@mondaydotcomorg/atp-compiler 0.17.14

package/src/transformer/array-transformer-wrappers.ts

@@ -0,0 +1,165 @@
+import * as t from '@babel/types';
+
+/**
+ * Wrap batch result with post-processing for filter()
+ * Filter must return filtered ITEMS, not boolean results
+ */
+export function wrapFilterResult(
+	batchCall: t.AwaitExpression,
+	array: t.Expression,
+	methodId: string
+): t.Expression {
+	const resultsVar = `__filter_results_${methodId}`;
+	const indexVar = `__i_${methodId}`;
+	const arrayClone = t.cloneNode(array, true);
+
+	return t.awaitExpression(
+		t.callExpression(
+			t.arrowFunctionExpression(
+				[],
+				t.blockStatement([
+					t.variableDeclaration('const', [
+						t.variableDeclarator(t.identifier(resultsVar), batchCall.argument),
+					]),
+					t.returnStatement(
+						t.callExpression(t.memberExpression(arrayClone, t.identifier('filter')), [
+							t.arrowFunctionExpression(
+								[t.identifier('_'), t.identifier(indexVar)],
+								t.callExpression(t.identifier('Boolean'), [
+									t.memberExpression(t.identifier(resultsVar), t.identifier(indexVar), true),
+								])
+							),
+						])
+					),
+				]),
+				true
+			),
+			[]
+		)
+	);
+}
+
+/**
+ * Wrap batch result with post-processing for find()
+ * Find must return first matching ITEM (not boolean)
+ */
+export function wrapFindResult(
+	batchCall: t.AwaitExpression,
+	array: t.Expression,
+	methodId: string
+): t.Expression {
+	const resultsVar = `__find_results_${methodId}`;
+	const arrayClone = t.cloneNode(array, true);
+
+	return t.awaitExpression(
+		t.callExpression(
+			t.arrowFunctionExpression(
+				[],
+				t.blockStatement([
+					t.variableDeclaration('const', [
+						t.variableDeclarator(t.identifier(resultsVar), batchCall.argument),
+					]),
+					t.returnStatement(
+						t.callExpression(t.memberExpression(arrayClone, t.identifier('find')), [
+							t.arrowFunctionExpression(
+								[t.identifier('_'), t.identifier('__i')],
+								t.callExpression(t.identifier('Boolean'), [
+									t.memberExpression(t.identifier(resultsVar), t.identifier('__i'), true),
+								])
+							),
+						])
+					),
+				]),
+				true
+			),
+			[]
+		)
+	);
+}
+
+/**
+ * Wrap batch result with post-processing for some()
+ * Some must return boolean: true if ANY result is truthy
+ */
+export function wrapSomeResult(batchCall: t.AwaitExpression, methodId: string): t.Expression {
+	const resultsVar = `__some_results_${methodId}`;
+
+	return t.awaitExpression(
+		t.callExpression(
+			t.arrowFunctionExpression(
+				[],
+				t.blockStatement([
+					t.variableDeclaration('const', [
+						t.variableDeclarator(t.identifier(resultsVar), batchCall.argument),
+					]),
+					t.returnStatement(
+						t.callExpression(t.memberExpression(t.identifier(resultsVar), t.identifier('some')), [
+							t.arrowFunctionExpression(
+								[t.identifier('r')],
+								t.callExpression(t.identifier('Boolean'), [t.identifier('r')])
+							),
+						])
+					),
+				]),
+				true
+			),
+			[]
+		)
+	);
+}
+
+/**
+ * Wrap batch result with post-processing for every()
+ * Every must return boolean: true if ALL results are truthy
+ */
+export function wrapEveryResult(batchCall: t.AwaitExpression, methodId: string): t.Expression {
+	const resultsVar = `__every_results_${methodId}`;
+
+	return t.awaitExpression(
+		t.callExpression(
+			t.arrowFunctionExpression(
+				[],
+				t.blockStatement([
+					t.variableDeclaration('const', [
+						t.variableDeclarator(t.identifier(resultsVar), batchCall.argument),
+					]),
+					t.returnStatement(
+						t.callExpression(t.memberExpression(t.identifier(resultsVar), t.identifier('every')), [
+							t.arrowFunctionExpression(
+								[t.identifier('r')],
+								t.callExpression(t.identifier('Boolean'), [t.identifier('r')])
+							),
+						])
+					),
+				]),
+				true
+			),
+			[]
+		)
+	);
+}
+
+/**
+ * Wrap batch result if method needs post-processing
+ */
+export function wrapBatchResultIfNeeded(
+	batchCall: t.AwaitExpression,
+	methodName: string,
+	array: t.Expression,
+	methodId: string
+): t.Expression {
+	switch (methodName) {
+		case 'filter':
+			return wrapFilterResult(batchCall, array, methodId);
+		case 'find':
+			return wrapFindResult(batchCall, array, methodId);
+		case 'some':
+			return wrapSomeResult(batchCall, methodId);
+		case 'every':
+			return wrapEveryResult(batchCall, methodId);
+		case 'forEach':
+			return batchCall;
+		default:
+			return batchCall;
+	}
+}

