feat(Data Table Node): Add bulk insert mode (no-changelog) (#19294)

packages/nodes-base/nodes/DataTable/actions/router.ts

@@ -15,7 +15,7 @@ type DataTableNodeType = AllEntities<{
 
 const BULK_OPERATIONS = ['insert'] as const;
 
-function canBulk(operation: string): operation is (typeof BULK_OPERATIONS)[number] {
+function hasBulkExecute(operation: string): operation is (typeof BULK_OPERATIONS)[number] {
 	return (BULK_OPERATIONS as readonly string[]).includes(operation);
 }
 
@@ -41,7 +41,7 @@ export async function router(this: IExecuteFunctions): Promise<INodeExecutionDat
 	} as DataTableNodeType;
 
 	// If the operation supports
-	if (canBulk(dataTableNodeData.operation) && !hasComplexId(this)) {
+	if (hasBulkExecute(dataTableNodeData.operation) && !hasComplexId(this)) {
 		try {
 			const proxy = await getDataTableProxyExecute(this);
 
@@ -66,7 +66,8 @@ export async function router(this: IExecuteFunctions): Promise<INodeExecutionDat
 					itemData: { item: i },
 				});
 
-				operationResult.push.apply(operationResult, executionData);
+				// pushing here risks stack overflows for very high numbers (~100k) of results on filter-based queries (update, get, etc.)
+				operationResult = operationResult.concat(executionData);
 			} catch (error) {
 				if (this.continueOnFail()) {
 					operationResult.push({

packages/nodes-base/nodes/DataTable/actions/row/insert.operation.ts

@@ -18,26 +18,63 @@ const displayOptions: IDisplayOptions = {
 	},
 };
 
-export const description: INodeProperties[] = [makeAddRow(FIELD, displayOptions)];
+export const description: INodeProperties[] = [
+	makeAddRow(FIELD, displayOptions),
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Option',
+		default: {},
+		options: [
+			{
+				displayName: 'Optimize Bulk',
+				name: 'optimizeBulk',
+				type: 'boolean',
+				default: false,
+				noDataExpression: true, // bulk inserts don't support expressions so this is a bit paradoxical
+				description: 'Whether to improve bulk insert performance 5x by not returning inserted data',
+			},
+		],
+		displayOptions,
+	},
+];
 
 export async function execute(
 	this: IExecuteFunctions,
 	index: number,
 ): Promise<INodeExecutionData[]> {
+	const optimizeBulkEnabled = this.getNodeParameter('options.optimizeBulk', index, false);
 	const dataStoreProxy = await getDataTableProxyExecute(this, index);
 
 	const row = getAddRow(this, index);
 
-	const insertedRows = await dataStoreProxy.insertRows([row]);
-	return insertedRows.map((json) => ({ json }));
+	if (optimizeBulkEnabled) {
+		// This function is always called by index, so we inherently cannot operate in bulk
+		this.addExecutionHints({
+			message: 'Unable to optimize bulk insert due to expression in Data Table ID ',
+			location: 'outputPane',
+		});
+		const json = await dataStoreProxy.insertRows([row], 'count');
+		return [{ json }];
+	} else {
+		const insertedRows = await dataStoreProxy.insertRows([row], 'all');
+		return insertedRows.map((json, item) => ({ json, pairedItem: { item } }));
+	}
 }
 
 export async function executeBulk(
 	this: IExecuteFunctions,
 	proxy: IDataStoreProjectService,
 ): Promise<INodeExecutionData[]> {
+	const optimizeBulkEnabled = this.getNodeParameter('options.optimizeBulk', 0, false);
 	const rows = this.getInputData().flatMap((_, i) => [getAddRow(this, i)]);
 
-	const insertedRows = await proxy.insertRows(rows);
-	return insertedRows.map((json, item) => ({ json, pairedItem: { item } }));
+	if (optimizeBulkEnabled) {
+		const json = await proxy.insertRows(rows, 'count');
+		return [{ json }];
+	} else {
+		const insertedRows = await proxy.insertRows(rows, 'all');
+		return insertedRows.map((json, item) => ({ json, pairedItem: { item } }));
+	}
 }