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

package/dist/temporal-workflow-runtime.mjs

@@ -44,6 +44,13 @@ export class TemporalExecutionEngine {
         return out;
       }
 
+      case 'mapping': {
+        log.info('mapping', { mappingId: entry.id });
+        const out = await this.activityHandle[entry.id]({ inputData, initData: this.initData });
+        stepResults[entry.id] = out;
+        return out;
+      }
+
       case 'sleep': {
         const duration = entry.duration ?? (entry.fn ? await this.activityHandle[entry.fn]({ inputData }) : 0);
         log.info('sleep', { id: entry.id, duration });
@@ -65,13 +72,14 @@ export class TemporalExecutionEngine {
       }
 
       case 'parallel': {
-        log.info('parallel', { steps: entry.steps.map(s => s.step.id) });
-        const results = await Promise.all(entry.steps.map(s => this.activityHandle[s.step.id]({ inputData })));
+        const entryId = parallelEntry =>
+          parallelEntry.type === 'childWorkflow' ? parallelEntry.workflowType : parallelEntry.step.id;
+        log.info('parallel', { steps: entry.steps.map(entryId) });
+        const results = await Promise.all(entry.steps.map(step => this.executeEntry(step, inputData, stepResults)));
         const out = {};
 
-        entry.steps.forEach((s, i) => {
-          out[s.step.id] = results[i];
-          stepResults[s.step.id] = results[i];
+        entry.steps.forEach((step, i) => {
+          out[entryId(step)] = results[i];
         });
 
         return out;
@@ -187,6 +195,13 @@ export function createWorkflow(workflowId, options) {
       });
       return workflow;
     },
+    map(mappingId) {
+      stepFlow.push({
+        type: 'mapping',
+        id: mappingId,
+      });
+      return workflow;
+    },
     sleep(durationOrFnId) {
       if (typeof durationOrFnId === 'number') {
         stepFlow.push({
@@ -225,15 +240,10 @@ export function createWorkflow(workflowId, options) {
       }
       return workflow;
     },
-    parallel(stepIds) {
+    parallel(entries) {
       stepFlow.push({
         type: 'parallel',
-        steps: stepIds.map(id => ({
-          type: 'step',
-          step: {
-            id,
-          },
-        })),
+        steps: entries,
       });
       return workflow;
     },

package/dist/transforms/activities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/transforms/activities.ts"],"names":[],"mappings":"AAyBA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;CAC7C;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAmE/G;AA6HD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CA4W9C"}
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/transforms/activities.ts"],"names":[],"mappings":"AA0BA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;CAC7C;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAmE/G;AAmRD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CAoY9C"}

package/dist/transforms/temporal-workflow-runtime.d.mts

@@ -33,6 +33,13 @@ export declare function createWorkflow(workflowId: any, options: any): ((startAr
         state: any;
         steps: {};
     }>;
+    map(mappingId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
     sleep(durationOrFnId: any): (startArgs: any) => Promise<{
         status: string;
         input: any;
@@ -47,7 +54,7 @@ export declare function createWorkflow(workflowId: any, options: any): ((startAr
         state: any;
         steps: {};
     }>;
-    parallel(stepIds: any): (startArgs: any) => Promise<{
+    parallel(entries: any): (startArgs: any) => Promise<{
         status: string;
         input: any;
         result: any;

package/dist/transforms/temporal-workflow-runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAEA,qBAAa,uBAAuB;IAU3B,QAAQ;IATf,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IAEf,YAAY,MAAM,KAAA,EAGjB;IAEK,OAAO,CAAC,MAAM,KAAA;;;;;;OAgBnB;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,gBAuH/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJjD"}
+{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAEA,qBAAa,uBAAuB;IAU3B,QAAQ;IATf,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IAEf,YAAY,MAAM,KAAA,EAGjB;IAEK,OAAO,CAAC,MAAM,KAAA;;;;;;OAgBnB;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,gBA+H/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmJjD"}

package/dist/transforms/workflows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/transforms/workflows.ts"],"names":[],"mappings":"AAgcA,MAAM,WAAW,4BAA4B;CAE5C;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iCAAiC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC;AAoUD;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAwCjC"}
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/transforms/workflows.ts"],"names":[],"mappings":"AAufA,MAAM,WAAW,4BAA4B;CAE5C;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iCAAiC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC;AAyUD;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAwCjC"}

package/dist/worker.cjs

@@ -301,6 +301,80 @@ 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, 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 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)]);
+		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")))]);
+		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) {
@@ -360,15 +434,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",
@@ -386,6 +463,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;
@@ -447,6 +526,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;
 							}
@@ -486,6 +566,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;
 							}
@@ -685,7 +766,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 +801,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 +839,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 +862,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")), []);
@@ -891,12 +990,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));