@mastra/temporal 0.4.6-alpha.0 → 0.4.6-alpha.10

package/dist/worker.js

@@ -1,4 +1,5 @@
 import { t as toWorkflowType } from "./utils-B_iPTfDi.js";
+import { builtinModules } from "module";
 import { readFileSync } from "fs";
 import { writeFile } from "fs/promises";
 import path, { basename, join } from "path";
@@ -276,6 +277,95 @@ 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, requestContextClassName, 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 contextNames = [
+			"requestContext",
+			"runId",
+			"resourceId",
+			"workflowId"
+		];
+		const params = t.objectPattern([
+			t.objectProperty(t.identifier("inputData"), t.identifier("inputData"), false, true),
+			t.objectProperty(t.identifier("initData"), t.identifier("initData"), false, true),
+			...contextNames.map((name) => t.objectProperty(t.identifier(name), t.identifier(name), 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"))),
+			t.objectProperty(t.identifier("requestContext"), t.newExpression(t.identifier(requestContextClassName), [t.identifier("requestContext")])),
+			...contextNames.filter((name) => name !== "requestContext").map((name) => t.objectProperty(t.identifier(name), t.identifier(name), false, true))
+		]);
+		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) {
@@ -307,27 +397,38 @@ function hasLocalMastraBinding(ast) {
 		return declaration.declarations.some((declarator) => t.isIdentifier(declarator.id, { name: "mastra" }));
 	});
 }
-function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding) {
-	return parse(mastraImportPath ? `
-        function createStep(args) {
-          return async (params) => {
-            const { mastra } = await import(${JSON.stringify(mastraImportPath)});
-            return args.execute({ ...params, mastra });
-          };
-        }
-      ` : hasMastraBinding ? `
-        function createStep(args) {
-          return async (params) => {
-            return args.execute({ ...params, mastra });
-          };
-        }
-      ` : `
-        function createStep(args) {
-          return async (params) => {
-            return args.execute(params);
-          };
-        }
-      `, {
+function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding, requestContextClassName) {
+	return parse(`
+    function withRequestContext(params) {
+      const { requestContext, initData, ...rest } = params;
+      return {
+        ...rest,
+        requestContext: new ${requestContextClassName}(requestContext),
+        getInitData: () => initData,
+      };
+    }
+
+    ${mastraImportPath ? `
+          function createStep(args) {
+            return async (params) => {
+              const { mastra } = await import(${JSON.stringify(mastraImportPath)});
+              return args.execute({ ...withRequestContext(params), mastra });
+            };
+          }
+        ` : hasMastraBinding ? `
+            function createStep(args) {
+              return async (params) => {
+                return args.execute({ ...withRequestContext(params), mastra });
+              };
+            }
+          ` : `
+            function createStep(args) {
+              return async (params) => {
+                return args.execute(withRequestContext(params));
+              };
+            }
+          `}
+  `, {
 		sourceType: "module",
 		plugins: parserPlugins
 	}).program.body;
@@ -335,15 +436,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",
@@ -356,17 +460,23 @@ async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputF
 					plugins: parserPlugins,
 					sourceFilename: id
 				});
-				const statements = [];
+				const usedExportNames = collectTopLevelBindingNames(ast.program);
+				let requestContextClassName = "TemporalRequestContext";
+				let requestContextSuffix = 1;
+				while (usedExportNames.has(requestContextClassName)) requestContextClassName = `TemporalRequestContext${requestContextSuffix++}`;
+				usedExportNames.add(requestContextClassName);
+				const statements = [t.importDeclaration([t.importSpecifier(t.identifier(requestContextClassName), t.identifier("RequestContext"))], t.stringLiteral("@mastra/core/di"))];
 				const seenNames = /* @__PURE__ */ new Set();
 				const strippedNames = /* @__PURE__ */ new Set();
 				const workflowBindingNames = collectWorkflowBindingNames(ast);
 				const stepFactoryBindings = collectCreateStepFactoryBindings(ast.program);
+				const staticFunctionBindings = collectStaticFunctionBindings(ast.program);
 				const sourceFilePath = id;
 				const hasMastraBinding = hasLocalMastraBinding(ast);
 				let helperInserted = false;
 				const ensureHelperInserted = () => {
 					if (helperInserted) return;
-					statements.push(...createTemporalActivitiesHelperStatements(null, hasMastraBinding));
+					statements.push(...createTemporalActivitiesHelperStatements(null, hasMastraBinding, requestContextClassName));
 					helperInserted = true;
 				};
 				for (const statement of ast.program.body) {
@@ -422,6 +532,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, requestContextClassName, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -461,6 +572,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, requestContextClassName, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -660,7 +772,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 +807,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 +845,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 +868,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")), []);
@@ -777,6 +907,10 @@ function getCommittedWorkflowName(statement) {
 	if (!t.isCallExpression(expression) || !t.isMemberExpression(expression.callee) || expression.callee.computed || !isIdentifierNamed(expression.callee.property, "commit") || !t.isIdentifier(expression.callee.object)) return null;
 	return expression.callee.object.name;
 }
+const nodeBuiltinModules = new Set(builtinModules.flatMap((moduleName) => [moduleName, `node:${moduleName}`]));
+function isNodeBuiltinModule(moduleId) {
+	return nodeBuiltinModules.has(moduleId);
+}
 function createWorkflowTransformState(program, filePath) {
 	return {
 		statements: [...createTemporalWorkflowHelperStatements()],
@@ -866,12 +1000,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));
@@ -936,14 +1070,16 @@ async function buildTemporalWorkflowModule(entryFile, outputDirectory, outputFil
 		}]
 	});
 	try {
-		const baseName = basename(outputFileName);
-		const { output } = await bundle.write({
+		const outputOptions = {
 			dir: outputDirectory,
 			entryFileNames: outputFileName,
-			chunkFileNames: `${baseName}-[hash].mjs`,
+			chunkFileNames: `${basename(outputFileName)}-[hash].mjs`,
 			format: "esm",
 			sourcemap: "inline"
-		});
+		};
+		const forbiddenImport = (await bundle.generate(outputOptions)).output.filter((output) => output.type === "chunk").flatMap((chunk) => [...chunk.imports, ...chunk.dynamicImports]).find(isNodeBuiltinModule);
+		if (forbiddenImport) throw new Error(`Temporal workflow bundle cannot depend on Node.js builtin '${forbiddenImport}'. Move the dependency into an activity or remove it from workflow initialization.`);
+		const { output } = await bundle.write(outputOptions);
 		return { outputPath: join(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName) };
 	} finally {
 		await bundle.close();