package/src/transformer/array-transformer.ts

@@ -0,0 +1,76 @@
+import * as t from '@babel/types';
+import { BatchOptimizer } from './batch-optimizer.js';
+import { BatchParallelDetector } from './batch-detector.js';
+import { getArrayMethodName, canUseBatchParallel } from './array-transformer-utils.js';
+import { transformToBatchParallel } from './array-transformer-batch.js';
+import { transformToSequential } from './array-transformer-sequential.js';
+
+export class ArrayTransformer {
+	private transformCount = 0;
+	private batchOptimizer: BatchOptimizer;
+	private batchDetector: BatchParallelDetector;
+	private batchSizeThreshold: number;
+
+	constructor(batchSizeThreshold: number = 10) {
+		this.batchOptimizer = new BatchOptimizer();
+		this.batchDetector = new BatchParallelDetector();
+		this.batchSizeThreshold = batchSizeThreshold;
+	}
+
+	transformArrayMethod(path: any): boolean {
+		const node = path.node as t.CallExpression;
+
+		const methodName = getArrayMethodName(node);
+		if (!methodName) {
+			return false;
+		}
+
+		const callback = node.arguments[0];
+		if (!callback || !t.isFunction(callback) || !callback.async) {
+			return false;
+		}
+
+		const batchResult = this.batchOptimizer.canBatchArrayMethod(callback);
+
+		if (batchResult.canBatch && canUseBatchParallel(methodName)) {
+			const array = (node.callee as t.MemberExpression).object;
+			const decision = this.batchOptimizer.makeSmartBatchDecision(
+				methodName,
+				batchResult,
+				array,
+				this.batchSizeThreshold
+			);
+
+			if (decision.shouldBatch) {
+				return transformToBatchParallel(
+					path,
+					node,
+					methodName,
+					callback,
+					this.batchDetector,
+					() => this.transformCount++,
+					() => this.doTransformToSequential(path, node, methodName, callback)
+				);
+			}
+		}
+
+		return this.doTransformToSequential(path, node, methodName, callback);
+	}
+
+	private doTransformToSequential(
+		path: any,
+		node: t.CallExpression,
+		methodName: string,
+		callback: t.Function
+	): boolean {
+		return transformToSequential(path, node, methodName, callback, () => this.transformCount++);
+	}
+
+	getTransformCount(): number {
+		return this.transformCount;
+	}
+
+	resetTransformCount(): void {
+		this.transformCount = 0;
+	}
+}

package/src/transformer/batch-detector.ts

