@mastra/temporal 0.4.6-alpha.8 → 0.4.6

package/dist/temporal-workflow-runtime.mjs

@@ -11,6 +11,12 @@ export class TemporalExecutionEngine {
 
   async execute(params) {
     this.initData = params.input;
+    this.executionContext = {
+      ...(params.requestContext !== undefined && { requestContext: params.requestContext }),
+      ...(params.runId !== undefined && { runId: params.runId }),
+      ...(params.resourceId !== undefined && { resourceId: params.resourceId }),
+      workflowId: params.workflowId,
+    };
     let result = params.input;
     const stepResults = {};
 
@@ -27,18 +33,26 @@ export class TemporalExecutionEngine {
     };
   }
 
+  activityParams(inputData, extra = {}) {
+    return { inputData, ...extra, ...this.executionContext };
+  }
+
   async executeEntry(entry, inputData, stepResults) {
     switch (entry.type) {
       case 'step': {
         log.info('step', { stepId: entry.step.id });
-        const out = await this.activityHandle[entry.step.id]({ inputData });
+        const out = await this.activityHandle[entry.step.id](
+          this.activityParams(inputData, { initData: this.initData }),
+        );
         stepResults[entry.step.id] = out;
         return out;
       }
 
       case 'childWorkflow': {
         log.info('childWorkflow', { workflowType: entry.workflowType });
-        const childResult = await executeChild(entry.workflowType, { args: [{ inputData }] });
+        const childResult = await executeChild(entry.workflowType, {
+          args: [{ inputData, ...this.executionContext }],
+        });
         const out = childResult?.result ?? childResult;
         stepResults[entry.workflowType] = out;
         return out;
@@ -46,13 +60,14 @@ export class TemporalExecutionEngine {
 
       case 'mapping': {
         log.info('mapping', { mappingId: entry.id });
-        const out = await this.activityHandle[entry.id]({ inputData, initData: this.initData });
+        const out = await this.activityHandle[entry.id](this.activityParams(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);
+        const duration =
+          entry.duration ?? (entry.fn ? await this.activityHandle[entry.fn](this.activityParams(inputData)) : 0);
         log.info('sleep', { id: entry.id, duration });
         await sleep(duration);
         return inputData;
@@ -63,7 +78,7 @@ export class TemporalExecutionEngine {
           entry.date != null
             ? new Date(entry.date)
             : entry.fn
-              ? new Date(await this.activityHandle[entry.fn]({ inputData }))
+              ? new Date(await this.activityHandle[entry.fn](this.activityParams(inputData)))
               : new Date();
         log.info('sleepUntil', { id: entry.id, date: date.toISOString() });
         const duration = Math.max(0, date.getTime() - Date.now());
@@ -90,14 +105,16 @@ export class TemporalExecutionEngine {
           conditions: entry.serializedConditions.map(condition => condition.id),
         });
         const condResults = await Promise.all(
-          entry.serializedConditions.map(condition => this.activityHandle[condition.id]({ inputData })),
+          entry.serializedConditions.map(condition =>
+            this.activityHandle[condition.id](this.activityParams(inputData)),
+          ),
         );
         const out = {};
 
         for (let i = 0; i < entry.steps.length; i++) {
           if (condResults[i]) {
             const stepId = entry.steps[i].step.id;
-            const res = await this.activityHandle[stepId]({ inputData });
+            const res = await this.activityHandle[stepId](this.activityParams(inputData, { initData: this.initData }));
             out[stepId] = res;
             stepResults[stepId] = res;
           }
@@ -111,10 +128,10 @@ export class TemporalExecutionEngine {
         let current = inputData;
 
         while (true) {
-          current = await this.activityHandle[entry.step.id]({ inputData: current });
+          current = await this.activityHandle[entry.step.id](this.activityParams(current, { initData: this.initData }));
           stepResults[entry.step.id] = current;
           const shouldContinue = Boolean(
-            await this.activityHandle[entry.serializedCondition.id]({ inputData: current }),
+            await this.activityHandle[entry.serializedCondition.id](this.activityParams(current)),
           );
 
           if (entry.loopType === 'dowhile' ? !shouldContinue : shouldContinue) {
@@ -142,7 +159,9 @@ export class TemporalExecutionEngine {
             if (i >= items.length) {
               break;
             }
-            results[i] = await this.activityHandle[entry.step.id]({ inputData: items[i] });
+            results[i] = await this.activityHandle[entry.step.id](
+              this.activityParams(items[i], { initData: this.initData }),
+            );
           }
         });
 
@@ -169,6 +188,7 @@ export function createWorkflow(workflowId, options) {
       workflowId,
       runId: startArgs?.runId,
       resourceId: startArgs?.resourceId,
+      requestContext: startArgs?.requestContext,
       graph: {
         id: workflowId,
         steps: stepFlow,

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

@@ -1 +1 @@
-{"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"}
+{"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;AA2SD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CAoZ9C"}

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

@@ -1,5 +1,11 @@
 export declare class TemporalExecutionEngine {
     initData: any;
+    executionContext: {
+        requestContext?: any;
+        runId?: any;
+        resourceId?: any;
+        workflowId: any;
+    } | undefined;
     startToCloseTimeout: any;
     activityHandle: import("@temporalio/workflow").ActivityInterfaceFor<import("@temporalio/workflow").UntypedActivities>;
     constructor(params: any);
@@ -10,6 +16,13 @@ export declare class TemporalExecutionEngine {
         state: any;
         steps: {};
     }>;
+    activityParams(inputData: any, extra?: {}): {
+        requestContext?: any;
+        runId?: any;
+        resourceId?: any;
+        workflowId?: any;
+        inputData: any;
+    };
     executeEntry(entry: any, inputData: any, stepResults: any): Promise<any>;
 }
 export declare function createWorkflow(workflowId: any, options: any): ((startArgs: any) => Promise<{

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,gBA+H/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmJjD"}
+{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAEA,qBAAa,uBAAuB;IAU3B,QAAQ;IACR,gBAAgB;;;;;;IAVvB,mBAAmB,MAAC;IACpB,cAAc,wGAAC;IAEf,YAAY,MAAM,KAAA,EAGjB;IAEK,OAAO,CAAC,MAAM,KAAA;;;;;;OAsBnB;IAED,cAAc,CAAC,SAAS,KAAA,EAAE,KAAK,KAAK;;;;;;MAEnC;IAEK,YAAY,CAAC,KAAK,KAAA,EAAE,SAAS,KAAA,EAAE,WAAW,KAAA,gBAwI/C;CACF;AAED,wBAAgB,cAAc,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoJjD"}

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/transforms/workflows.ts"],"names":[],"mappings":"AAwfA,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;AA+UD;;;;;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,CAsDjC"}

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",
@@ -349,7 +350,7 @@ function collectTopLevelBindingNames(program) {
 	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) {
+function createMappingActivityStatements(workflowExpression, filePath, staticFunctionBindings, usedExportNames, requestContextClassName, addBinding) {
 	const chain = parseWorkflowChain$1(workflowExpression);
 	if (!chain) return [];
 	const workflowId = getStaticWorkflowId(chain.createWorkflowCall, filePath);
@@ -366,8 +367,23 @@ function createMappingActivityStatements(workflowExpression, filePath, staticFun
 		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 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))])));
@@ -406,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;
@@ -458,19 +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 usedExportNames = collectTopLevelBindingNames(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) {
@@ -526,7 +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, addGeneratedActivityBinding));
+								statements.push(...createMappingActivityStatements(declaration.init, sourceFilePath, staticFunctionBindings, usedExportNames, requestContextClassName, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -566,7 +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, addGeneratedActivityBinding));
+								statements.push(...createMappingActivityStatements(declaration.init, sourceFilePath, staticFunctionBindings, usedExportNames, requestContextClassName, addGeneratedActivityBinding));
 								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
 								continue;
 							}
@@ -901,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()],
@@ -1060,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();