feat(TheHive Node): Overhaul (#6457)

packages/nodes-base/nodes/TheHiveProject/actions/case/addAttachment.operation.ts

@@ -0,0 +1,89 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { attachmentsUi, caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [
+	caseRLC,
+	attachmentsUi,
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		options: [
+			{
+				displayName: 'Rename Files',
+				name: 'canRename',
+				type: 'boolean',
+				description: 'Whether to rename the file in case a file with the same name already exists',
+				default: false,
+			},
+		],
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['addAttachment'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+	const canRename = this.getNodeParameter('options.canRename', i, false) as boolean;
+
+	const inputDataFields = (
+		this.getNodeParameter('attachmentsUi.values', i, []) as IDataObject[]
+	).map((entry) => (entry.field as string).trim());
+
+	const attachments = [];
+
+	for (const inputDataField of inputDataFields) {
+		const binaryData = this.helpers.assertBinaryData(i, inputDataField);
+		const dataBuffer = await this.helpers.getBinaryDataBuffer(i, inputDataField);
+
+		attachments.push({
+			value: dataBuffer,
+			options: {
+				contentType: binaryData.mimeType,
+				filename: binaryData.fileName,
+			},
+		});
+	}
+
+	responseData = await theHiveApiRequest.call(
+		this,
+		'POST',
+		`/v1/case/${caseId}/attachments`,
+		undefined,
+		undefined,
+		undefined,
+		{
+			Headers: {
+				'Content-Type': 'multipart/form-data',
+			},
+			formData: {
+				attachments,
+				canRename: JSON.stringify(canRename),
+			},
+		},
+	);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/create.operation.ts

@@ -0,0 +1,82 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+
+import { theHiveApiRequest } from '../../transport';
+
+import set from 'lodash/set';
+
+import { fixFieldType, prepareInputItem } from '../../helpers/utils';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Fields',
+		name: 'caseFields',
+		type: 'resourceMapper',
+		default: {
+			mappingMode: 'defineBelow',
+			value: null,
+		},
+		noDataExpression: true,
+		required: true,
+		typeOptions: {
+			resourceMapper: {
+				resourceMapperMethod: 'getCaseFields',
+				mode: 'add',
+				valuesLabel: 'Fields',
+			},
+		},
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['create'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	i: number,
+	item: INodeExecutionData,
+): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+	let inputData: IDataObject = {};
+
+	const dataMode = this.getNodeParameter('caseFields.mappingMode', i) as string;
+
+	if (dataMode === 'autoMapInputData') {
+		const schema = this.getNodeParameter('caseFields.schema', i) as IDataObject[];
+		inputData = prepareInputItem(item.json, schema, i);
+	}
+
+	if (dataMode === 'defineBelow') {
+		const caseFields = this.getNodeParameter('caseFields.value', i, []) as IDataObject;
+		inputData = caseFields;
+	}
+
+	inputData = fixFieldType(inputData);
+
+	const body: IDataObject = {};
+
+	for (const field of Object.keys(inputData)) {
+		// use set to construct the updateBody, as it allows to process customFields.fieldName
+		// if customFields provided under customFields property, it will be send as is
+		set(body, field, inputData[field]);
+	}
+
+	responseData = await theHiveApiRequest.call(this, 'POST', '/v1/case' as string, body);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/deleteAttachment.operation.ts

@@ -0,0 +1,42 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeProperties } from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [
+	caseRLC,
+	{
+		displayName: 'Attachment Name or ID',
+		name: 'attachmentId',
+		type: 'options',
+		default: '',
+		required: true,
+		description:
+			'ID of the attachment. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+		typeOptions: {
+			loadOptionsMethod: 'loadCaseAttachments',
+		},
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['deleteAttachment'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+	const attachmentId = this.getNodeParameter('attachmentId', i) as string;
+
+	await theHiveApiRequest.call(this, 'DELETE', `/v1/case/${caseId}/attachment/${attachmentId}`);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData({ success: true }), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/deleteCase.operation.ts

@@ -0,0 +1,27 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeProperties } from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [caseRLC];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['deleteCase'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+
+	await theHiveApiRequest.call(this, 'DELETE', `/v1/case/${caseId}`);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData({ success: true }), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/executeResponder.operation.ts

@@ -0,0 +1,73 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { caseRLC, responderOptions } from '../../descriptions';
+import { theHiveApiRequest } from '../../transport';
+
+const properties: INodeProperties[] = [{ ...caseRLC, name: 'id' }, responderOptions];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['executeResponder'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+
+	const caseId = this.getNodeParameter('id', i, '', { extractValue: true }) as string;
+	const responderId = this.getNodeParameter('responder', i) as string;
+	let body: IDataObject;
+	let response;
+	responseData = [];
+	body = {
+		responderId,
+		objectId: caseId,
+		objectType: 'case',
+	};
+	response = await theHiveApiRequest.call(this, 'POST', '/connector/cortex/action' as string, body);
+	body = {
+		query: [
+			{
+				_name: 'listAction',
+			},
+			{
+				_name: 'filter',
+				_and: [
+					{
+						_field: 'cortexId',
+						_value: response.cortexId,
+					},
+					{
+						_field: 'objectId',
+						_value: response.objectId,
+					},
+					{
+						_field: 'startDate',
+						_value: response.startDate,
+					},
+				],
+			},
+		],
+	};
+	const qs: IDataObject = {};
+	qs.name = 'log-actions';
+	do {
+		response = await theHiveApiRequest.call(this, 'POST', '/v1/query', body, qs);
+	} while (response.status === 'Waiting' || response.status === 'InProgress');
+
+	responseData = response;
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/get.operation.ts

@@ -0,0 +1,53 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [caseRLC];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['get'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+
+	const qs: IDataObject = {};
+
+	const body = {
+		query: [
+			{
+				_name: 'getCase',
+				idOrName: caseId,
+			},
+			{
+				_name: 'page',
+				from: 0,
+				to: 10,
+				extraData: ['attachmentCount'],
+			},
+		],
+	};
+
+	qs.name = `get-case-${caseId}`;
+
+	responseData = await theHiveApiRequest.call(this, 'POST', '/v1/query', body, qs);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/getAttachment.operation.ts

@@ -0,0 +1,112 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [
+	caseRLC,
+	{
+		displayName: 'Attachment Name or ID',
+		name: 'attachmentId',
+		type: 'options',
+		default: '',
+		required: true,
+		description:
+			'ID of the attachment. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+		typeOptions: {
+			loadOptionsMethod: 'loadCaseAttachments',
+			loadOptionsDependsOn: ['caseId.value'],
+		},
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		options: [
+			{
+				displayName: 'File Name',
+				name: 'fileName',
+				type: 'string',
+				default: '',
+				description: 'Rename the file when downloading',
+			},
+			{
+				displayName: 'Data Property Name',
+				name: 'dataPropertyName',
+				type: 'string',
+				default: 'data',
+				description: 'Name of the binary property to which write the data of the attachment',
+			},
+		],
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['getAttachment'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+	const options = this.getNodeParameter('options', i);
+	const attachmentId = this.getNodeParameter('attachmentId', i) as string;
+
+	const requestOptions = {
+		useStream: true,
+		resolveWithFullResponse: true,
+		encoding: null,
+		json: false,
+	};
+
+	const response = await theHiveApiRequest.call(
+		this,
+		'GET',
+		`/v1/case/${caseId}/attachment/${attachmentId}/download`,
+		undefined,
+		undefined,
+		undefined,
+		requestOptions,
+	);
+
+	const mimeType = (response.headers as IDataObject)?.['content-type'] ?? undefined;
+
+	let fileName = (options.fileName as string) || 'attachment';
+
+	if (!options.fileName && response.headers['content-disposition'] !== undefined) {
+		const contentDisposition = response.headers['content-disposition'] as string;
+		const fileNameMatch = contentDisposition.match(/filename="(.+)"/);
+		if (fileNameMatch !== null) {
+			fileName = fileNameMatch[1];
+		}
+	}
+
+	const newItem: INodeExecutionData = {
+		json: {
+			_id: attachmentId,
+			caseId,
+			fileName,
+			mimeType,
+		},
+		binary: {},
+	};
+
+	newItem.binary![(options.dataPropertyName as string) || 'data'] =
+		await this.helpers.prepareBinaryData(response.body as Buffer, fileName, mimeType as string);
+
+	const executionData = this.helpers.constructExecutionMetaData([newItem], {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/getTimeline.operation.ts

@@ -0,0 +1,34 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import { theHiveApiRequest } from '../../transport';
+import { caseRLC } from '../../descriptions';
+
+const properties: INodeProperties[] = [caseRLC];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['getTimeline'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+
+	const caseId = this.getNodeParameter('caseId', i, '', { extractValue: true }) as string;
+
+	responseData = await theHiveApiRequest.call(this, 'GET', `/v1/case/${caseId}/timeline`);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/index.ts

@@ -0,0 +1,104 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+import * as addAttachment from './addAttachment.operation';
+
+import * as create from './create.operation';
+import * as deleteAttachment from './deleteAttachment.operation';
+import * as deleteCase from './deleteCase.operation';
+import * as executeResponder from './executeResponder.operation';
+import * as get from './get.operation';
+import * as getAttachment from './getAttachment.operation';
+import * as search from './search.operation';
+import * as getTimeline from './getTimeline.operation';
+import * as update from './update.operation';
+
+export {
+	addAttachment,
+	create,
+	deleteAttachment,
+	deleteCase,
+	executeResponder,
+	get,
+	search,
+	getAttachment,
+	getTimeline,
+	update,
+};
+
+export const description: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		default: 'create',
+		type: 'options',
+		noDataExpression: true,
+		required: true,
+		options: [
+			{
+				name: 'Add Attachment',
+				value: 'addAttachment',
+				action: 'Add attachment to a case',
+			},
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a case',
+			},
+			{
+				name: 'Delete Attachment',
+				value: 'deleteAttachment',
+				action: 'Delete attachment from a case',
+			},
+			{
+				name: 'Delete Case',
+				value: 'deleteCase',
+				action: 'Delete an case',
+			},
+			{
+				name: 'Execute Responder',
+				value: 'executeResponder',
+				action: 'Execute responder on a case',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a case',
+			},
+			{
+				name: 'Get Attachment',
+				value: 'getAttachment',
+				action: 'Get attachment from a case',
+			},
+			{
+				name: 'Get Timeline',
+				value: 'getTimeline',
+				action: 'Get timeline of a case',
+			},
+			{
+				name: 'Search',
+				value: 'search',
+				action: 'Search cases',
+			},
+			{
+				name: 'Update',
+				value: 'update',
+				action: 'Update a case',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['case'],
+			},
+		},
+	},
+	...addAttachment.description,
+	...create.description,
+	...deleteAttachment.description,
+	...deleteCase.description,
+	...executeResponder.description,
+	...get.description,
+	...getAttachment.description,
+	...search.description,
+	...getTimeline.description,
+	...update.description,
+];

packages/nodes-base/nodes/TheHiveProject/actions/case/search.operation.ts

@@ -0,0 +1,60 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+import {
+	genericFiltersCollection,
+	returnAllAndLimit,
+	searchOptions,
+	sortCollection,
+} from '../../descriptions';
+import { theHiveApiQuery } from '../../transport';
+
+const properties: INodeProperties[] = [
+	...returnAllAndLimit,
+	genericFiltersCollection,
+	sortCollection,
+	searchOptions,
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['search'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]> {
+	let responseData: IDataObject | IDataObject[] = [];
+
+	const filtersValues = this.getNodeParameter('filters.values', i, []) as IDataObject[];
+	const sortFields = this.getNodeParameter('sort.fields', i, []) as IDataObject[];
+	const returnAll = this.getNodeParameter('returnAll', i);
+	const { returnCount, extraData } = this.getNodeParameter('options', i);
+	let limit;
+
+	if (!returnAll) {
+		limit = this.getNodeParameter('limit', i);
+	}
+
+	responseData = await theHiveApiQuery.call(
+		this,
+		{ query: 'listCase' },
+		filtersValues,
+		sortFields,
+		limit,
+		returnCount as boolean,
+		extraData as string[],
+	);
+
+	const executionData = this.helpers.constructExecutionMetaData(wrapData(responseData), {
+		itemData: { item: i },
+	});
+
+	return executionData;
+}

packages/nodes-base/nodes/TheHiveProject/actions/case/update.operation.ts

@@ -0,0 +1,147 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+import { NodeOperationError } from 'n8n-workflow';
+import { updateDisplayOptions, wrapData } from '@utils/utilities';
+
+import { theHiveApiRequest } from '../../transport';
+import { fixFieldType, prepareInputItem } from '../../helpers/utils';
+import set from 'lodash/set';
+
+const properties: INodeProperties[] = [
+	{
+		displayName: 'Fields',
+		name: 'caseUpdateFields',
+		type: 'resourceMapper',
+		default: {
+			mappingMode: 'defineBelow',
+			value: null,
+		},
+		noDataExpression: true,
+		required: true,
+		typeOptions: {
+			resourceMapper: {
+				resourceMapperMethod: 'getCaseUpdateFields',
+				mode: 'update',
+				valuesLabel: 'Fields',
+				addAllFields: true,
+				multiKeyMatch: true,
+			},
+		},
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['case'],
+		operation: ['update'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(
+	this: IExecuteFunctions,
+	i: number,
+	item: INodeExecutionData,
+): Promise<INodeExecutionData[]> {
+	let body: IDataObject = {};
+	let updated = 1;
+
+	const dataMode = this.getNodeParameter('caseUpdateFields.mappingMode', i) as string;
+
+	if (dataMode === 'autoMapInputData') {
+		const schema = this.getNodeParameter('caseUpdateFields.schema', i) as IDataObject[];
+		body = prepareInputItem(item.json, schema, i);
+	}
+
+	if (dataMode === 'defineBelow') {
+		const caseUpdateFields = this.getNodeParameter('caseUpdateFields.value', i, []) as IDataObject;
+		body = caseUpdateFields;
+	}
+
+	body = fixFieldType(body);
+
+	const fieldsToMatchOn = this.getNodeParameter('caseUpdateFields.matchingColumns', i) as string[];
+
+	const updateBody: IDataObject = {};
+	const matchFields: IDataObject = {};
+	const { id } = body; // id would be used if matching on id, also we need to remove it from the body
+
+	for (const field of Object.keys(body)) {
+		if (field === 'customFields') {
+			//in input data customFields sent as an object, parse it extracting customFields that are used for matching
+			const customFields: IDataObject = {};
+			for (const customField of Object.keys(body.customFields || {})) {
+				const customFieldPath = `customFields.${customField}`;
+				if (fieldsToMatchOn.includes(customFieldPath)) {
+					matchFields[customFieldPath] = (body.customFields as IDataObject)[customField];
+				} else {
+					customFields[customField] = (body.customFields as IDataObject)[customField];
+				}
+			}
+			set(updateBody, 'customFields', customFields);
+			continue;
+		}
+		if (fieldsToMatchOn.includes(field)) {
+			// if field is in fieldsToMatchOn, we need to exclude it from the updateBody, as values used for matching should not be updated
+			matchFields[field] = body[field];
+		} else {
+			// use set to construct the updateBody, as it allows to process customFields.fieldName
+			// if customFields provided under customFields property, it will be send as is
+			set(updateBody, field, body[field]);
+		}
+	}
+
+	if (fieldsToMatchOn.includes('id')) {
+		await theHiveApiRequest.call(this, 'PATCH', `/v1/case/${id}`, body);
+	} else {
+		const filter = {
+			_name: 'filter',
+			_and: fieldsToMatchOn.map((field) => ({
+				_eq: {
+					_field: field,
+					_value: matchFields[field],
+				},
+			})),
+		};
+
+		const queryBody = {
+			query: [
+				{
+					_name: 'listCase',
+				},
+				filter,
+			],
+		};
+
+		const matches = (await theHiveApiRequest.call(
+			this,
+			'POST',
+			'/v1/query',
+			queryBody,
+		)) as IDataObject[];
+
+		if (!matches.length) {
+			throw new NodeOperationError(this.getNode(), 'No matching alerts found');
+		}
+		const ids = matches.map((match) => match._id);
+		updated = ids.length;
+
+		updateBody.ids = ids;
+
+		await theHiveApiRequest.call(this, 'PATCH', '/v1/case/_bulk', updateBody);
+	}
+
+	const executionData = this.helpers.constructExecutionMetaData(
+		wrapData({ success: true, updated }),
+		{
+			itemData: { item: i },
+		},
+	);
+
+	return executionData;
+}