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

package/dist/worker.cjs

@@ -32,6 +32,7 @@ let _babel_parser = require("@babel/parser");
 let _babel_types = require("@babel/types");
 _babel_types = __toESM(_babel_types, 1);
 let rollup = require("rollup");
+let module$1 = require("module");
 //#region src/transforms/shared.ts
 const parserPlugins = [
 	"typescript",
@@ -301,6 +302,95 @@ function rebaseModulePath(modulePath, sourceFilePath, outputFilePath) {
 	const resolvedPath = path.default.resolve(path.default.dirname(sourceFilePath), modulePath);
 	return normalizeImportPath(path.default.relative(path.default.dirname(outputFilePath), resolvedPath), path.default.extname(resolvedPath));
 }
+function parseWorkflowChain$1(node) {
+	const methods = [];
+	let current = node;
+	while (_babel_types.isCallExpression(current) && _babel_types.isMemberExpression(current.callee) && !current.callee.computed) {
+		if (!_babel_types.isIdentifier(current.callee.property)) return null;
+		methods.unshift({
+			name: current.callee.property.name,
+			args: current.arguments
+		});
+		current = current.callee.object;
+	}
+	if (!_babel_types.isCallExpression(current) || !_babel_types.isIdentifier(current.callee, { name: "createWorkflow" })) return null;
+	return {
+		createWorkflowCall: current,
+		methods
+	};
+}
+function getStaticWorkflowId(call, filePath) {
+	const [config] = call.arguments;
+	if (!_babel_types.isObjectExpression(config)) throw new Error(`Unable to determine workflow config in ${filePath}`);
+	for (const property of config.properties) {
+		if (!_babel_types.isObjectProperty(property) || getObjectPropertyName(property) !== "id") continue;
+		if (_babel_types.isStringLiteral(property.value)) return property.value.value;
+		if (_babel_types.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 = _babel_types.isExportNamedDeclaration(statement) ? statement.declaration : statement;
+		if (_babel_types.isFunctionDeclaration(declaration) && declaration.id) {
+			bindings.add(declaration.id.name);
+			continue;
+		}
+		if (!_babel_types.isVariableDeclaration(declaration) || declaration.kind !== "const") continue;
+		for (const declarator of declaration.declarations) if (_babel_types.isIdentifier(declarator.id) && (_babel_types.isArrowFunctionExpression(declarator.init) || _babel_types.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(_babel_types.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 (_babel_types.isObjectExpression(callback)) throw new Error(`.map() in workflow ${workflowId} (${filePath}) does not yet support declarative object mappings`);
+		if (!_babel_types.isArrowFunctionExpression(callback) && !_babel_types.isFunctionExpression(callback) && !(_babel_types.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 = _babel_types.objectPattern([
+			_babel_types.objectProperty(_babel_types.identifier("inputData"), _babel_types.identifier("inputData"), false, true),
+			_babel_types.objectProperty(_babel_types.identifier("initData"), _babel_types.identifier("initData"), false, true),
+			...contextNames.map((name) => _babel_types.objectProperty(_babel_types.identifier(name), _babel_types.identifier(name), false, true))
+		]);
+		const callbackContext = _babel_types.objectExpression([
+			_babel_types.objectProperty(_babel_types.identifier("inputData"), _babel_types.identifier("inputData"), false, true),
+			_babel_types.objectProperty(_babel_types.identifier("getInitData"), _babel_types.arrowFunctionExpression([], _babel_types.identifier("initData"))),
+			_babel_types.objectProperty(_babel_types.identifier("requestContext"), _babel_types.newExpression(_babel_types.identifier(requestContextClassName), [_babel_types.identifier("requestContext")])),
+			...contextNames.filter((name) => name !== "requestContext").map((name) => _babel_types.objectProperty(_babel_types.identifier(name), _babel_types.identifier(name), false, true))
+		]);
+		const callbackExpression = _babel_types.cloneNode(callback, true);
+		const body = _babel_types.callExpression(callbackExpression, [callbackContext]);
+		statements.push(_babel_types.exportNamedDeclaration(_babel_types.variableDeclaration("const", [_babel_types.variableDeclarator(_babel_types.identifier(exportName), _babel_types.arrowFunctionExpression([params], body, true))])));
+		addBinding(exportName, mappingId);
+	}
+	return statements;
+}
 function collectWorkflowBindingNames(ast) {
 	const workflowNames = /* @__PURE__ */ new Set();
 	for (const statement of ast.program.body) {
@@ -332,27 +422,38 @@ function hasLocalMastraBinding(ast) {
 		return declaration.declarations.some((declarator) => _babel_types.isIdentifier(declarator.id, { name: "mastra" }));
 	});
 }
-function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding) {
-	return (0, _babel_parser.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 (0, _babel_parser.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;
@@ -360,15 +461,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 (0, rollup.rollup)({
 		input: entryFile,
 		treeshake: "smallest",
@@ -381,17 +485,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 = [_babel_types.importDeclaration([_babel_types.importSpecifier(_babel_types.identifier(requestContextClassName), _babel_types.identifier("RequestContext"))], _babel_types.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) {
@@ -447,6 +557,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;
 							}
@@ -486,6 +597,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;
 							}
@@ -685,7 +797,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,
@@ -720,9 +832,16 @@ function rewriteChainMethod(method, filePath, workflowName, stepBindings, workfl
 		case "parallel": {
 			const arg = argNode(0);
 			if (!_babel_types.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([_babel_types.arrayExpression(names.map((n) => _babel_types.stringLiteral(n)))]);
+			const entries = arg.elements.map((element) => {
+				if (_babel_types.isIdentifier(element)) {
+					const workflowType = workflowBindings.get(element.name);
+					if (workflowType) return _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("type"), _babel_types.stringLiteral("childWorkflow")), _babel_types.objectProperty(_babel_types.identifier("workflowType"), _babel_types.stringLiteral(workflowType))]);
+				}
+				const stepId = getWorkflowStepName(element, stepBindings);
+				if (!stepId) throw new Error(`Unable to determine step names inside .parallel() in ${workflowName} (${filePath})`);
+				return _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("type"), _babel_types.stringLiteral("step")), _babel_types.objectProperty(_babel_types.identifier("step"), _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("id"), _babel_types.stringLiteral(stepId))]))]);
+			});
+			return rewritten([_babel_types.arrayExpression(entries)]);
 		}
 		case "branch": {
 			const arg = argNode(0);
@@ -751,6 +870,15 @@ function rewriteChainMethod(method, filePath, workflowName, stepBindings, workfl
 			if (optsArg && _babel_types.isExpression(optsArg)) args.push(_babel_types.cloneNode(optsArg, true));
 			return rewritten(args);
 		}
+		case "map": {
+			const callback = argNode(0);
+			if (_babel_types.isObjectExpression(callback)) throw new Error(`.map() in ${workflowName} (${filePath}) does not yet support declarative object mappings; use a callback mapping`);
+			if (!_babel_types.isArrowFunctionExpression(callback) && !_babel_types.isFunctionExpression(callback) && !_babel_types.isIdentifier(callback)) throw new Error(`.map() in ${workflowName} (${filePath}) requires an inline function or a statically declared function identifier`);
+			const args = [_babel_types.stringLiteral(`mapping_${workflowId}_${mappingOrdinal}`)];
+			const optsArg = method.args[1];
+			if (optsArg && _babel_types.isExpression(optsArg)) args.push(_babel_types.cloneNode(optsArg, true));
+			return rewritten(args);
+		}
 		case "commit": return rewritten([]);
 		default: throw new Error(`Unsupported workflow chain method .${method.name}() in ${workflowName} (${filePath})`);
 	}
@@ -765,12 +893,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 = [_babel_types.cloneNode(workflowId, true)];
 	if (runtimeOptions) createWorkflowArgs.push(_babel_types.cloneNode(runtimeOptions, true));
 	let expression = _babel_types.callExpression(_babel_types.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 = _babel_types.callExpression(_babel_types.memberExpression(expression, _babel_types.identifier(rewrittenMethod.name)), rewrittenMethod.args);
 	}
 	if (includeCommit && !methods.some((m) => m.name === "commit")) expression = _babel_types.callExpression(_babel_types.memberExpression(expression, _babel_types.identifier("commit")), []);
@@ -802,6 +932,10 @@ function getCommittedWorkflowName(statement) {
 	if (!_babel_types.isCallExpression(expression) || !_babel_types.isMemberExpression(expression.callee) || expression.callee.computed || !isIdentifierNamed(expression.callee.property, "commit") || !_babel_types.isIdentifier(expression.callee.object)) return null;
 	return expression.callee.object.name;
 }
+const nodeBuiltinModules = new Set(module$1.builtinModules.flatMap((moduleName) => [moduleName, `node:${moduleName}`]));
+function isNodeBuiltinModule(moduleId) {
+	return nodeBuiltinModules.has(moduleId);
+}
 function createWorkflowTransformState(program, filePath) {
 	return {
 		statements: [...createTemporalWorkflowHelperStatements()],
@@ -891,12 +1025,12 @@ function rewriteWorkflowVariableDeclaration(statement, filePath, state) {
 		}
 		const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
 		if (!workflowConfig || !_babel_types.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) => _babel_types.cloneNode(declaration, true));
@@ -961,14 +1095,16 @@ async function buildTemporalWorkflowModule(entryFile, outputDirectory, outputFil
 		}]
 	});
 	try {
-		const baseName = (0, path.basename)(outputFileName);
-		const { output } = await bundle.write({
+		const outputOptions = {
 			dir: outputDirectory,
 			entryFileNames: outputFileName,
-			chunkFileNames: `${baseName}-[hash].mjs`,
+			chunkFileNames: `${(0, path.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: (0, path.join)(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName) };
 	} finally {
 		await bundle.close();