@@ -0,0 +1,166 @@
+import * as t from '@babel/types';
+import type { BatchCallInfo } from '../types.js';
+import { isPausableCallExpression, getMemberExpressionPath } from './utils.js';
+
+export class BatchParallelDetector {
+	canBatch(promiseAllNode: t.CallExpression): boolean {
+		const arrayArg = promiseAllNode.arguments[0];
+
+		if (!t.isArrayExpression(arrayArg)) {
+			return false;
+		}
+
+		if (arrayArg.elements.length === 0) {
+			return false;
+		}
+
+		return arrayArg.elements.every((el) => {
+			if (!el || t.isSpreadElement(el)) {
+				return false;
+			}
+
+			return this.isDirectPausableCall(el);
+		});
+	}
+
+	private isDirectPausableCall(node: t.Node): boolean {
+		if (t.isAwaitExpression(node)) {
+			node = node.argument;
+		}
+
+		if (!t.isCallExpression(node)) {
+			return false;
+		}
+
+		return isPausableCallExpression(node);
+	}
+
+	extractBatchCalls(arrayNode: t.ArrayExpression): BatchCallInfo[] {
+		const calls: BatchCallInfo[] = [];
+
+		for (const el of arrayNode.elements) {
+			if (!el || t.isSpreadElement(el)) {
+				continue;
+			}
+
+			let callNode: t.Node = el;
+			if (t.isAwaitExpression(callNode)) {
+				callNode = callNode.argument;
+			}
+
+			if (!t.isCallExpression(callNode)) {
+				continue;
+			}
+
+			const callInfo = this.extractCallInfo(callNode);
+			if (callInfo) {
+				calls.push(callInfo);
+			}
+		}
+
+		return calls;
+	}
+
+	extractCallInfo(callNode: t.CallExpression): BatchCallInfo | null {
+		if (!t.isMemberExpression(callNode.callee)) {
+			return null;
+		}
+
+		const path = getMemberExpressionPath(callNode.callee);
+		const parts = path.split('.');
+
+		if (parts.length < 3) {
+			return null;
+		}
+
+		const [namespace, service, method] = parts;
+		if (namespace !== 'atp' || !method) {
+			return null;
+		}
+
+		const type = service as 'llm' | 'approval' | 'embedding';
+		const payload = this.extractPayload(callNode.arguments as t.Expression[]);
+
+		return {
+			type,
+			operation: method,
+			payload,
+		};
+	}
+
+	/**
+	 * Extract payload AST node directly
+	 */
+	extractPayloadNode(callNode: t.CallExpression): t.Expression | null {
+		if (callNode.arguments.length === 0) {
+			return t.objectExpression([]);
+		}
+
+		const firstArg = callNode.arguments[0];
+		if (!firstArg || t.isSpreadElement(firstArg) || !t.isExpression(firstArg)) {
+			return null;
+		}
+
+		return firstArg;
+	}
+
+	private extractPayload(args: Array<t.Expression | t.SpreadElement>): Record<string, unknown> {
+		if (args.length === 0) {
+			return {};
+		}
+
+		const firstArg = args[0];
+		if (t.isSpreadElement(firstArg)) {
+			return {};
+		}
+
+		if (t.isObjectExpression(firstArg)) {
+			return this.objectExpressionToRecord(firstArg);
+		}
+
+		if (t.isStringLiteral(firstArg)) {
+			return { message: firstArg.value };
+		}
+
+		return {};
+	}
+
+	private objectExpressionToRecord(obj: t.ObjectExpression): Record<string, unknown> {
+		const record: Record<string, unknown> = {};
+
+		for (const prop of obj.properties) {
+			if (t.isObjectProperty(prop) && !prop.computed) {
+				const key = t.isIdentifier(prop.key) ? prop.key.name : String(prop.key);
+				const value = this.extractValue(prop.value);
+				record[key] = value;
+			}
+		}
+
+		return record;
+	}
+
+	private extractValue(node: t.Node): unknown {
+		if (t.isStringLiteral(node)) {
+			return node.value;
+		}
+		if (t.isNumericLiteral(node)) {
+			return node.value;
+		}
+		if (t.isBooleanLiteral(node)) {
+			return node.value;
+		}
+		if (t.isNullLiteral(node)) {
+			return null;
+		}
+		if (t.isArrayExpression(node)) {
+			return node.elements.map((el) =>
+				el && !t.isSpreadElement(el) ? this.extractValue(el) : null
+			);
+		}
+		if (t.isObjectExpression(node)) {
+			return this.objectExpressionToRecord(node);
+		}
+
+		return undefined;
+	}
+}

package/src/transformer/batch-optimizer.ts

