@temporalio/workflow 1.2.0 → 1.4.0

package/src/index.ts

@@ -8,7 +8,7 @@
  *
  * The recommended way of scheduling timers is by using the {@link sleep} function. We've replaced `setTimeout` and
  * `clearTimeout` with deterministic versions so these are also usable but have a limitation that they don't play well
- * with {@link https://docs.temporal.io/typescript/workflow-scopes-and-cancellation | cancellation scopes}.
+ * with {@link https://docs.temporal.io/typescript/cancellation-scopes | cancellation scopes}.
  *
  * <!--SNIPSTART typescript-sleep-workflow-->
  * <!--SNIPEND-->
@@ -34,45 +34,41 @@
  * <!--SNIPSTART typescript-workflow-signal-implementation-->
  * <!--SNIPEND-->
  *
- * ### Deterministic built-ins
- * It is safe to call `Math.random()` and `Date()` in workflow code as they are replaced with deterministic versions. We
- * also provide a deterministic {@link uuid4} function for convenience.
+ * ### More
  *
- * ### [Cancellation and scopes](https://docs.temporal.io/typescript/workflow-scopes-and-cancellation)
- * - {@link CancellationScope}
- * - {@link Trigger}
- *
- * ### [Sinks](https://docs.temporal.io/typescript/sinks)
- * - {@link Sinks}
+ * - [Deterministic built-ins](https://docs.temporal.io/typescript/determinism#sources-of-non-determinism)
+ * - [Cancellation and scopes](https://docs.temporal.io/typescript/cancellation-scopes)
+ *   - {@link CancellationScope}
+ *   - {@link Trigger}
+ * - [Sinks](https://docs.temporal.io/application-development/observability/?lang=ts#logging)
+ *   - {@link Sinks}
  *
  * @module
  */
 
 export {
+  ActivityCancellationType,
   ActivityFailure,
+  ActivityFunction,
+  ActivityInterface,
+  ActivityOptions,
   ApplicationFailure,
   CancelledFailure,
   ChildWorkflowFailure,
   defaultPayloadConverter,
   PayloadConverter,
+  RetryPolicy,
   rootCause,
   ServerFailure,
   TemporalFailure,
   TerminatedFailure,
   TimeoutFailure,
-} from '@temporalio/common';
-export {
-  ActivityCancellationType,
-  ActivityFunction,
-  ActivityInterface, // eslint-disable-line deprecation/deprecation
-  ActivityOptions,
-  RetryPolicy,
   UntypedActivities,
-} from '@temporalio/internal-workflow-common';
-export * from '@temporalio/internal-workflow-common/lib/errors';
-export * from '@temporalio/internal-workflow-common/lib/interfaces';
-export * from '@temporalio/internal-workflow-common/lib/workflow-handle';
-export * from '@temporalio/internal-workflow-common/lib/workflow-options';
+} from '@temporalio/common';
+export * from '@temporalio/common/lib/errors';
+export * from '@temporalio/common/lib/interfaces';
+export * from '@temporalio/common/lib/workflow-handle';
+export * from '@temporalio/common/lib/workflow-options';
 export { AsyncLocalStorage, CancellationScope, CancellationScopeOptions, ROOT_SCOPE } from './cancellation-scope';
 export * from './errors';
 export * from './interceptors';
@@ -81,16 +77,17 @@ export {
   ChildWorkflowOptions,
   ContinueAsNew,
   ContinueAsNewOptions,
+  EnhancedStackTrace,
+  FileLocation,
+  FileSlice,
   ParentClosePolicy,
   ParentWorkflowInfo,
-  WorkflowInfo,
-  FileSlice,
-  FileLocation,
-  StackTrace,
-  EnhancedStackTrace,
   SDKInfo,
+  StackTrace,
+  UnsafeWorkflowInfo,
+  WorkflowInfo,
 } from './interfaces';
-export { Sink, SinkCall, SinkFunction, Sinks } from './sinks';
+export { LoggerSinks, Sink, SinkCall, SinkFunction, Sinks } from './sinks';
 export { Trigger } from './trigger';
 export * from './workflow';
 export { ChildWorkflowHandle, ExternalWorkflowHandle } from './workflow-handle';

package/src/interceptors.ts

@@ -6,8 +6,7 @@
  * @module
  */
 
-import { WorkflowExecution } from '@temporalio/common';
-import { ActivityOptions, Headers, LocalActivityOptions, Next, Timestamp } from '@temporalio/internal-workflow-common';
+import { ActivityOptions, Headers, LocalActivityOptions, Next, Timestamp, WorkflowExecution } from '@temporalio/common';
 import type { coresdk } from '@temporalio/proto';
 import { ChildWorkflowOptionsWithDefaults, ContinueAsNewOptions } from './interfaces';
 

package/src/interfaces.ts

@@ -1,5 +1,6 @@
 import { RetryPolicy, TemporalFailure } from '@temporalio/common';
-import { checkExtends, CommonWorkflowOptions, SearchAttributes } from '@temporalio/internal-workflow-common';
+import { CommonWorkflowOptions, SearchAttributes } from '@temporalio/common';
+import { checkExtends } from '@temporalio/common/lib/type-helpers';
 import type { coresdk } from '@temporalio/proto';
 
 /**
@@ -135,6 +136,14 @@ export interface WorkflowInfo {
  * Never rely on this information in Workflow logic as it will cause non-deterministic behavior.
  */
 export interface UnsafeWorkflowInfo {
+  /**
+   * Current system time in milliseconds
+   *
+   * The safe version of time is `new Date()` and `Date.now()`, which are set on the first invocation of a Workflow
+   * Task and stay constant for the duration of the Task and during replay.
+   */
+  now(): number;
+
   isReplaying: boolean;
 }
 
@@ -169,12 +178,12 @@ export interface ContinueAsNewOptions {
   taskQueue?: string;
   /**
    * Timeout for the entire Workflow run
-   * @format {@link https://www.npmjs.com/package/ms | ms} formatted string
+   * @format {@link https://www.npmjs.com/package/ms | ms-formatted string}
    */
   workflowRunTimeout?: string;
   /**
    * Timeout for a single Workflow task
-   * @format {@link https://www.npmjs.com/package/ms | ms} formatted string
+   * @format {@link https://www.npmjs.com/package/ms | ms-formatted string}
    */
   workflowTaskTimeout?: string;
   /**
@@ -223,6 +232,7 @@ export enum ChildWorkflowCancellationType {
 }
 
 checkExtends<coresdk.child_workflow.ChildWorkflowCancellationType, ChildWorkflowCancellationType>();
+checkExtends<ChildWorkflowCancellationType, coresdk.child_workflow.ChildWorkflowCancellationType>();
 
 /**
  * How a Child Workflow reacts to the Parent Workflow reaching a Closed state.
@@ -254,6 +264,7 @@ export enum ParentClosePolicy {
 }
 
 checkExtends<coresdk.child_workflow.ParentClosePolicy, ParentClosePolicy>();
+checkExtends<ParentClosePolicy, coresdk.child_workflow.ParentClosePolicy>();
 
 export interface ChildWorkflowOptions extends CommonWorkflowOptions {
   /**

package/src/internals.ts

@@ -1,22 +1,17 @@
-import { PayloadConverter } from '@temporalio/common';
+import { defaultFailureConverter, FailureConverter, PayloadConverter } from '@temporalio/common';
 import type { RawSourceMap } from 'source-map';
 import {
   arrayFromPayloads,
   defaultPayloadConverter,
   ensureTemporalFailure,
-  errorToFailure,
-  failureToError,
-  optionalFailureToOptionalError,
-  TemporalFailure,
-} from '@temporalio/common';
-import {
-  checkExtends,
-  composeInterceptors,
   IllegalStateError,
+  TemporalFailure,
   Workflow,
   WorkflowQueryType,
   WorkflowSignalType,
-} from '@temporalio/internal-workflow-common';
+} from '@temporalio/common';
+import { composeInterceptors } from '@temporalio/common/lib/interceptors';
+import { checkExtends } from '@temporalio/common/lib/type-helpers';
 import type { coresdk } from '@temporalio/proto';
 import { alea, RNG } from './alea';
 import { ROOT_SCOPE } from './cancellation-scope';
@@ -39,6 +34,7 @@ enum StartChildWorkflowExecutionFailedCause {
 }
 
 checkExtends<coresdk.child_workflow.StartChildWorkflowExecutionFailedCause, StartChildWorkflowExecutionFailedCause>();
+checkExtends<StartChildWorkflowExecutionFailedCause, coresdk.child_workflow.StartChildWorkflowExecutionFailedCause>();
 
 export interface Stack {
   formatted: string;
@@ -147,11 +143,11 @@ export class Activator implements ActivationHandler {
       resolve(result);
     } else if (activation.result.failed) {
       const { failure } = activation.result.failed;
-      const err = optionalFailureToOptionalError(failure, state.payloadConverter);
+      const err = failure ? state.failureConverter.failureToError(failure) : undefined;
       reject(err);
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
-      const err = optionalFailureToOptionalError(failure, state.payloadConverter);
+      const err = failure ? state.failureConverter.failureToError(failure) : undefined;
       reject(err);
     } else if (activation.result.backoff) {
       reject(new LocalActivityDoBackoff(activation.result.backoff));
@@ -185,7 +181,7 @@ export class Activator implements ActivationHandler {
       if (!activation.cancelled.failure) {
         throw new TypeError('Got no failure in cancelled variant');
       }
-      reject(failureToError(activation.cancelled.failure, state.payloadConverter));
+      reject(state.failureConverter.failureToError(activation.cancelled.failure));
     } else {
       throw new TypeError('Got ResolveChildWorkflowExecutionStart with no status');
     }
@@ -205,13 +201,13 @@ export class Activator implements ActivationHandler {
       if (failure === undefined || failure === null) {
         throw new TypeError('Got failed result with no failure attribute');
       }
-      reject(failureToError(failure, state.payloadConverter));
+      reject(state.failureConverter.failureToError(failure));
     } else if (activation.result.cancelled) {
       const { failure } = activation.result.cancelled;
       if (failure === undefined || failure === null) {
         throw new TypeError('Got cancelled result with no failure attribute');
       }
-      reject(failureToError(failure, state.payloadConverter));
+      reject(state.failureConverter.failureToError(failure));
     }
   }
 
@@ -303,7 +299,7 @@ export class Activator implements ActivationHandler {
   public resolveSignalExternalWorkflow(activation: coresdk.workflow_activation.IResolveSignalExternalWorkflow): void {
     const { resolve, reject } = consumeCompletion('signalWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(failureToError(activation.failure, state.payloadConverter));
+      reject(state.failureConverter.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -314,7 +310,7 @@ export class Activator implements ActivationHandler {
   ): void {
     const { resolve, reject } = consumeCompletion('cancelWorkflow', getSeq(activation));
     if (activation.failure) {
-      reject(failureToError(activation.failure, state.payloadConverter));
+      reject(state.failureConverter.failureToError(activation.failure));
     } else {
       resolve(undefined);
     }
@@ -546,6 +542,7 @@ export class State {
   public importInterceptors?: InterceptorsImportFunc;
 
   public payloadConverter: PayloadConverter = defaultPayloadConverter;
+  public failureConverter: FailureConverter = defaultFailureConverter;
 
   /**
    * Patches we know the status of for this workflow, as in {@link patched}
@@ -612,7 +609,7 @@ export async function handleWorkflowFailure(error: unknown): Promise<void> {
     state.pushCommand(
       {
         failWorkflowExecution: {
-          failure: errorToFailure(error, state.payloadConverter),
+          failure: state.failureConverter.errorToFailure(error),
         },
       },
       true
@@ -628,7 +625,7 @@ function completeQuery(queryId: string, result: unknown) {
 
 async function failQuery(queryId: string, error: any) {
   state.pushCommand({
-    respondToQuery: { queryId, failed: errorToFailure(ensureTemporalFailure(error), state.payloadConverter) },
+    respondToQuery: { queryId, failed: state.failureConverter.errorToFailure(ensureTemporalFailure(error)) },
   });
 }
 

package/src/sinks.ts

@@ -39,3 +39,16 @@ export interface SinkCall {
   fnName: string;
   args: any[];
 }
+
+/**
+ * Sink interface for forwarding logs from the Workflow sandbox to the Worker
+ */
+export interface LoggerSinks extends Sinks {
+  defaultWorkerLogger: {
+    trace(message: string, attrs: Record<string, unknown>): void;
+    debug(message: string, attrs: Record<string, unknown>): void;
+    info(message: string, attrs: Record<string, unknown>): void;
+    warn(message: string, attrs: Record<string, unknown>): void;
+    error(message: string, attrs: Record<string, unknown>): void;
+  };
+}

package/src/worker-interface.ts

@@ -3,8 +3,9 @@
  *
  * @module
  */
-import { errorToFailure as _errorToFailure, ProtoFailure } from '@temporalio/common';
-import { composeInterceptors, IllegalStateError, msToTs, tsToMs } from '@temporalio/internal-workflow-common';
+import { IllegalStateError, ProtoFailure } 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';
@@ -39,8 +40,10 @@ export function setImportFuncs({ importWorkflows, importInterceptors }: ImportFu
   state.importInterceptors = importInterceptors;
 }
 
+const global = globalThis as any;
+const OriginalDate = globalThis.Date;
+
 export function overrideGlobals(): void {
-  const global = globalThis as any;
   // 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.
@@ -53,8 +56,6 @@ export function overrideGlobals(): void {
     );
   };
 
-  const OriginalDate = globalThis.Date;
-
   global.Date = function (...args: unknown[]) {
     if (args.length > 0) {
       return new (OriginalDate as any)(...args);
@@ -120,7 +121,6 @@ export async function initRuntime({
   sourceMap,
   showStackTraceSources,
 }: WorkflowCreateOptionsWithSourceMap): Promise<void> {
-  const global = globalThis as any;
   // 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;
@@ -131,6 +131,7 @@ export async function initRuntime({
   };
 
   state.info = info;
+  state.info.unsafe.now = OriginalDate.now;
   state.now = now;
   state.random = alea(randomnessSeed);
   state.showStackTraceSources = showStackTraceSources;
@@ -142,14 +143,18 @@ export async function initRuntime({
     }
   }
 
-  // webpack doesn't know what to bundle given a dynamic import expression, so we can't do:
-  // state.payloadConverter = (await import(payloadConverterPath)).payloadConverter;
   // @ts-expect-error this is a webpack alias to payloadConverterPath
   const customPayloadConverter = (await import('__temporal_custom_payload_converter')).payloadConverter;
   // The `payloadConverter` export is validated in the Worker
   if (customPayloadConverter !== undefined) {
     state.payloadConverter = customPayloadConverter;
   }
+  // @ts-expect-error this is a webpack alias to failureConverterPath
+  const customFailureConverter = (await import('__temporal_custom_failure_converter')).failureConverter;
+  // The `failureConverter` export is validated in the Worker
+  if (customFailureConverter !== undefined) {
+    state.failureConverter = customFailureConverter;
+  }
 
   const { importWorkflows, importInterceptors } = state;
   if (importWorkflows === undefined || importInterceptors === undefined) {
@@ -293,5 +298,5 @@ export async function dispose(): Promise<void> {
 }
 
 export function errorToFailure(err: unknown): ProtoFailure {
-  return _errorToFailure(err, state.payloadConverter);
+  return state.failureConverter.errorToFailure(err);
 }

package/src/workflow-handle.ts

@@ -1,4 +1,4 @@
-import { BaseWorkflowHandle, SignalDefinition, Workflow } from '@temporalio/internal-workflow-common';
+import { BaseWorkflowHandle, SignalDefinition, Workflow } from '@temporalio/common';
 
 /**
  * Handle representing an external Workflow Execution.

package/src/workflow.ts

@@ -1,24 +1,23 @@
-import { mapToPayloads, searchAttributePayloadConverter, toPayloads } from '@temporalio/common';
 import {
   ActivityFunction,
   ActivityOptions,
   compileRetryPolicy,
-  composeInterceptors,
   IllegalStateError,
   LocalActivityOptions,
-  msOptionalToTs,
-  msToNumber,
-  msToTs,
+  mapToPayloads,
   QueryDefinition,
+  searchAttributePayloadConverter,
   SearchAttributes,
   SignalDefinition,
-  tsToMs,
+  toPayloads,
   UntypedActivities,
   WithWorkflowArgs,
   Workflow,
   WorkflowResultType,
   WorkflowReturnType,
-} from '@temporalio/internal-workflow-common';
+} from '@temporalio/common';
+import { msOptionalToTs, msToNumber, msToTs, tsToMs } from '@temporalio/common/lib/time';
+import { composeInterceptors } from '@temporalio/common/lib/interceptors';
 import { CancellationScope, registerSleepImplementation } from './cancellation-scope';
 import {
   ActivityInput,
@@ -102,7 +101,7 @@ function timerNextHandler(input: TimerInput) {
  *
  * Schedules a timer on the Temporal service.
  *
- * @param ms sleep duration - {@link https://www.npmjs.com/package/ms | ms} formatted string or number of milliseconds.
+ * @param ms sleep duration - number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}.
  * If given a negative number or 0, value will be set to 1.
  */
 export function sleep(ms: number | string): Promise<void> {
@@ -171,6 +170,7 @@ function scheduleActivityNextHandler({ options, args, headers, seq, activityType
         scheduleToStartTimeout: msOptionalToTs(options.scheduleToStartTimeout),
         headers,
         cancellationType: options.cancellationType,
+        doNotEagerlyExecute: !(options.allowEagerDispatch ?? true),
       },
     });
     state.completions.activity.set(seq, {
@@ -325,21 +325,10 @@ function startChildWorkflowExecutionNextHandler({
       untrackPromise(
         scope.cancelRequested.catch(() => {
           const complete = !state.completions.childWorkflowComplete.has(seq);
-          const started = !state.completions.childWorkflowStart.has(seq);
 
-          if (started && !complete) {
-            const cancelSeq = state.nextSeqs.cancelWorkflow++;
+          if (!complete) {
             state.pushCommand({
-              requestCancelExternalWorkflowExecution: {
-                seq: cancelSeq,
-                childWorkflowId: workflowId,
-              },
-            });
-            // Not interested in this completion
-            state.completions.cancelWorkflow.set(cancelSeq, { resolve: () => undefined, reject: () => undefined });
-          } else if (!started) {
-            state.pushCommand({
-              cancelUnstartedChildWorkflowExecution: { childWorkflowSeq: seq },
+              cancelChildWorkflowExecution: { childWorkflowSeq: seq },
             });
           }
           // Nothing to cancel otherwise
@@ -1078,7 +1067,7 @@ function patchInternal(patchId: string, deprecated: boolean): boolean {
 /**
  * Returns a Promise that resolves when `fn` evaluates to `true` or `timeout` expires.
  *
- * @param timeout {@link https://www.npmjs.com/package/ms | ms} formatted string or number of milliseconds
+ * @param timeout number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
  *
  * @returns a boolean indicating whether the condition was true before the timeout expires
  */