@temporalio/workflow 1.5.2 → 1.7.0

package/src/worker-interface.ts

@@ -7,12 +7,13 @@ 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 { storage } from './cancellation-scope';
+import { disableStorage } from './cancellation-scope';
 import { DeterminismViolationError } from './errors';
 import { WorkflowInterceptorsFactory } from './interceptors';
-import { WorkflowCreateOptionsWithSourceMap } from './interfaces';
+import { WorkflowCreateOptionsWithSourceMap, WorkflowInfo } from './interfaces';
 import { Activator, getActivator } from './internals';
 import { SinkCall } from './sinks';
+import { setActivatorUntyped } from './global-attributes';
 
 // Export the type for use on the "worker" side
 export { PromiseStackStore } from './internals';
@@ -22,7 +23,6 @@ const OriginalDate = globalThis.Date;
 
 export function overrideGlobals(): void {
   // Mock any weak reference because GC is non-deterministic and the effect is observable from the Workflow.
-  // WeakRef is implemented in V8 8.4 which is embedded in node >=14.6.0.
   // Workflow developer will get a meaningful exception if they try to use these.
   global.WeakRef = function () {
     throw new DeterminismViolationError('WeakRef cannot be used in Workflows because v8 GC is non-deterministic');
@@ -93,13 +93,13 @@ export function overrideGlobals(): void {
  * Sets required internal state and instantiates the workflow and interceptors.
  */
 export function initRuntime(options: WorkflowCreateOptionsWithSourceMap): void {
-  const { info } = options;
+  const info: WorkflowInfo = fixPrototypes(options.info);
   info.unsafe.now = OriginalDate.now;
-  const activator = new Activator(options);
+  const activator = new Activator({ ...options, info });
   // 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;
+  setActivatorUntyped(activator);
 
   // webpack alias to payloadConverterPath
   // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -126,7 +126,7 @@ export function initRuntime(options: WorkflowCreateOptionsWithSourceMap): void {
     const factory: WorkflowInterceptorsFactory = mod.interceptors;
     if (factory !== undefined) {
       if (typeof factory !== 'function') {
-        throw new TypeError(`interceptors must be a function, got: ${factory}`);
+        throw new TypeError(`Failed to initialize workflows interceptors: expected a function, but got: '${factory}'`);
       }
       const interceptors = factory();
       activator.interceptors.inbound.push(...(interceptors.inbound ?? []));
@@ -136,11 +136,39 @@ export function initRuntime(options: WorkflowCreateOptionsWithSourceMap): void {
   }
 
   const mod = importWorkflows();
-  const workflow = mod[info.workflowType];
-  if (typeof workflow !== 'function') {
-    throw new TypeError(`'${info.workflowType}' is not a function`);
+  const workflowFn = mod[info.workflowType];
+  const defaultWorfklowFn = mod['default'];
+
+  if (typeof workflowFn === 'function') {
+    activator.workflow = workflowFn;
+  } else if (typeof defaultWorfklowFn === 'function') {
+    activator.workflow = defaultWorfklowFn;
+  } else {
+    const details =
+      workflowFn === undefined
+        ? 'no such function is exported by the workflow bundle'
+        : `expected a function, but got: '${typeof workflowFn}'`;
+    throw new TypeError(`Failed to initialize workflow of type '${info.workflowType}': ${details}`);
   }
-  activator.workflow = workflow;
+}
+
+/**
+ * Objects transfered to the VM from outside have prototypes belonging to the
+ * outer context, which means that instanceof won't work inside the VM. This
+ * function recursively walks over the content of an object, and recreate some
+ * of these objects (notably Array, Date and Objects).
+ */
+function fixPrototypes<X>(obj: X): X {
+  if (obj != null && typeof obj === 'object') {
+    switch (Object.getPrototypeOf(obj)?.constructor?.name) {
+      case 'Array':
+        return Array.from((obj as Array<unknown>).map(fixPrototypes)) as X;
+      case 'Date':
+        return new Date(obj as unknown as Date) as X;
+      default:
+        return Object.fromEntries(Object.entries(obj).map(([k, v]): [string, any] => [k, fixPrototypes(v)])) as X;
+    }
+  } else return obj;
 }
 
 /**
@@ -185,7 +213,7 @@ export function activate(activation: coresdk.workflow_activation.WorkflowActivat
         return;
       }
       activator[job.variant](variant as any /* TS can't infer this type */);
-      if (showUnblockConditions(job)) {
+      if (shouldUnblockConditions(job)) {
         tryUnblockConditions();
       }
     }
@@ -244,13 +272,13 @@ export function tryUnblockConditions(): number {
 /**
  * Predicate used to prevent triggering conditions for non-query and non-patch jobs.
  */
-export function showUnblockConditions(job: coresdk.workflow_activation.IWorkflowActivationJob): boolean {
+export function shouldUnblockConditions(job: coresdk.workflow_activation.IWorkflowActivationJob): boolean {
   return !job.queryWorkflow && !job.notifyHasPatch;
 }
 
 export function dispose(): void {
   const dispose = composeInterceptors(getActivator().interceptors.internals, 'dispose', async () => {
-    storage.disable();
+    disableStorage();
   });
   dispose({});
 }

package/src/workflow.ts

@@ -32,10 +32,12 @@ import {
   ChildWorkflowOptionsWithDefaults,
   ContinueAsNew,
   ContinueAsNewOptions,
+  DefaultSignalHandler,
   EnhancedStackTrace,
+  Handler,
   WorkflowInfo,
 } from './interfaces';
-import { LocalActivityDoBackoff, getActivator } from './internals';
+import { LocalActivityDoBackoff, getActivator, maybeGetActivator } from './internals';
 import { Sinks } from './sinks';
 import { untrackPromise } from './stack-helpers';
 import { ChildWorkflowHandle, ExternalWorkflowHandle } from './workflow-handle';
@@ -692,7 +694,7 @@ export async function startChild<T extends Workflow>(
   options?: WithWorkflowArgs<T, ChildWorkflowOptions>
 ): Promise<ChildWorkflowHandle<T>> {
   const activator = getActivator();
-  const optionsWithDefaults = addDefaultWorkflowOptions(options ?? {});
+  const optionsWithDefaults = addDefaultWorkflowOptions(options ?? ({} as any));
   const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
   const execute = composeInterceptors(
     activator.interceptors.outbound,
@@ -791,7 +793,7 @@ export async function executeChild<T extends Workflow>(
   options?: WithWorkflowArgs<T, ChildWorkflowOptions>
 ): Promise<WorkflowResultType<T>> {
   const activator = getActivator();
-  const optionsWithDefaults = addDefaultWorkflowOptions(options ?? {});
+  const optionsWithDefaults = addDefaultWorkflowOptions(options ?? ({} as any));
   const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
   const execute = composeInterceptors(
     activator.interceptors.outbound,
@@ -843,18 +845,7 @@ export function workflowInfo(): WorkflowInfo {
  * Returns whether or not code is executing in workflow context
  */
 export function inWorkflowContext(): boolean {
-  try {
-    getActivator();
-    return true;
-  } catch (err: any) {
-    // Use string comparison in case multiple versions of @temporalio/common are
-    // installed in which case an instanceof check would fail.
-    if (err.name === 'IllegalStateError') {
-      return false;
-    } else {
-      throw err;
-    }
-  }
+  return maybeGetActivator() !== undefined;
 }
 
 /**
@@ -1131,11 +1122,13 @@ function conditionInner(fn: () => boolean): Promise<void> {
  * Definitions are used to register handler in the Workflow via {@link setHandler} and to signal Workflows using a {@link WorkflowHandle}, {@link ChildWorkflowHandle} or {@link ExternalWorkflowHandle}.
  * Definitions can be reused in multiple Workflows.
  */
-export function defineSignal<Args extends any[] = []>(name: string): SignalDefinition<Args> {
+export function defineSignal<Args extends any[] = [], Name extends string = string>(
+  name: Name
+): SignalDefinition<Args, Name> {
   return {
     type: 'signal',
     name,
-  };
+  } as SignalDefinition<Args, Name>;
 }
 
 /**
@@ -1144,26 +1137,15 @@ export function defineSignal<Args extends any[] = []>(name: string): SignalDefin
  * Definitions are used to register handler in the Workflow via {@link setHandler} and to query Workflows using a {@link WorkflowHandle}.
  * Definitions can be reused in multiple Workflows.
  */
-export function defineQuery<Ret, Args extends any[] = []>(name: string): QueryDefinition<Ret, Args> {
+export function defineQuery<Ret, Args extends any[] = [], Name extends string = string>(
+  name: Name
+): QueryDefinition<Ret, Args, Name> {
   return {
     type: 'query',
     name,
-  };
+  } as QueryDefinition<Ret, Args, Name>;
 }
 
-/**
- * A handler function capable of accepting the arguments for a given SignalDefinition or QueryDefinition.
- */
-export type Handler<
-  Ret,
-  Args extends any[],
-  T extends SignalDefinition<Args> | QueryDefinition<Ret, Args>
-> = T extends SignalDefinition<infer A>
-  ? (...args: A) => void | Promise<void>
-  : T extends QueryDefinition<infer R, infer A>
-  ? (...args: A) => R
-  : never;
-
 /**
  * Set a handler function for a Workflow query or signal.
  *
@@ -1178,21 +1160,48 @@ export function setHandler<Ret, Args extends any[], T extends SignalDefinition<A
 ): void {
   const activator = getActivator();
   if (def.type === 'signal') {
-    activator.signalHandlers.set(def.name, handler as any);
-    const bufferedSignals = activator.bufferedSignals.get(def.name);
-    if (bufferedSignals !== undefined && handler !== undefined) {
-      activator.bufferedSignals.delete(def.name);
-      for (const signal of bufferedSignals) {
-        activator.signalWorkflow(signal);
-      }
+    if (typeof handler === 'function') {
+      activator.signalHandlers.set(def.name, handler as any);
+      activator.dispatchBufferedSignals();
+    } else if (handler == null) {
+      activator.signalHandlers.delete(def.name);
+    } else {
+      throw new TypeError(`Expected handler to be either a function or 'undefined'. Got: '${typeof handler}'`);
     }
   } else if (def.type === 'query') {
-    activator.queryHandlers.set(def.name, handler as any);
+    if (typeof handler === 'function') {
+      activator.queryHandlers.set(def.name, handler as any);
+    } else if (handler == null) {
+      activator.queryHandlers.delete(def.name);
+    } else {
+      throw new TypeError(`Expected handler to be either a function or 'undefined'. Got: '${typeof handler}'`);
+    }
   } else {
     throw new TypeError(`Invalid definition type: ${(def as any).type}`);
   }
 }
 
+/**
+ * Set a signal handler function that will handle signals calls for non-registered signal names.
+ *
+ * Signals are dispatched to the default signal handler in the order that they were accepted by the server.
+ *
+ * If this function is called multiple times for a given signal or query name the last handler will overwrite any previous calls.
+ *
+ * @param handler a function that will handle signals for non-registered signal names, or `undefined` to unset the handler.
+ */
+export function setDefaultSignalHandler(handler: DefaultSignalHandler | undefined): void {
+  const activator = getActivator();
+  if (typeof handler === 'function') {
+    activator.defaultSignalHandler = handler;
+    activator.dispatchBufferedSignals();
+  } else if (handler == null) {
+    activator.defaultSignalHandler = undefined;
+  } else {
+    throw new TypeError(`Expected handler to be either a function or 'undefined'. Got: '${typeof handler}'`);
+  }
+}
+
 /**
  * Updates this Workflow's Search Attributes by merging the provided `searchAttributes` with the existing Search
  * Attributes, `workflowInfo().searchAttributes`.