@@ -0,0 +1,320 @@
+import * as t from '@babel/types';
+import { isPausableCallExpression } from './utils.js';
+
+export interface BatchOptimizationResult {
+	canBatch: boolean;
+	reason?: string;
+	llmCallPattern?: 'single' | 'multiple' | 'conditional';
+	hasConditionals?: boolean;
+	hasLoops?: boolean;
+}
+
+export interface SmartBatchDecision {
+	shouldBatch: boolean;
+	reason: string;
+	strategy: 'always-batch' | 'size-dependent' | 'never-batch';
+}
+
+export class BatchOptimizer {
+	private arrayMethodsWithEarlyExit = ['find', 'some', 'every'];
+
+	canBatchArrayMethod(callback: t.Function): BatchOptimizationResult {
+		if (!callback.async) {
+			return { canBatch: false, reason: 'Not async' };
+		}
+
+		const body = callback.body;
+
+		if (!t.isBlockStatement(body)) {
+			if (t.isAwaitExpression(body)) {
+				if (this.isDirectPausableCall(body.argument)) {
+					return { canBatch: true, llmCallPattern: 'single', hasConditionals: false };
+				}
+			}
+			return { canBatch: false, reason: 'Non-block body without direct call' };
+		}
+
+		const statements = body.body;
+
+		if (statements.length === 0) {
+			return { canBatch: false, reason: 'Empty body' };
+		}
+
+		let hasConditionals = false;
+		let hasLoops = false;
+		let hasTryCatch = false;
+
+		for (const stmt of statements) {
+			if (t.isIfStatement(stmt) || t.isSwitchStatement(stmt)) {
+				hasConditionals = true;
+			}
+
+			if (t.isTryStatement(stmt)) {
+				hasTryCatch = true;
+			}
+
+			if (
+				t.isForStatement(stmt) ||
+				t.isForOfStatement(stmt) ||
+				t.isForInStatement(stmt) ||
+				t.isWhileStatement(stmt) ||
+				t.isDoWhileStatement(stmt)
+			) {
+				hasLoops = true;
+			}
+
+			if (t.isBreakStatement(stmt) || t.isContinueStatement(stmt)) {
+				return { canBatch: false, reason: 'Contains break/continue' };
+			}
+
+			if (t.isReturnStatement(stmt) && stmt !== statements[statements.length - 1]) {
+				return { canBatch: false, reason: 'Early return' };
+			}
+		}
+
+		if (hasLoops) {
+			return { canBatch: false, reason: 'Contains loops', hasLoops: true };
+		}
+
+		if (hasTryCatch) {
+			return { canBatch: false, reason: 'Contains try-catch' };
+		}
+
+		const pausableCalls = this.countPausableCalls(body);
+		if (pausableCalls === 0) {
+			return { canBatch: false, reason: 'No pausable calls' };
+		}
+
+		if (pausableCalls > 1) {
+			return { canBatch: false, reason: 'Multiple pausable calls', llmCallPattern: 'multiple' };
+		}
+
+		if (hasConditionals) {
+			return {
+				canBatch: true,
+				llmCallPattern: 'conditional',
+				hasConditionals: true,
+				reason: 'Simple conditional - can batch but consider array size',
+			};
+		}
+
+		return { canBatch: true, llmCallPattern: 'single', hasConditionals: false };
+	}
+
+	/**
+	 * Smart decision: Should we batch based on array size and method type?
+	 */
+	makeSmartBatchDecision(
+		methodName: string,
+		batchResult: BatchOptimizationResult,
+		arrayNode: t.Expression,
+		threshold: number = 10
+	): SmartBatchDecision {
+		if (!batchResult.canBatch) {
+			return {
+				shouldBatch: false,
+				reason: 'Complex callback - use sequential',
+				strategy: 'never-batch',
+			};
+		}
+
+		if (!batchResult.hasConditionals) {
+			return {
+				shouldBatch: true,
+				reason: 'Simple callback - batching is faster',
+				strategy: 'always-batch',
+			};
+		}
+
+		const hasEarlyExitBenefit = this.arrayMethodsWithEarlyExit.includes(methodName);
+
+		if (!hasEarlyExitBenefit) {
+			const arraySize = this.estimateArraySize(arrayNode);
+
+			if (arraySize !== null && arraySize < threshold) {
+				return {
+					shouldBatch: true,
+					reason: `Small array (${arraySize} < ${threshold}) - batch despite conditionals`,
+					strategy: 'size-dependent',
+				};
+			}
+
+			return {
+				shouldBatch: false,
+				reason: 'Conditionals + large/unknown array - sequential for safety',
+				strategy: 'size-dependent',
+			};
+		}
+
+		const arraySize = this.estimateArraySize(arrayNode);
+
+		if (arraySize !== null && arraySize < threshold) {
+			return {
+				shouldBatch: true,
+				reason: `Small array (${arraySize} < ${threshold}) - batch for speed`,
+				strategy: 'size-dependent',
+			};
+		}
+
+		if (arraySize !== null && arraySize >= threshold) {
+			return {
+				shouldBatch: false,
+				reason: `Large array (${arraySize} >= ${threshold}) + conditionals - sequential for early-exit savings`,
+				strategy: 'size-dependent',
+			};
+		}
+
+		if (t.isArrayExpression(arrayNode)) {
+			return {
+				shouldBatch: true,
+				reason: 'Array literal (likely small) - batch',
+				strategy: 'size-dependent',
+			};
+		}
+
+		return {
+			shouldBatch: false,
+			reason: 'Unknown array size + conditionals - sequential for safety',
+			strategy: 'size-dependent',
+		};
+	}
+
+	private estimateArraySize(arrayNode: t.Expression): number | null {
+		if (t.isArrayExpression(arrayNode)) {
+			return arrayNode.elements.length;
+		}
+
+		return null;
+	}
+
+	canBatchForOfLoop(loopNode: t.ForOfStatement): BatchOptimizationResult {
+		const body = loopNode.body;
+
+		if (!t.isBlockStatement(body)) {
+			return { canBatch: false, reason: 'Loop body not a block' };
+		}
+
+		const statements = body.body;
+
+		if (statements.length === 0) {
+			return { canBatch: false, reason: 'Empty loop body' };
+		}
+
+		const hasBreakOrContinue = this.containsBreakOrContinue(body);
+		if (hasBreakOrContinue) {
+			return { canBatch: false, reason: 'Contains break/continue' };
+		}
+
+		let hasConditionals = false;
+
+		for (const stmt of statements) {
+			if (t.isIfStatement(stmt) || t.isSwitchStatement(stmt)) {
+				hasConditionals = true;
+			}
+
+			if (
+				t.isForStatement(stmt) ||
+				t.isForOfStatement(stmt) ||
+				t.isForInStatement(stmt) ||
+				t.isWhileStatement(stmt) ||
+				t.isDoWhileStatement(stmt)
+			) {
+				return { canBatch: false, reason: 'Contains nested loops', hasLoops: true };
+			}
+		}
+
+		const pausableCalls = this.countPausableCalls(body);
+		if (pausableCalls === 0) {
+			return { canBatch: false, reason: 'No pausable calls' };
+		}
+
+		if (pausableCalls > 1) {
+			return { canBatch: false, reason: 'Multiple pausable calls', llmCallPattern: 'multiple' };
+		}
+
+		if (hasConditionals) {
+			return {
+				canBatch: true,
+				llmCallPattern: 'conditional',
+				hasConditionals: true,
+				reason: 'Simple conditional - can batch but consider array size',
+			};
+		}
+
+		return { canBatch: true, llmCallPattern: 'single', hasConditionals: false };
+	}
+
+	private containsBreakOrContinue(node: t.Node): boolean {
+		let found = false;
+
+		const visit = (n: t.Node) => {
+			if (found) return;
+
+			if (t.isBreakStatement(n) || t.isContinueStatement(n)) {
+				found = true;
+				return;
+			}
+
+			if (
+				t.isForStatement(n) ||
+				t.isForOfStatement(n) ||
+				t.isForInStatement(n) ||
+				t.isWhileStatement(n) ||
+				t.isDoWhileStatement(n)
+			) {
+				return;
+			}
+
+			Object.keys(n).forEach((key) => {
+				const value = (n as any)[key];
+				if (Array.isArray(value)) {
+					value.forEach((item) => {
+						if (item && typeof item === 'object' && item.type) {
+							visit(item);
+						}
+					});
+				} else if (value && typeof value === 'object' && value.type) {
+					visit(value);
+				}
+			});
+		};
+
+		visit(node);
+		return found;
+	}
+
+	private isDirectPausableCall(node: t.Node): boolean {
+		if (!t.isCallExpression(node)) {
+			return false;
+		}
+
+		return isPausableCallExpression(node);
+	}
+
+	private countPausableCalls(body: t.BlockStatement): number {
+		let count = 0;
+
+		const visit = (node: t.Node) => {
+			if (t.isAwaitExpression(node) && this.isDirectPausableCall(node.argument)) {
+				count++;
+				return;
+			}
+
+			Object.keys(node).forEach((key) => {
+				const value = (node as any)[key];
+				if (Array.isArray(value)) {
+					value.forEach((item) => {
+						if (item && typeof item === 'object' && item.type) {
+							visit(item);
+						}
+					});
+				} else if (value && typeof value === 'object' && value.type) {
+					visit(value);
+				}
+			});
+		};
+
+		visit(body);
+		return count;
+	}
+}