@mastra/temporal 0.4.6-alpha.5 → 0.4.6-alpha.6

package/dist/worker.js

@@ -276,6 +276,80 @@ function rebaseModulePath(modulePath, sourceFilePath, outputFilePath) {
 	const resolvedPath = path.resolve(path.dirname(sourceFilePath), modulePath);
 	return normalizeImportPath(path.relative(path.dirname(outputFilePath), resolvedPath), path.extname(resolvedPath));
 }
+function parseWorkflowChain$1(node) {
+	const methods = [];
+	let current = node;
+	while (t.isCallExpression(current) && t.isMemberExpression(current.callee) && !current.callee.computed) {
+		if (!t.isIdentifier(current.callee.property)) return null;
+		methods.unshift({
+			name: current.callee.property.name,
+			args: current.arguments
+		});
+		current = current.callee.object;
+	}
+	if (!t.isCallExpression(current) || !t.isIdentifier(current.callee, { name: "createWorkflow" })) return null;
+	return {
+		createWorkflowCall: current,
+		methods
+	};
+}
+function getStaticWorkflowId(call, filePath) {
+	const [config] = call.arguments;
+	if (!t.isObjectExpression(config)) throw new Error(`Unable to determine workflow config in ${filePath}`);
+	for (const property of config.properties) {
+		if (!t.isObjectProperty(property) || getObjectPropertyName(property) !== "id") continue;
+		if (t.isStringLiteral(property.value)) return property.value.value;
+		if (t.isTemplateLiteral(property.value) && property.value.expressions.length === 0) return property.value.quasis[0]?.value.cooked ?? "";
+	}
+	throw new Error(`Workflow id must be a static string in ${filePath}`);
+}
+function toExportName(id) {
+	return id.replace(/[^a-zA-Z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^[^a-zA-Z_$]+/, "").replace(/^(.)/, (char) => char.toLowerCase());
+}
+function collectStaticFunctionBindings(program) {
+	const bindings = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		const declaration = t.isExportNamedDeclaration(statement) ? statement.declaration : statement;
+		if (t.isFunctionDeclaration(declaration) && declaration.id) {
+			bindings.add(declaration.id.name);
+			continue;
+		}
+		if (!t.isVariableDeclaration(declaration) || declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations) if (t.isIdentifier(declarator.id) && (t.isArrowFunctionExpression(declarator.init) || t.isFunctionExpression(declarator.init))) bindings.add(declarator.id.name);
+	}
+	return bindings;
+}
+function collectTopLevelBindingNames(program) {
+	const bindings = /* @__PURE__ */ new Set();
+	for (const statement of program.body) for (const name of Object.keys(t.getBindingIdentifiers(statement))) bindings.add(name);
+	return bindings;
+}
+function createMappingActivityStatements(workflowExpression, filePath, staticFunctionBindings, usedExportNames, addBinding) {
+	const chain = parseWorkflowChain$1(workflowExpression);
+	if (!chain) return [];
+	const workflowId = getStaticWorkflowId(chain.createWorkflowCall, filePath);
+	const statements = [];
+	let mappingOrdinal = 0;
+	for (const method of chain.methods) {
+		if (method.name !== "map") continue;
+		const [callback] = method.args;
+		if (t.isObjectExpression(callback)) throw new Error(`.map() in workflow ${workflowId} (${filePath}) does not yet support declarative object mappings`);
+		if (!t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback) && !(t.isIdentifier(callback) && staticFunctionBindings.has(callback.name))) throw new Error(`.map() in workflow ${workflowId} (${filePath}) requires an inline function or a statically declared function identifier`);
+		const mappingId = `mapping_${workflowId}_${mappingOrdinal++}`;
+		const baseExportName = toExportName(mappingId);
+		let exportName = baseExportName;
+		let exportSuffix = 1;
+		while (usedExportNames.has(exportName)) exportName = `${baseExportName}${exportSuffix++}`;
+		usedExportNames.add(exportName);
+		const params = t.objectPattern([t.objectProperty(t.identifier("inputData"), t.identifier("inputData"), false, true), t.objectProperty(t.identifier("initData"), t.identifier("initData"), false, true)]);
+		const callbackContext = t.objectExpression([t.objectProperty(t.identifier("inputData"), t.identifier("inputData"), false, true), t.objectProperty(t.identifier("getInitData"), t.arrowFunctionExpression([], t.identifier("initData")))]);
+		const callbackExpression = t.cloneNode(callback, true);
+		const body = t.callExpression(callbackExpression, [callbackContext]);
+		statements.push(t.exportNamedDeclaration(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(exportName), t.arrowFunctionExpression([params], body, true))])));
+		addBinding(exportName, mappingId);
+	}
+	return statements;
+}
 function collectWorkflowBindingNames(ast) {
 	const workflowNames = /* @__PURE__ */ new Set();
 	for (const statement of ast.program.body) {
@@ -335,15 +409,18 @@ function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBin
 async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputFileName) {
 	const activityBindings = [];
 	const seenActivityBindingNames = /* @__PURE__ */ new Set();
-	const addActivityBinding = (exportName, call) => {
-		const stepId = getCreateStepId(call);
-		if (!stepId || seenActivityBindingNames.has(exportName)) return;
+	const addGeneratedActivityBinding = (exportName, stepId) => {
+		if (seenActivityBindingNames.has(exportName)) return;
 		seenActivityBindingNames.add(exportName);
 		activityBindings.push({
 			exportName,
 			stepId
 		});
 	};
+	const addActivityBinding = (exportName, call) => {
+		const stepId = getCreateStepId(call);
+		if (stepId) addGeneratedActivityBinding(exportName, stepId);
+	};
 	const bundle = await rollup({
 		input: entryFile,
 		treeshake: "smallest",
@@ -361,6 +438,8 @@ async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputF
 				const strippedNames = /* @__PURE__ */ new Set();
 				const workflowBindingNames = collectWorkflowBindingNames(ast);
 				const stepFactoryBindings = collectCreateStepFactoryBindings(ast.program);
+				const staticFunctionBindings = collectStaticFunctionBindings(ast.program);
+				const usedExportNames = collectTopLevelBindingNames(ast.program);
 				const sourceFilePath = id;
 				const hasMastraBinding = hasLocalMastraBinding(ast);
 				let helperInserted = false;
@@ -422,6 +501,7 @@ async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputF
 							if (hasCreateWorkflowCall(declaration.init)) {
 								workflowBindingNames.add(declaration.id.name);
 								strippedNames.add(declaration.id.name);
+								statements.push(...createMappingActivityStatements(declaration.init, sourceFilePath, staticFunctionBindings, usedExportNames, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -461,6 +541,7 @@ async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputF
 							if (hasCreateWorkflowCall(declaration.init)) {
 								workflowBindingNames.add(declaration.id.name);
 								strippedNames.add(declaration.id.name);
+								statements.push(...createMappingActivityStatements(declaration.init, sourceFilePath, staticFunctionBindings, usedExportNames, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -660,7 +741,7 @@ function getWorkflowStepName(node, stepBindings) {
 * Most step references collapse down to step ids so the generated workflow can call
 * activities by id instead of keeping the original `createStep` definitions around.
 */
-function rewriteChainMethod(method, filePath, workflowName, stepBindings, workflowBindings) {
+function rewriteChainMethod(method, filePath, workflowName, workflowId, mappingOrdinal, stepBindings, workflowBindings) {
 	const argNode = (index) => method.args[index];
 	const rewritten = (args, name = method.name) => ({
 		name,
@@ -695,9 +776,16 @@ function rewriteChainMethod(method, filePath, workflowName, stepBindings, workfl
 		case "parallel": {
 			const arg = argNode(0);
 			if (!t.isArrayExpression(arg)) throw new Error(`.parallel() in ${workflowName} (${filePath}) requires an array literal argument`);
-			const names = arg.elements.map((el) => getWorkflowStepName(el, stepBindings));
-			if (names.some((n) => !n)) throw new Error(`Unable to determine step names inside .parallel() in ${workflowName} (${filePath})`);
-			return rewritten([t.arrayExpression(names.map((n) => t.stringLiteral(n)))]);
+			const entries = arg.elements.map((element) => {
+				if (t.isIdentifier(element)) {
+					const workflowType = workflowBindings.get(element.name);
+					if (workflowType) return t.objectExpression([t.objectProperty(t.identifier("type"), t.stringLiteral("childWorkflow")), t.objectProperty(t.identifier("workflowType"), t.stringLiteral(workflowType))]);
+				}
+				const stepId = getWorkflowStepName(element, stepBindings);
+				if (!stepId) throw new Error(`Unable to determine step names inside .parallel() in ${workflowName} (${filePath})`);
+				return t.objectExpression([t.objectProperty(t.identifier("type"), t.stringLiteral("step")), t.objectProperty(t.identifier("step"), t.objectExpression([t.objectProperty(t.identifier("id"), t.stringLiteral(stepId))]))]);
+			});
+			return rewritten([t.arrayExpression(entries)]);
 		}
 		case "branch": {
 			const arg = argNode(0);
@@ -726,6 +814,15 @@ function rewriteChainMethod(method, filePath, workflowName, stepBindings, workfl
 			if (optsArg && t.isExpression(optsArg)) args.push(t.cloneNode(optsArg, true));
 			return rewritten(args);
 		}
+		case "map": {
+			const callback = argNode(0);
+			if (t.isObjectExpression(callback)) throw new Error(`.map() in ${workflowName} (${filePath}) does not yet support declarative object mappings; use a callback mapping`);
+			if (!t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback) && !t.isIdentifier(callback)) throw new Error(`.map() in ${workflowName} (${filePath}) requires an inline function or a statically declared function identifier`);
+			const args = [t.stringLiteral(`mapping_${workflowId}_${mappingOrdinal}`)];
+			const optsArg = method.args[1];
+			if (optsArg && t.isExpression(optsArg)) args.push(t.cloneNode(optsArg, true));
+			return rewritten(args);
+		}
 		case "commit": return rewritten([]);
 		default: throw new Error(`Unsupported workflow chain method .${method.name}() in ${workflowName} (${filePath})`);
 	}
@@ -740,12 +837,14 @@ function getExportedName(node) {
 * we emit a deterministic exported function whose name matches Temporal's runtime
 * lookup and whose body delegates into the injected helper runtime.
 */
-function createTemporalWorkflowStatements(exportName, workflowId, methods, filePath, includeCommit, stepBindings, workflowBindings, runtimeOptions) {
+function createTemporalWorkflowStatements(exportName, workflowId, workflowIdValue, methods, filePath, includeCommit, stepBindings, workflowBindings, runtimeOptions) {
 	const createWorkflowArgs = [t.cloneNode(workflowId, true)];
 	if (runtimeOptions) createWorkflowArgs.push(t.cloneNode(runtimeOptions, true));
 	let expression = t.callExpression(t.identifier("createWorkflow"), createWorkflowArgs);
+	let mappingOrdinal = 0;
 	for (const method of methods) {
-		const rewrittenMethod = rewriteChainMethod(method, filePath, exportName, stepBindings, workflowBindings);
+		const rewrittenMethod = rewriteChainMethod(method, filePath, exportName, workflowIdValue, mappingOrdinal, stepBindings, workflowBindings);
+		if (method.name === "map") mappingOrdinal += 1;
 		expression = t.callExpression(t.memberExpression(expression, t.identifier(rewrittenMethod.name)), rewrittenMethod.args);
 	}
 	if (includeCommit && !methods.some((m) => m.name === "commit")) expression = t.callExpression(t.memberExpression(expression, t.identifier("commit")), []);
@@ -866,12 +965,12 @@ function rewriteWorkflowVariableDeclaration(statement, filePath, state) {
 		}
 		const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
 		if (!workflowConfig || !t.isObjectExpression(workflowConfig)) throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
-		const { expression: workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
+		const { expression: workflowId, workflowId: workflowIdValue } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
 		const workflowExport = getTemporalWorkflowExportFromDeclaration(declaration, filePath);
 		if (!workflowExport) throw new Error(`Unable to determine workflow export for ${declaration.id.name} in ${filePath}`);
 		const { exportName } = workflowExport;
 		state.workflowExports.push(workflowExport);
-		state.statements.push(...createTemporalWorkflowStatements(exportName, workflowId, workflowChain.methods, filePath, state.committedWorkflowNames.has(declaration.id.name), state.stepBindings, state.workflowBindings, state.runtimeOptions));
+		state.statements.push(...createTemporalWorkflowStatements(exportName, workflowId, workflowIdValue, workflowChain.methods, filePath, state.committedWorkflowNames.has(declaration.id.name), state.stepBindings, state.workflowBindings, state.runtimeOptions));
 	}
 	if (declarations.length > 0) {
 		const cloned = declarations.map((declaration) => t.cloneNode(declaration, true));