@temporalio/workflow 1.4.3 → 1.5.0

package/src/stack-helpers.ts

@@ -4,7 +4,7 @@ import type { PromiseStackStore } from './internals';
  * Helper function to remove a promise from being tracked for stack trace query purposes
  */
 export function untrackPromise(promise: Promise<unknown>): void {
-  const store = (globalThis as any).__TEMPORAL__?.promiseStackStore as PromiseStackStore | undefined;
+  const store = (globalThis as any).__TEMPORAL__?.activator?.promiseStackStore as PromiseStackStore | undefined;
   if (!store) return;
   store.childToParent.delete(promise);
   store.promiseToStack.delete(promise);

package/src/worker-interface.ts

@@ -3,43 +3,20 @@
  *
  * @module
  */
-import { IllegalStateError, ProtoFailure } from '@temporalio/common';
+import { IllegalStateError } from '@temporalio/common';
 import { msToTs, tsToMs } from '@temporalio/common/lib/time';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import type { coresdk } from '@temporalio/proto';
-import { alea } from './alea';
 import { storage } from './cancellation-scope';
 import { DeterminismViolationError } from './errors';
 import { WorkflowInterceptorsFactory } from './interceptors';
-import { WorkflowInfo } from './interfaces';
-import { InterceptorsImportFunc, state, WorkflowsImportFunc } from './internals';
+import { WorkflowCreateOptionsWithSourceMap } from './interfaces';
+import { Activator, getActivator } from './internals';
 import { SinkCall } from './sinks';
-import type { RawSourceMap } from 'source-map';
 
 // Export the type for use on the "worker" side
 export { PromiseStackStore } from './internals';
 
-export interface WorkflowCreateOptions {
-  info: WorkflowInfo;
-  randomnessSeed: number[];
-  now: number;
-  patches: string[];
-  showStackTraceSources: boolean;
-}
-
-export interface WorkflowCreateOptionsWithSourceMap extends WorkflowCreateOptions {
-  sourceMap: RawSourceMap;
-}
-
-export interface ImportFunctions {
-  importWorkflows: WorkflowsImportFunc;
-  importInterceptors: InterceptorsImportFunc;
-}
-export function setImportFuncs({ importWorkflows, importInterceptors }: ImportFunctions): void {
-  state.importWorkflows = importWorkflows;
-  state.importInterceptors = importInterceptors;
-}
-
 const global = globalThis as any;
 const OriginalDate = globalThis.Date;
 
@@ -60,11 +37,11 @@ export function overrideGlobals(): void {
     if (args.length > 0) {
       return new (OriginalDate as any)(...args);
     }
-    return new OriginalDate(state.now);
+    return new OriginalDate(getActivator().now);
   };
 
   global.Date.now = function () {
-    return state.now;
+    return getActivator().now;
   };
 
   global.Date.parse = OriginalDate.parse.bind(OriginalDate);
@@ -76,12 +53,13 @@ export function overrideGlobals(): void {
    * @param ms sleep duration -  number of milliseconds. If given a negative number, value will be set to 1.
    */
   global.setTimeout = function (cb: (...args: any[]) => any, ms: number, ...args: any[]): number {
+    const activator = getActivator();
     ms = Math.max(1, ms);
-    const seq = state.nextSeqs.timer++;
+    const seq = activator.nextSeqs.timer++;
     // Create a Promise for AsyncLocalStorage to be able to track this completion using promise hooks.
     new Promise((resolve, reject) => {
-      state.completions.timer.set(seq, { resolve, reject });
-      state.pushCommand({
+      activator.completions.timer.set(seq, { resolve, reject });
+      activator.pushCommand({
         startTimer: {
           seq,
           startToFireTimeout: msToTs(ms),
@@ -95,17 +73,18 @@ export function overrideGlobals(): void {
   };
 
   global.clearTimeout = function (handle: number): void {
-    state.nextSeqs.timer++;
-    state.completions.timer.delete(handle);
-    state.pushCommand({
+    const activator = getActivator();
+    activator.nextSeqs.timer++;
+    activator.completions.timer.delete(handle);
+    activator.pushCommand({
       cancelTimer: {
         seq: handle,
       },
     });
   };
 
-  // state.random is mutable, don't hardcode its reference
-  Math.random = () => state.random();
+  // activator.random is mutable, don't hardcode its reference
+  Math.random = () => getActivator().random();
 }
 
 /**
@@ -113,55 +92,36 @@ export function overrideGlobals(): void {
  *
  * Sets required internal state and instantiates the workflow and interceptors.
  */
-export async function initRuntime({
-  info,
-  randomnessSeed,
-  now,
-  patches,
-  sourceMap,
-  showStackTraceSources,
-}: WorkflowCreateOptionsWithSourceMap): Promise<void> {
-  // Set the runId globally on the context so it can be retrieved in the case
-  // of an unhandled promise rejection.
-  global.__TEMPORAL__.runId = info.runId;
-  // Set the promiseStackStore so promises can be tracked
-  global.__TEMPORAL__.promiseStackStore = {
-    promiseToStack: new Map(),
-    childToParent: new Map(),
-  };
+export function initRuntime(options: WorkflowCreateOptionsWithSourceMap): void {
+  const { info } = options;
+  info.unsafe.now = OriginalDate.now;
+  const activator = new Activator(options);
+  // There's on activator per workflow instance, set it globally on the context.
+  // We do this before importing any user code so user code can statically reference @temporalio/workflow functions
+  // as well as Date and Math.random.
+  global.__TEMPORAL__.activator = activator;
 
-  state.info = info;
-  state.info.unsafe.now = OriginalDate.now;
-  state.now = now;
-  state.random = alea(randomnessSeed);
-  state.showStackTraceSources = showStackTraceSources;
-  state.sourceMap = sourceMap;
-
-  if (info.unsafe.isReplaying) {
-    for (const patch of patches) {
-      state.knownPresentPatches.add(patch);
-    }
-  }
-
-  // @ts-expect-error this is a webpack alias to payloadConverterPath
-  const customPayloadConverter = (await import('__temporal_custom_payload_converter')).payloadConverter;
+  // webpack alias to payloadConverterPath
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const customPayloadConverter = require('__temporal_custom_payload_converter').payloadConverter;
   // The `payloadConverter` export is validated in the Worker
-  if (customPayloadConverter !== undefined) {
-    state.payloadConverter = customPayloadConverter;
+  if (customPayloadConverter != null) {
+    activator.payloadConverter = customPayloadConverter;
   }
-  // @ts-expect-error this is a webpack alias to failureConverterPath
-  const customFailureConverter = (await import('__temporal_custom_failure_converter')).failureConverter;
+  // webpack alias to failureConverterPath
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const customFailureConverter = require('__temporal_custom_failure_converter').failureConverter;
   // The `failureConverter` export is validated in the Worker
-  if (customFailureConverter !== undefined) {
-    state.failureConverter = customFailureConverter;
+  if (customFailureConverter != null) {
+    activator.failureConverter = customFailureConverter;
   }
 
-  const { importWorkflows, importInterceptors } = state;
+  const { importWorkflows, importInterceptors } = global.__TEMPORAL__;
   if (importWorkflows === undefined || importInterceptors === undefined) {
-    throw new IllegalStateError('Workflow has not been initialized');
+    throw new IllegalStateError('Workflow bundle did not register import hooks');
   }
 
-  const interceptors = await importInterceptors();
+  const interceptors = importInterceptors();
   for (const mod of interceptors) {
     const factory: WorkflowInterceptorsFactory = mod.interceptors;
     if (factory !== undefined) {
@@ -169,18 +129,18 @@ export async function initRuntime({
         throw new TypeError(`interceptors must be a function, got: ${factory}`);
       }
       const interceptors = factory();
-      state.interceptors.inbound.push(...(interceptors.inbound ?? []));
-      state.interceptors.outbound.push(...(interceptors.outbound ?? []));
-      state.interceptors.internals.push(...(interceptors.internals ?? []));
+      activator.interceptors.inbound.push(...(interceptors.inbound ?? []));
+      activator.interceptors.outbound.push(...(interceptors.outbound ?? []));
+      activator.interceptors.internals.push(...(interceptors.internals ?? []));
     }
   }
 
-  const mod = await importWorkflows();
+  const mod = importWorkflows();
   const workflow = mod[info.workflowType];
   if (typeof workflow !== 'function') {
     throw new TypeError(`'${info.workflowType}' is not a function`);
   }
-  state.workflow = workflow;
+  activator.workflow = workflow;
 }
 
 /**
@@ -188,23 +148,21 @@ export async function initRuntime({
  * @returns a boolean indicating whether job was processed or ignored
  */
 export function activate(activation: coresdk.workflow_activation.WorkflowActivation, batchIndex: number): void {
-  const intercept = composeInterceptors(state.interceptors.internals, 'activate', ({ activation, batchIndex }) => {
+  const activator = getActivator();
+  const intercept = composeInterceptors(activator.interceptors.internals, 'activate', ({ activation, batchIndex }) => {
     if (batchIndex === 0) {
-      if (state.info === undefined) {
-        throw new IllegalStateError('Workflow has not been initialized');
-      }
       if (!activation.jobs) {
         throw new TypeError('Got activation with no jobs');
       }
       if (activation.timestamp != null) {
         // timestamp will not be updated for activation that contain only queries
-        state.now = tsToMs(activation.timestamp);
+        activator.now = tsToMs(activation.timestamp);
       }
       if (activation.historyLength == null) {
         throw new TypeError('Got activation with no historyLength');
       }
-      state.info.unsafe.isReplaying = activation.isReplaying ?? false;
-      state.info.historyLength = activation.historyLength;
+      activator.info.unsafe.isReplaying = activation.isReplaying ?? false;
+      activator.info.historyLength = activation.historyLength;
     }
 
     // Cast from the interface to the class which has the `variant` attribute.
@@ -223,10 +181,10 @@ export function activate(activation: coresdk.workflow_activation.WorkflowActivat
       // The only job that can be executed on a completed workflow is a query.
       // We might get other jobs after completion for instance when a single
       // activation contains multiple jobs and the first one completes the workflow.
-      if (state.completed && job.variant !== 'queryWorkflow') {
+      if (activator.completed && job.variant !== 'queryWorkflow') {
         return;
       }
-      state.activator[job.variant](variant as any /* TS can't infer this type */);
+      activator[job.variant](variant as any /* TS can't infer this type */);
       if (showUnblockConditions(job)) {
         tryUnblockConditions();
       }
@@ -245,18 +203,18 @@ export function activate(activation: coresdk.workflow_activation.WorkflowActivat
  * Activation failures are handled in the main Node.js isolate.
  */
 export function concludeActivation(): coresdk.workflow_completion.IWorkflowActivationCompletion {
-  const intercept = composeInterceptors(state.interceptors.internals, 'concludeActivation', (input) => input);
-  const { info } = state;
-  const { commands } = intercept({ commands: state.commands });
-  state.commands = [];
+  const activator = getActivator();
+  const intercept = composeInterceptors(activator.interceptors.internals, 'concludeActivation', (input) => input);
+  const { info } = activator;
+  const { commands } = intercept({ commands: activator.getAndResetCommands() });
   return {
-    runId: info?.runId,
+    runId: info.runId,
     successful: { commands },
   };
 }
 
 export function getAndResetSinkCalls(): SinkCall[] {
-  return state.getAndResetSinkCalls();
+  return getActivator().getAndResetSinkCalls();
 }
 
 /**
@@ -268,12 +226,12 @@ export function tryUnblockConditions(): number {
   let numUnblocked = 0;
   for (;;) {
     const prevUnblocked = numUnblocked;
-    for (const [seq, cond] of state.blockedConditions.entries()) {
+    for (const [seq, cond] of getActivator().blockedConditions.entries()) {
       if (cond.fn()) {
         cond.resolve();
         numUnblocked++;
         // It is safe to delete elements during map iteration
-        state.blockedConditions.delete(seq);
+        getActivator().blockedConditions.delete(seq);
       }
     }
     if (prevUnblocked === numUnblocked) {
@@ -290,13 +248,9 @@ export function showUnblockConditions(job: coresdk.workflow_activation.IWorkflow
   return !job.queryWorkflow && !job.notifyHasPatch;
 }
 
-export async function dispose(): Promise<void> {
-  const dispose = composeInterceptors(state.interceptors.internals, 'dispose', async () => {
+export function dispose(): void {
+  const dispose = composeInterceptors(getActivator().interceptors.internals, 'dispose', async () => {
     storage.disable();
   });
-  await dispose({});
-}
-
-export function errorToFailure(err: unknown): ProtoFailure {
-  return state.failureConverter.errorToFailure(err);
+  dispose({});
 }