@temporalio/workflow 1.12.3 → 1.13.0

package/lib/errors.js

@@ -47,6 +47,7 @@ exports.LocalActivityDoBackoff = LocalActivityDoBackoff = __decorate([
  */
 function isCancellation(err) {
     return (err instanceof common_1.CancelledFailure ||
-        ((err instanceof common_1.ActivityFailure || err instanceof common_1.ChildWorkflowFailure) && err.cause instanceof common_1.CancelledFailure));
+        ((err instanceof common_1.ActivityFailure || err instanceof common_1.ChildWorkflowFailure || err instanceof common_1.NexusOperationFailure) &&
+            err.cause instanceof common_1.CancelledFailure));
 }
 //# sourceMappingURL=errors.js.map

package/lib/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;;;;;;;AA6BA,wCAKC;AAlCD,+CAA6F;AAC7F,sEAAiF;AAGjF;;GAEG;AAEI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,KAAK;CAAG,CAAA;AAA9B,sCAAa;wBAAb,aAAa;IADzB,IAAA,yCAA0B,EAAC,eAAe,CAAC;GAC/B,aAAa,CAAiB;AAE3C;;GAEG;AAEI,IAAM,yBAAyB,GAA/B,MAAM,yBAA0B,SAAQ,aAAa;CAAG,CAAA;AAAlD,8DAAyB;oCAAzB,yBAAyB;IADrC,IAAA,yCAA0B,EAAC,2BAA2B,CAAC;GAC3C,yBAAyB,CAAyB;AAE/D;;GAEG;AAEI,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,KAAK;IACnB;IAA5B,YAA4B,OAA2C;QACrE,KAAK,EAAE,CAAC;QADkB,YAAO,GAAP,OAAO,CAAoC;IAEvE,CAAC;CACF,CAAA;AAJY,wDAAsB;iCAAtB,sBAAsB;IADlC,IAAA,yCAA0B,EAAC,wBAAwB,CAAC;GACxC,sBAAsB,CAIlC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,GAAY;IACzC,OAAO,CACL,GAAG,YAAY,yBAAgB;QAC/B,CAAC,CAAC,GAAG,YAAY,wBAAe,IAAI,GAAG,YAAY,6BAAoB,CAAC,IAAI,GAAG,CAAC,KAAK,YAAY,yBAAgB,CAAC,CACnH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;;;;;;;AA6BA,wCAMC;AAnCD,+CAAoH;AACpH,sEAAiF;AAGjF;;GAEG;AAEI,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,KAAK;CAAG,CAAA;AAA9B,sCAAa;wBAAb,aAAa;IADzB,IAAA,yCAA0B,EAAC,eAAe,CAAC;GAC/B,aAAa,CAAiB;AAE3C;;GAEG;AAEI,IAAM,yBAAyB,GAA/B,MAAM,yBAA0B,SAAQ,aAAa;CAAG,CAAA;AAAlD,8DAAyB;oCAAzB,yBAAyB;IADrC,IAAA,yCAA0B,EAAC,2BAA2B,CAAC;GAC3C,yBAAyB,CAAyB;AAE/D;;GAEG;AAEI,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,KAAK;IACnB;IAA5B,YAA4B,OAA2C;QACrE,KAAK,EAAE,CAAC;QADkB,YAAO,GAAP,OAAO,CAAoC;IAEvE,CAAC;CACF,CAAA;AAJY,wDAAsB;iCAAtB,sBAAsB;IADlC,IAAA,yCAA0B,EAAC,wBAAwB,CAAC;GACxC,sBAAsB,CAIlC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,GAAY;IACzC,OAAO,CACL,GAAG,YAAY,yBAAgB;QAC/B,CAAC,CAAC,GAAG,YAAY,wBAAe,IAAI,GAAG,YAAY,6BAAoB,IAAI,GAAG,YAAY,8BAAqB,CAAC;YAC9G,GAAG,CAAC,KAAK,YAAY,yBAAgB,CAAC,CACzC,CAAC;AACJ,CAAC"}

package/lib/index.d.ts

@@ -66,6 +66,7 @@ export { Trigger } from './trigger';
 export * from './workflow';
 export { ChildWorkflowHandle, ExternalWorkflowHandle } from './workflow-handle';
 export { metricMeter } from './metrics';
+export { createNexusClient, NexusClientOptions, NexusClient, NexusOperationHandle } from './nexus';
 export { 
 /**
  * @deprecated Do not use LoggerSinks directly. To log from Workflow code, use the `log` object

package/lib/index.js

@@ -64,7 +64,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.metricMeter = exports.Trigger = exports.log = exports.proxySinks = exports.ParentClosePolicy = exports.ContinueAsNew = exports.ChildWorkflowCancellationType = exports.CancellationScope = exports.AsyncLocalStorage = exports.TimeoutFailure = exports.TerminatedFailure = exports.TemporalFailure = exports.ServerFailure = exports.rootCause = exports.defaultPayloadConverter = exports.ChildWorkflowFailure = exports.CancelledFailure = exports.ApplicationFailure = exports.ActivityFailure = exports.ActivityCancellationType = void 0;
+exports.createNexusClient = exports.metricMeter = exports.Trigger = exports.log = exports.proxySinks = exports.ParentClosePolicy = exports.ContinueAsNew = exports.ChildWorkflowCancellationType = exports.CancellationScope = exports.AsyncLocalStorage = exports.TimeoutFailure = exports.TerminatedFailure = exports.TemporalFailure = exports.ServerFailure = exports.rootCause = exports.defaultPayloadConverter = exports.ChildWorkflowFailure = exports.CancelledFailure = exports.ApplicationFailure = exports.ActivityFailure = exports.ActivityCancellationType = void 0;
 var common_1 = require("@temporalio/common");
 Object.defineProperty(exports, "ActivityCancellationType", { enumerable: true, get: function () { return common_1.ActivityCancellationType; } });
 Object.defineProperty(exports, "ActivityFailure", { enumerable: true, get: function () { return common_1.ActivityFailure; } });
@@ -98,4 +98,6 @@ Object.defineProperty(exports, "Trigger", { enumerable: true, get: function () {
 __exportStar(require("./workflow"), exports);
 var metrics_1 = require("./metrics");
 Object.defineProperty(exports, "metricMeter", { enumerable: true, get: function () { return metrics_1.metricMeter; } });
+var nexus_1 = require("./nexus");
+Object.defineProperty(exports, "createNexusClient", { enumerable: true, get: function () { return nexus_1.createNexusClient; } });
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;;;;;;;;;;;;;;;;;AAEH,6CAiB4B;AAhB1B,kHAAA,wBAAwB,OAAA;AACxB,yGAAA,eAAe,OAAA;AAEf,4GAAA,kBAAkB,OAAA;AAClB,0GAAA,gBAAgB,OAAA;AAChB,8GAAA,oBAAoB,OAAA;AACpB,iHAAA,uBAAuB,OAAA;AAGvB,mGAAA,SAAS,OAAA;AAGT,uGAAA,aAAa,OAAA;AACb,yGAAA,eAAe,OAAA;AACf,2GAAA,iBAAiB,OAAA;AACjB,wGAAA,cAAc,OAAA;AAEhB,gEAA8C;AAc9C,yEAAuD;AACvD,0EAAwD;AACxD,2DAAsG;AAA7F,uHAAA,iBAAiB,OAAA;AAAE,uHAAA,iBAAiB,OAAA;AAC7C,2CAAyB;AACzB,iDAA+B;AAC/B,2CAesB;AAdpB,2HAAA,6BAA6B,OAAA;AAE7B,2GAAA,aAAa,OAAA;AAKb,+GAAA,iBAAiB,OAAA;AAQnB,iCAA0E;AAAjE,mGAAA,UAAU,OAAA;AACnB,+BAA6B;AAApB,2FAAA,GAAG,OAAA;AACZ,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAChB,6CAA2B;AAE3B,qCAAwC;AAA/B,sGAAA,WAAW,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;;;;;;;;;;;;;;;;;AAEH,6CAiB4B;AAhB1B,kHAAA,wBAAwB,OAAA;AACxB,yGAAA,eAAe,OAAA;AAEf,4GAAA,kBAAkB,OAAA;AAClB,0GAAA,gBAAgB,OAAA;AAChB,8GAAA,oBAAoB,OAAA;AACpB,iHAAA,uBAAuB,OAAA;AAGvB,mGAAA,SAAS,OAAA;AAGT,uGAAA,aAAa,OAAA;AACb,yGAAA,eAAe,OAAA;AACf,2GAAA,iBAAiB,OAAA;AACjB,wGAAA,cAAc,OAAA;AAEhB,gEAA8C;AAc9C,yEAAuD;AACvD,0EAAwD;AACxD,2DAAsG;AAA7F,uHAAA,iBAAiB,OAAA;AAAE,uHAAA,iBAAiB,OAAA;AAC7C,2CAAyB;AACzB,iDAA+B;AAC/B,2CAesB;AAdpB,2HAAA,6BAA6B,OAAA;AAE7B,2GAAA,aAAa,OAAA;AAKb,+GAAA,iBAAiB,OAAA;AAQnB,iCAA0E;AAAjE,mGAAA,UAAU,OAAA;AACnB,+BAA6B;AAApB,2FAAA,GAAG,OAAA;AACZ,qCAAoC;AAA3B,kGAAA,OAAO,OAAA;AAChB,6CAA2B;AAE3B,qCAAwC;AAA/B,sGAAA,WAAW,OAAA;AAEpB,iCAAmG;AAA1F,0GAAA,iBAAiB,OAAA"}

package/lib/interceptors.d.ts

@@ -1,34 +1,96 @@
 /**
- * Type definitions and generic helpers for interceptors.
- *
- * The Workflow specific interceptors are defined here.
+ * Type definitions for Workflow interceptors.
  *
  * @module
  */
-import { ActivityOptions, Headers, LocalActivityOptions, MetricTags, Next, Timestamp, WorkflowExecution } from '@temporalio/common';
+import { ActivityOptions, Duration, Headers, LocalActivityOptions, MetricTags, Next, Timestamp, WorkflowExecution } from '@temporalio/common';
 import type { coresdk } from '@temporalio/proto';
 import { ChildWorkflowOptionsWithDefaults, ContinueAsNewOptions } from './interfaces';
 export { Next, Headers };
-/** Input for WorkflowInboundCallsInterceptor.execute */
+/**
+ * A function that instantiates {@link WorkflowInterceptors}.
+ *
+ * Workflow interceptor modules should export an `interceptors` function of this type.
+ *
+ * @example
+ *
+ * ```ts
+ * export function interceptors(): WorkflowInterceptors {
+ *   return {
+ *     inbound: [],   // Populate with list of inbound interceptor implementations
+ *     outbound: [],  // Populate with list of outbound interceptor implementations
+ *     internals: [], // Populate with list of internals interceptor implementations
+ *   };
+ * }
+ * ```
+ */
+export type WorkflowInterceptorsFactory = () => WorkflowInterceptors;
+/**
+ * A mapping from interceptor type to an optional list of interceptor implementations
+ */
+export interface WorkflowInterceptors {
+    inbound?: WorkflowInboundCallsInterceptor[];
+    outbound?: WorkflowOutboundCallsInterceptor[];
+    internals?: WorkflowInternalsInterceptor[];
+}
+/**
+ * Implement any of these methods to intercept Workflow inbound calls like execution, and signal and query handling.
+ */
+export interface WorkflowInboundCallsInterceptor {
+    /**
+     * Called when Workflow execute method is called
+     *
+     * @return result of the Workflow execution
+     */
+    execute?: (input: WorkflowExecuteInput, next: Next<WorkflowInboundCallsInterceptor, 'execute'>) => Promise<unknown>;
+    /**
+     * Called when Update handler is called
+     *
+     * @return result of the Update
+     */
+    handleUpdate?: (input: UpdateInput, next: Next<WorkflowInboundCallsInterceptor, 'handleUpdate'>) => Promise<unknown>;
+    /**
+     * Called when update validator called
+     */
+    validateUpdate?: (input: UpdateInput, next: Next<WorkflowInboundCallsInterceptor, 'validateUpdate'>) => void;
+    /**
+     * Called when signal is delivered to a Workflow execution
+     */
+    handleSignal?: (input: SignalInput, next: Next<WorkflowInboundCallsInterceptor, 'handleSignal'>) => Promise<void>;
+    /**
+     * Called when a Workflow is queried
+     *
+     * @return result of the query
+     */
+    handleQuery?: (input: QueryInput, next: Next<WorkflowInboundCallsInterceptor, 'handleQuery'>) => Promise<unknown>;
+}
+/**
+ * Input for {@link WorkflowInboundCallsInterceptor.execute}.
+ */
 export interface WorkflowExecuteInput {
     readonly args: unknown[];
     readonly headers: Headers;
 }
-/** Input for WorkflowInboundCallsInterceptor.handleUpdate and
- * WorkflowInboundCallsInterceptor.validateUpdate */
+/**
+ * Input for {@link WorkflowInboundCallsInterceptor.handleUpdate} and {@link WorkflowInboundCallsInterceptor.validateUpdate}.
+ */
 export interface UpdateInput {
     readonly updateId: string;
     readonly name: string;
     readonly args: unknown[];
     readonly headers: Headers;
 }
-/** Input for WorkflowInboundCallsInterceptor.handleSignal */
+/**
+ * Input for {@link WorkflowInboundCallsInterceptor.handleSignal}.
+ */
 export interface SignalInput {
     readonly signalName: string;
     readonly args: unknown[];
     readonly headers: Headers;
 }
-/** Input for WorkflowInboundCallsInterceptor.handleQuery */
+/**
+ * Input for {@link WorkflowInboundCallsInterceptor.handleQuery}.
+ */
 export interface QueryInput {
     readonly queryId: string;
     readonly queryName: string;
@@ -36,32 +98,85 @@ export interface QueryInput {
     readonly headers: Headers;
 }
 /**
- * Implement any of these methods to intercept Workflow inbound calls like execution, and signal and query handling.
+ * Implement any of these methods to intercept Workflow code calls to the Temporal APIs, like scheduling an activity
+ * and starting a timer.
  */
-export interface WorkflowInboundCallsInterceptor {
+export interface WorkflowOutboundCallsInterceptor {
     /**
-     * Called when Workflow execute method is called
+     * Called when Workflow starts a timer.
+     */
+    startTimer?: (input: TimerInput, next: Next<WorkflowOutboundCallsInterceptor, 'startTimer'>) => Promise<void>;
+    /**
+     * Called when Workflow schedules an Activity.
      *
-     * @return result of the Workflow execution
+     * @return result of the activity execution
      */
-    execute?: (input: WorkflowExecuteInput, next: Next<this, 'execute'>) => Promise<unknown>;
-    /** Called when Update handler is called
+    scheduleActivity?: (input: ActivityInput, next: Next<WorkflowOutboundCallsInterceptor, 'scheduleActivity'>) => Promise<unknown>;
+    /**
+     * Called when Workflow schedules a local Activity.
      *
-     * @return result of the Update
+     * @return result of the activity execution
      */
-    handleUpdate?: (input: UpdateInput, next: Next<this, 'handleUpdate'>) => Promise<unknown>;
-    /** Called when update validator called */
-    validateUpdate?: (input: UpdateInput, next: Next<this, 'validateUpdate'>) => void;
-    /** Called when signal is delivered to a Workflow execution */
-    handleSignal?: (input: SignalInput, next: Next<this, 'handleSignal'>) => Promise<void>;
+    scheduleLocalActivity?: (input: LocalActivityInput, next: Next<WorkflowOutboundCallsInterceptor, 'scheduleLocalActivity'>) => Promise<unknown>;
     /**
-     * Called when a Workflow is queried
+     * Called when Workflow starts a Nexus Operation.
      *
-     * @return result of the query
+     * @experimental Nexus support in Temporal SDK is experimental.
      */
-    handleQuery?: (input: QueryInput, next: Next<this, 'handleQuery'>) => Promise<unknown>;
+    startNexusOperation?: (input: StartNexusOperationInput, next: Next<WorkflowOutboundCallsInterceptor, 'startNexusOperation'>) => Promise<StartNexusOperationOutput>;
+    /**
+     * Called when Workflow starts a child workflow execution.
+     *
+     * The interceptor function returns 2 promises:
+     * - The first resolves with the `runId` when the child workflow has started or rejects if failed to start.
+     * - The second resolves with the workflow result when the child workflow completes or rejects on failure.
+     */
+    startChildWorkflowExecution?: (input: StartChildWorkflowExecutionInput, next: Next<WorkflowOutboundCallsInterceptor, 'startChildWorkflowExecution'>) => Promise<[Promise<string>, Promise<unknown>]>;
+    /**
+     * Called when Workflow signals a child or external Workflow.
+     */
+    signalWorkflow?: (input: SignalWorkflowInput, next: Next<WorkflowOutboundCallsInterceptor, 'signalWorkflow'>) => Promise<void>;
+    /**
+     * Called when Workflow calls continueAsNew.
+     */
+    continueAsNew?: (input: ContinueAsNewInput, next: Next<WorkflowOutboundCallsInterceptor, 'continueAsNew'>) => Promise<never>;
+    /**
+     * Called on each invocation of the `workflow.log` methods.
+     *
+     * The attributes returned in this call are attached to every log message.
+     */
+    getLogAttributes?: (input: GetLogAttributesInput, next: Next<WorkflowOutboundCallsInterceptor, 'getLogAttributes'>) => Record<string, unknown>;
+    /**
+     * Called once every time a metric is emitted from a Workflow metric (ie. a metric created
+     * from {@link workflow.metricMeter}).
+     *
+     * Tags returned by this hook are _prepended_ to tags defined at the metric level and tags
+     * defined on the emitter function itself.
+     */
+    getMetricTags?: (input: GetMetricTagsInput, next: Next<WorkflowOutboundCallsInterceptor, 'getMetricTags'>) => MetricTags;
+}
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.startTimer}
+ */
+export interface TimerInput {
+    readonly durationMs: number;
+    readonly seq: number;
+    readonly options?: TimerOptions;
+}
+/**
+ * Options for starting a timer (i.e. sleep)
+ */
+export interface TimerOptions {
+    /**
+     * A fixed, single line summary of the command's purpose
+     *
+     * @experimental User metadata is a new API and susceptible to change.
+     */
+    readonly summary?: string;
 }
-/** Input for WorkflowOutboundCallsInterceptor.scheduleActivity */
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.scheduleActivity}.
+ */
 export interface ActivityInput {
     readonly activityType: string;
     readonly args: unknown[];
@@ -69,7 +184,9 @@ export interface ActivityInput {
     readonly headers: Headers;
     readonly seq: number;
 }
-/** Input for WorkflowOutboundCallsInterceptor.scheduleLocalActivity */
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.scheduleLocalActivity}.
+ */
 export interface LocalActivityInput {
     readonly activityType: string;
     readonly args: unknown[];
@@ -79,35 +196,71 @@ export interface LocalActivityInput {
     readonly originalScheduleTime?: Timestamp;
     readonly attempt: number;
 }
-/** Input for WorkflowOutboundCallsInterceptor.startChildWorkflowExecution */
-export interface StartChildWorkflowExecutionInput {
-    readonly workflowType: string;
-    readonly options: ChildWorkflowOptionsWithDefaults;
-    readonly headers: Headers;
-    readonly seq: number;
-}
-/** Input for WorkflowOutboundCallsInterceptor.startTimer */
-export interface TimerInput {
-    readonly durationMs: number;
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.startNexusOperation}.
+ *
+ * @experimental Nexus support in Temporal SDK is experimental.
+ */
+export interface StartNexusOperationInput {
+    readonly input: unknown;
+    readonly endpoint: string;
+    readonly service: string;
+    readonly options: StartNexusOperationOptions;
+    readonly operation: string;
     readonly seq: number;
-    readonly options?: TimerOptions;
+    readonly headers: Record<string, string>;
 }
-/** Options for starting a timer (i.e. sleep) */
-export interface TimerOptions {
-    /** @experimental A fixed, single line summary of the command's purpose */
+/**
+ * Options for starting a Nexus Operation.
+ *
+ * @experimental Nexus support in Temporal SDK is experimental.
+ */
+export interface StartNexusOperationOptions {
+    /**
+     * The end to end timeout for the Nexus Operation.
+     *
+     * Optional: defaults to the maximum allowed by the Temporal server.
+     */
+    readonly scheduleToCloseTimeout?: Duration;
+    /**
+     * A fixed, single-line summary for this Nexus Operation that may appear in the UI/CLI.
+     * This can be in single-line Temporal markdown format.
+     *
+     * @experimental User metadata is a new API and susceptible to change.
+     */
     readonly summary?: string;
 }
 /**
- * Same as ContinueAsNewOptions but workflowType must be defined
+ * Output for {@link WorkflowOutboundCallsInterceptor.startNexusOperation}.
+ *
+ * @experimental Nexus support in Temporal SDK is experimental.
  */
-export type ContinueAsNewInputOptions = ContinueAsNewOptions & Required<Pick<ContinueAsNewOptions, 'workflowType'>>;
-/** Input for WorkflowOutboundCallsInterceptor.continueAsNew */
-export interface ContinueAsNewInput {
-    readonly args: unknown[];
+export interface StartNexusOperationOutput {
+    /**
+     * The token for the Nexus Operation.
+     *
+     * Undefined if the Nexus Operation completed synchronously, in which case the {@link result}
+     * will be immediately resolved.
+     */
+    readonly token?: string;
+    /**
+     * A promise that will resolve when the Nexus Operation completes, either with the result of the
+     * Operation if it completed successfully, or a failure if the Nexus Operation failed.
+     */
+    readonly result: Promise<unknown>;
+}
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.startChildWorkflowExecution}.
+ */
+export interface StartChildWorkflowExecutionInput {
+    readonly workflowType: string;
+    readonly options: ChildWorkflowOptionsWithDefaults;
     readonly headers: Headers;
-    readonly options: ContinueAsNewInputOptions;
+    readonly seq: number;
 }
-/** Input for WorkflowOutboundCallsInterceptor.signalWorkflow */
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.signalWorkflow}.
+ */
 export interface SignalWorkflowInput {
     readonly seq: number;
     readonly signalName: string;
@@ -121,74 +274,26 @@ export interface SignalWorkflowInput {
         readonly childWorkflowId: string;
     };
 }
-/** Input for WorkflowOutboundCallsInterceptor.getLogAttributes */
-export type GetLogAttributesInput = Record<string, unknown>;
-/** Input for WorkflowOutboundCallsInterceptor.getMetricTags */
-export type GetMetricTagsInput = MetricTags;
 /**
- * Implement any of these methods to intercept Workflow code calls to the Temporal APIs, like scheduling an activity and starting a timer
+ * Input for {@link WorkflowOutboundCallsInterceptor.continueAsNew}.
  */
-export interface WorkflowOutboundCallsInterceptor {
-    /**
-     * Called when Workflow schedules an Activity
-     *
-     * @return result of the activity execution
-     */
-    scheduleActivity?: (input: ActivityInput, next: Next<this, 'scheduleActivity'>) => Promise<unknown>;
-    /**
-     * Called when Workflow schedules a local Activity
-     *
-     * @return result of the activity execution
-     */
-    scheduleLocalActivity?: (input: LocalActivityInput, next: Next<this, 'scheduleLocalActivity'>) => Promise<unknown>;
-    /**
-     * Called when Workflow starts a timer
-     */
-    startTimer?: (input: TimerInput, next: Next<this, 'startTimer'>) => Promise<void>;
-    /**
-     * Called when Workflow calls continueAsNew
-     */
-    continueAsNew?: (input: ContinueAsNewInput, next: Next<this, 'continueAsNew'>) => Promise<never>;
-    /**
-     * Called when Workflow signals a child or external Workflow
-     */
-    signalWorkflow?: (input: SignalWorkflowInput, next: Next<this, 'signalWorkflow'>) => Promise<void>;
-    /**
-     * Called when Workflow starts a child workflow execution, the interceptor function returns 2 promises:
-     *
-     * - The first resolves with the `runId` when the child workflow has started or rejects if failed to start.
-     * - The second resolves with the workflow result when the child workflow completes or rejects on failure.
-     */
-    startChildWorkflowExecution?: (input: StartChildWorkflowExecutionInput, next: Next<this, 'startChildWorkflowExecution'>) => Promise<[Promise<string>, Promise<unknown>]>;
-    /**
-     * Called on each invocation of the `workflow.log` methods.
-     *
-     * The attributes returned in this call are attached to every log message.
-     */
-    getLogAttributes?: (input: GetLogAttributesInput, next: Next<this, 'getLogAttributes'>) => Record<string, unknown>;
-    /**
-     * Called once every time a metric is emitted from a Workflow metric (ie. a metric created
-     * from {@link workflow.metricMeter}).
-     *
-     * Tags returned by this hook are _prepended_ to tags defined at the metric level and tags
-     * defined on the emitter function itself.
-     */
-    getMetricTags?: (input: GetMetricTagsInput, next: Next<this, 'getMetricTags'>) => MetricTags;
-}
-/** Input for WorkflowInternalsInterceptor.concludeActivation */
-export interface ConcludeActivationInput {
-    commands: coresdk.workflow_commands.IWorkflowCommand[];
-}
-/** Output for WorkflowInternalsInterceptor.concludeActivation */
-export type ConcludeActivationOutput = ConcludeActivationInput;
-/** Input for WorkflowInternalsInterceptor.activate */
-export interface ActivateInput {
-    activation: coresdk.workflow_activation.IWorkflowActivation;
-    batchIndex: number;
-}
-/** Input for WorkflowInternalsInterceptor.dispose */
-export interface DisposeInput {
+export interface ContinueAsNewInput {
+    readonly args: unknown[];
+    readonly headers: Headers;
+    readonly options: ContinueAsNewInputOptions;
 }
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.continueAsNew}.
+ */
+export type ContinueAsNewInputOptions = ContinueAsNewOptions & Required<Pick<ContinueAsNewOptions, 'workflowType'>>;
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.getLogAttributes}.
+ */
+export type GetLogAttributesInput = Record<string, unknown>;
+/**
+ * Input for {@link WorkflowOutboundCallsInterceptor.getMetricTags}.
+ */
+export type GetMetricTagsInput = MetricTags;
 /**
  * Interceptor for the internals of the Workflow runtime.
  *
@@ -215,28 +320,24 @@ export interface WorkflowInternalsInterceptor {
     dispose?(input: DisposeInput, next: Next<this, 'dispose'>): void;
 }
 /**
- * A mapping from interceptor type to an optional list of interceptor implementations
+ * Input for {@link WorkflowInternalsInterceptor.activate}
  */
-export interface WorkflowInterceptors {
-    inbound?: WorkflowInboundCallsInterceptor[];
-    outbound?: WorkflowOutboundCallsInterceptor[];
-    internals?: WorkflowInternalsInterceptor[];
+export interface ActivateInput {
+    readonly activation: coresdk.workflow_activation.IWorkflowActivation;
+    readonly batchIndex: number;
 }
 /**
- * A function that returns {@link WorkflowInterceptors} and takes no arguments.
- *
- * Workflow interceptor modules should export an `interceptors` function of this type.
- *
- * @example
- *
- * ```ts
- * export function interceptors(): WorkflowInterceptors {
- *   return {
- *     inbound: [],   // Populate with list of interceptor implementations
- *     outbound: [],  // Populate with list of interceptor implementations
- *     internals: [], // Populate with list of interceptor implementations
- *   };
- * }
- * ```
+ * Input for {@link WorkflowInternalsInterceptor.dispose}
  */
-export type WorkflowInterceptorsFactory = () => WorkflowInterceptors;
+export interface DisposeInput {
+}
+/**
+ * Input for {@link WorkflowInternalsInterceptor.concludeActivation}
+ */
+export interface ConcludeActivationInput {
+    readonly commands: coresdk.workflow_commands.IWorkflowCommand[];
+}
+/**
+ * Output for {@link WorkflowInternalsInterceptor.concludeActivation}
+ */
+export type ConcludeActivationOutput = ConcludeActivationInput;

package/lib/interceptors.js

@@ -1,8 +1,6 @@
 "use strict";
 /**
- * Type definitions and generic helpers for interceptors.
- *
- * The Workflow specific interceptors are defined here.
+ * Type definitions for Workflow interceptors.
  *
  * @module
  */

package/lib/interceptors.js.map

@@ -1 +1 @@
-{"version":3,"file":"interceptors.js","sourceRoot":"","sources":["../src/interceptors.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}
+{"version":3,"file":"interceptors.js","sourceRoot":"","sources":["../src/interceptors.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/lib/internals.d.ts

@@ -3,7 +3,7 @@ import { FailureConverter, PayloadConverter, HandlerUnfinishedPolicy, Workflow,
 import type { coresdk } from '@temporalio/proto';
 import { RNG } from './alea';
 import { RootCancellationScope } from './cancellation-scope';
-import { QueryInput, SignalInput, UpdateInput, WorkflowExecuteInput, WorkflowInterceptors } from './interceptors';
+import { QueryInput, SignalInput, StartNexusOperationOutput, UpdateInput, WorkflowExecuteInput, WorkflowInterceptors } from './interceptors';
 import { DefaultSignalHandler, StackTraceFileLocation, WorkflowInfo, WorkflowCreateOptionsInternal, ActivationCompletion, DefaultUpdateHandler, DefaultQueryHandler } from './interfaces';
 import { type SinkCall } from './sinks';
 import { SdkFlag } from './flags';
@@ -18,9 +18,9 @@ export interface PromiseStackStore {
     childToParent: Map<Promise<unknown>, Set<Promise<unknown>>>;
     promiseToStack: Map<Promise<unknown>, Stack>;
 }
-export interface Completion {
-    resolve(val: unknown): unknown;
-    reject(reason: unknown): unknown;
+export interface Completion<Success> {
+    resolve(val: Success): void;
+    reject(reason: Error): void;
 }
 export interface Condition {
     fn(): boolean;
@@ -68,12 +68,14 @@ export declare class Activator implements ActivationHandler {
      * Map of task sequence to a Completion
      */
     readonly completions: {
-        timer: Map<number, Completion>;
-        activity: Map<number, Completion>;
-        childWorkflowStart: Map<number, Completion>;
-        childWorkflowComplete: Map<number, Completion>;
-        signalWorkflow: Map<number, Completion>;
-        cancelWorkflow: Map<number, Completion>;
+        timer: Map<number, Completion<void>>;
+        activity: Map<number, Completion<unknown>>;
+        nexusOperationStart: Map<number, Completion<StartNexusOperationOutput>>;
+        nexusOperationComplete: Map<number, Completion<unknown>>;
+        childWorkflowStart: Map<number, Completion<string>>;
+        childWorkflowComplete: Map<number, Completion<unknown>>;
+        signalWorkflow: Map<number, Completion<void>>;
+        cancelWorkflow: Map<number, Completion<void>>;
     };
     /**
      * Holds buffered Update calls until a handler is registered
@@ -193,6 +195,7 @@ export declare class Activator implements ActivationHandler {
         signalWorkflow: number;
         cancelWorkflow: number;
         condition: number;
+        nexusOperation: number;
         stack: number;
     };
     /**
@@ -263,8 +266,8 @@ export declare class Activator implements ActivationHandler {
     resolveActivity(activation: coresdk.workflow_activation.IResolveActivity): void;
     resolveChildWorkflowExecutionStart(activation: coresdk.workflow_activation.IResolveChildWorkflowExecutionStart): void;
     resolveChildWorkflowExecution(activation: coresdk.workflow_activation.IResolveChildWorkflowExecution): void;
-    resolveNexusOperationStart(_: coresdk.workflow_activation.IResolveNexusOperationStart): void;
-    resolveNexusOperation(_: coresdk.workflow_activation.IResolveNexusOperation): void;
+    resolveNexusOperationStart(activation: coresdk.workflow_activation.IResolveNexusOperationStart): void;
+    resolveNexusOperation(activation: coresdk.workflow_activation.IResolveNexusOperation): void;
     protected queryWorkflowNextHandler({ queryName, args }: QueryInput): Promise<unknown>;
     queryWorkflow(activation: coresdk.workflow_activation.IQueryWorkflow): void;
     doUpdate(activation: coresdk.workflow_activation.IDoUpdate): void;