@temporalio/workflow 1.11.8 → 1.12.0

package/lib/internals.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Activator = void 0;
 const common_1 = require("@temporalio/common");
+const payload_search_attributes_1 = require("@temporalio/common/lib/converter/payload-search-attributes");
 const interceptors_1 = require("@temporalio/common/lib/interceptors");
 const internal_workflow_1 = require("@temporalio/common/lib/internal-workflow");
 const alea_1 = require("./alea");
@@ -42,186 +43,263 @@ const [_encodeStartChildWorkflowExecutionFailedCause, decodeStartChildWorkflowEx
  * - Call user-defined functions, including any form of interceptor.
  */
 class Activator {
-    constructor({ info, now, showStackTraceSources, sourceMap, getTimeOfDay, randomnessSeed, registeredActivityNames, }) {
-        /**
-         * Cache for modules - referenced in reusable-vm.ts
-         */
-        this.moduleCache = new Map();
-        /**
-         * Map of task sequence to a Completion
-         */
-        this.completions = {
-            timer: new Map(),
-            activity: new Map(),
-            childWorkflowStart: new Map(),
-            childWorkflowComplete: new Map(),
-            signalWorkflow: new Map(),
-            cancelWorkflow: new Map(),
-        };
-        /**
-         * Holds buffered Update calls until a handler is registered
-         */
-        this.bufferedUpdates = Array();
-        /**
-         * Holds buffered signal calls until a handler is registered
-         */
-        this.bufferedSignals = Array();
-        /**
-         * Mapping of update name to handler and validator
-         */
-        this.updateHandlers = new Map();
-        /**
-         * Mapping of signal name to handler
-         */
-        this.signalHandlers = new Map();
-        /**
-         * Mapping of in-progress updates to handler execution information.
-         */
-        this.inProgressUpdates = new Map();
-        /**
-         * Mapping of in-progress signals to handler execution information.
-         */
-        this.inProgressSignals = new Map();
-        /**
-         * A sequence number providing unique identifiers for signal handler executions.
-         */
-        this.signalHandlerExecutionSeq = 0;
-        this.promiseStackStore = {
-            promiseToStack: new Map(),
-            childToParent: new Map(),
-        };
-        this.rootScope = new cancellation_scope_1.RootCancellationScope();
-        /**
-         * Mapping of query name to handler
-         */
-        this.queryHandlers = new Map([
-            [
-                '__stack_trace',
-                {
-                    handler: () => {
-                        return this.getStackTraces()
-                            .map((s) => s.formatted)
-                            .join('\n\n');
-                    },
-                    description: 'Returns a sensible stack trace.',
+    /**
+     * Cache for modules - referenced in reusable-vm.ts
+     */
+    moduleCache = new Map();
+    /**
+     * Map of task sequence to a Completion
+     */
+    completions = {
+        timer: new Map(),
+        activity: new Map(),
+        childWorkflowStart: new Map(),
+        childWorkflowComplete: new Map(),
+        signalWorkflow: new Map(),
+        cancelWorkflow: new Map(),
+    };
+    /**
+     * Holds buffered Update calls until a handler is registered
+     */
+    bufferedUpdates = Array();
+    /**
+     * Holds buffered signal calls until a handler is registered
+     */
+    bufferedSignals = Array();
+    /**
+     * Mapping of update name to handler and validator
+     */
+    updateHandlers = new Map();
+    /**
+     * Mapping of signal name to handler
+     */
+    signalHandlers = new Map();
+    /**
+     * Mapping of in-progress updates to handler execution information.
+     */
+    inProgressUpdates = new Map();
+    /**
+     * Mapping of in-progress signals to handler execution information.
+     */
+    inProgressSignals = new Map();
+    /**
+     * A sequence number providing unique identifiers for signal handler executions.
+     */
+    signalHandlerExecutionSeq = 0;
+    /**
+     * A signal handler that catches calls for non-registered signal names.
+     */
+    defaultSignalHandler;
+    /**
+     * A update handler that catches calls for non-registered update names.
+     */
+    defaultUpdateHandler;
+    /**
+     * A query handler that catches calls for non-registered query names.
+     */
+    defaultQueryHandler;
+    /**
+     * Source map file for looking up the source files in response to __enhanced_stack_trace
+     */
+    sourceMap;
+    /**
+     * Whether or not to send the sources in enhanced stack trace query responses
+     */
+    showStackTraceSources;
+    promiseStackStore = {
+        promiseToStack: new Map(),
+        childToParent: new Map(),
+    };
+    /**
+     * The error that caused the current Workflow Task to fail. Sets if a non-`TemporalFailure`
+     * error bubbles up out of the Workflow function, or out of a Signal or Update handler. We
+     * capture errors this way because those functions are not technically awaited when started,
+     * but left to run asynchronously. There is therefore no real "parent" function that can
+     * directly handle those errors, and not capturing it would result in an Unhandled Promise
+     * Rejection. So instead, we buffer the error here, to then be processed in the context
+     * of our own synchronous Activation handling event loop.
+     *
+     * Our code does a best effort to stop processing the current activation as soon as possible
+     * after this field is set:
+     *  - If an error is thrown while executing code synchronously (e.g. anything before the
+     *    first `await` statement in a Workflow function or a signal/update handler), the error
+     *    will be _immediately_ rethrown, which will prevent execution of further jobs in the
+     *    current activation. We know we're currently running code synchronously thanks to the
+     *    `rethrowSynchronously` flag below.
+     *  - It an error is thrown while executing microtasks, then the error will be rethrown on
+     *    the next call to `tryUnblockConditions()`.
+     *
+     * Unfortunately, there's no way for us to prevent further execution of microtasks that have
+     * already been scheduled, nor those that will be recursively scheduled from those microtasks.
+     * Should more errors get thrown while settling microtasks, those will be ignored (i.e. only
+     * the first captured error is preserved).
+     */
+    workflowTaskError;
+    /**
+     * Set to true when running synchronous code (e.g. while processing activation jobs and when calling
+     * `tryUnblockConditions()`). While this flag is set, it is safe to let errors bubble up.
+     */
+    rethrowSynchronously = false;
+    rootScope = new cancellation_scope_1.RootCancellationScope();
+    /**
+     * Mapping of query name to handler
+     */
+    queryHandlers = new Map([
+        [
+            '__stack_trace',
+            {
+                handler: () => {
+                    return this.getStackTraces()
+                        .map((s) => s.formatted)
+                        .join('\n\n');
                 },
-            ],
-            [
-                '__enhanced_stack_trace',
-                {
-                    handler: () => {
-                        const { sourceMap } = this;
-                        const sdk = { name: 'typescript', version: pkg_1.default.version };
-                        const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
-                        const sources = {};
-                        if (this.showStackTraceSources) {
-                            for (const { locations } of stacks) {
-                                for (const { file_path } of locations) {
-                                    if (!file_path)
-                                        continue;
-                                    const content = sourceMap?.sourcesContent?.[sourceMap?.sources.indexOf(file_path)];
-                                    if (!content)
-                                        continue;
-                                    sources[file_path] = [
-                                        {
-                                            line_offset: 0,
-                                            content,
-                                        },
-                                    ];
-                                }
+                description: 'Returns a sensible stack trace.',
+            },
+        ],
+        [
+            '__enhanced_stack_trace',
+            {
+                handler: () => {
+                    const { sourceMap } = this;
+                    const sdk = { name: 'typescript', version: pkg_1.default.version };
+                    const stacks = this.getStackTraces().map(({ structured: locations }) => ({ locations }));
+                    const sources = {};
+                    if (this.showStackTraceSources) {
+                        for (const { locations } of stacks) {
+                            for (const { file_path } of locations) {
+                                if (!file_path)
+                                    continue;
+                                const content = sourceMap?.sourcesContent?.[sourceMap?.sources.indexOf(file_path)];
+                                if (!content)
+                                    continue;
+                                sources[file_path] = [
+                                    {
+                                        line_offset: 0,
+                                        content,
+                                    },
+                                ];
                             }
                         }
-                        return { sdk, stacks, sources };
-                    },
-                    description: 'Returns a stack trace annotated with source information.',
+                    }
+                    return { sdk, stacks, sources };
                 },
-            ],
-            [
-                '__temporal_workflow_metadata',
-                {
-                    handler: () => {
-                        const workflowType = this.info.workflowType;
-                        const queryDefinitions = Array.from(this.queryHandlers.entries()).map(([name, value]) => ({
-                            name,
-                            description: value.description,
-                        }));
-                        const signalDefinitions = Array.from(this.signalHandlers.entries()).map(([name, value]) => ({
-                            name,
-                            description: value.description,
-                        }));
-                        const updateDefinitions = Array.from(this.updateHandlers.entries()).map(([name, value]) => ({
-                            name,
-                            description: value.description,
-                        }));
-                        return {
-                            definition: {
-                                type: workflowType,
-                                queryDefinitions,
-                                signalDefinitions,
-                                updateDefinitions,
-                            },
-                        };
-                    },
-                    description: 'Returns metadata associated with this workflow.',
+                description: 'Returns a stack trace annotated with source information.',
+            },
+        ],
+        [
+            '__temporal_workflow_metadata',
+            {
+                handler: () => {
+                    const workflowType = this.info.workflowType;
+                    const queryDefinitions = Array.from(this.queryHandlers.entries()).map(([name, value]) => ({
+                        name,
+                        description: value.description,
+                    }));
+                    const signalDefinitions = Array.from(this.signalHandlers.entries()).map(([name, value]) => ({
+                        name,
+                        description: value.description,
+                    }));
+                    const updateDefinitions = Array.from(this.updateHandlers.entries()).map(([name, value]) => ({
+                        name,
+                        description: value.description,
+                    }));
+                    return {
+                        definition: {
+                            type: workflowType,
+                            queryDefinitions,
+                            signalDefinitions,
+                            updateDefinitions,
+                        },
+                    };
                 },
-            ],
-        ]);
-        /**
-         * Loaded in {@link initRuntime}
-         */
-        this.interceptors = {
-            inbound: [],
-            outbound: [],
-            internals: [],
-        };
-        /**
-         * Buffer that stores all generated commands, reset after each activation
-         */
-        this.commands = [];
-        /**
-         * Stores all {@link condition}s that haven't been unblocked yet
-         */
-        this.blockedConditions = new Map();
-        /**
-         * Is this Workflow completed?
-         *
-         * A Workflow will be considered completed if it generates a command that the
-         * system considers as a final Workflow command (e.g.
-         * completeWorkflowExecution or failWorkflowExecution).
-         */
-        this.completed = false;
-        /**
-         * Was this Workflow cancelled?
-         */
-        this.cancelled = false;
-        /**
-         * The next (incremental) sequence to assign when generating completable commands
-         */
-        this.nextSeqs = {
-            timer: 1,
-            activity: 1,
-            childWorkflow: 1,
-            signalWorkflow: 1,
-            cancelWorkflow: 1,
-            condition: 1,
-            // Used internally to keep track of active stack traces
-            stack: 1,
-        };
-        this.payloadConverter = common_1.defaultPayloadConverter;
-        this.failureConverter = common_1.defaultFailureConverter;
-        /**
-         * Patches we know the status of for this workflow, as in {@link patched}
-         */
-        this.knownPresentPatches = new Set();
-        /**
-         * Patches we sent to core {@link patched}
-         */
-        this.sentPatches = new Set();
-        this.knownFlags = new Set();
-        /**
-         * Buffered sink calls per activation
-         */
-        this.sinkCalls = Array();
+                description: 'Returns metadata associated with this workflow.',
+            },
+        ],
+    ]);
+    /**
+     * Loaded in {@link initRuntime}
+     */
+    interceptors = {
+        inbound: [],
+        outbound: [],
+        internals: [],
+    };
+    /**
+     * Buffer that stores all generated commands, reset after each activation
+     */
+    commands = [];
+    /**
+     * Stores all {@link condition}s that haven't been unblocked yet
+     */
+    blockedConditions = new Map();
+    /**
+     * Is this Workflow completed?
+     *
+     * A Workflow will be considered completed if it generates a command that the
+     * system considers as a final Workflow command (e.g.
+     * completeWorkflowExecution or failWorkflowExecution).
+     */
+    completed = false;
+    /**
+     * Was this Workflow cancelled?
+     */
+    cancelled = false;
+    /**
+     * The next (incremental) sequence to assign when generating completable commands
+     */
+    nextSeqs = {
+        timer: 1,
+        activity: 1,
+        childWorkflow: 1,
+        signalWorkflow: 1,
+        cancelWorkflow: 1,
+        condition: 1,
+        // Used internally to keep track of active stack traces
+        stack: 1,
+    };
+    /**
+     * This is set every time the workflow executes an activation
+     * May be accessed and modified from outside the VM.
+     */
+    now;
+    /**
+     * Reference to the current Workflow, initialized when a Workflow is started
+     */
+    workflow;
+    /**
+     * Information about the current Workflow
+     * May be accessed from outside the VM.
+     */
+    info;
+    /**
+     * A deterministic RNG, used by the isolate's overridden Math.random
+     */
+    random;
+    payloadConverter = common_1.defaultPayloadConverter;
+    failureConverter = common_1.defaultFailureConverter;
+    /**
+     * Patches we know the status of for this workflow, as in {@link patched}
+     */
+    knownPresentPatches = new Set();
+    /**
+     * Patches we sent to core {@link patched}
+     */
+    sentPatches = new Set();
+    knownFlags = new Set();
+    /**
+     * Buffered sink calls per activation
+     */
+    sinkCalls = Array();
+    /**
+     * A nanosecond resolution time function, externally injected. This is used to
+     * precisely sort logs entries emitted from the Workflow Context vs those emitted
+     * from other sources (e.g. main thread, Core, etc).
+     */
+    getTimeOfDay;
+    registeredActivityNames;
+    versioningBehavior;
+    workflowDefinitionOptionsGetter;
+    constructor({ info, now, showStackTraceSources, sourceMap, getTimeOfDay, randomnessSeed, registeredActivityNames, }) {
         this.getTimeOfDay = getTimeOfDay;
         this.info = info;
         this.now = now;
@@ -281,6 +359,7 @@ class Activator {
         return {
             commands: this.commands.splice(0),
             usedInternalFlags: [...this.knownFlags],
+            versioningBehavior: this.versioningBehavior,
         };
     }
     async startWorkflowNextHandler({ args }) {
@@ -302,13 +381,17 @@ class Activator {
         // Most things related to initialization have already been handled in the constructor
         this.mutateWorkflowInfo((info) => ({
             ...info,
-            searchAttributes: (0, common_1.mapFromPayloads)(common_1.searchAttributePayloadConverter, searchAttributes?.indexedFields) ?? {},
+            searchAttributes: (0, payload_search_attributes_1.decodeSearchAttributes)(searchAttributes?.indexedFields),
+            typedSearchAttributes: (0, payload_search_attributes_1.decodeTypedSearchAttributes)(searchAttributes?.indexedFields),
             memo: (0, common_1.mapFromPayloads)(this.payloadConverter, memo?.fields),
             lastResult: (0, common_1.fromPayloadsAtIndex)(this.payloadConverter, 0, lastCompletionResult?.payloads),
             lastFailure: continuedFailure != null
                 ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter)
                 : undefined,
         }));
+        if (this.workflowDefinitionOptionsGetter) {
+            this.versioningBehavior = this.workflowDefinitionOptionsGetter().versioningBehavior;
+        }
     }
     cancelWorkflow(_activation) {
         this.cancelled = true;
@@ -344,14 +427,6 @@ class Activator {
             reject(new errors_1.LocalActivityDoBackoff(activation.result.backoff));
         }
     }
-    resolveNexusOperationStart(_activation) {
-        // This will never be called as we can't produce Nexus-related commands anyway
-        throw new Error('Nexus is not yet implemented');
-    }
-    resolveNexusOperation(_activation) {
-        // This will never be called as we can't produce Nexus-related commands anyway
-        throw new Error('Nexus is not yet implemented');
-    }
     resolveChildWorkflowExecutionStart(activation) {
         const { resolve, reject } = this.consumeCompletion('childWorkflowStart', getSeq(activation));
         if (activation.succeeded) {
@@ -401,14 +476,25 @@ class Activator {
             reject(this.failureToError(failure));
         }
     }
+    resolveNexusOperationStart(_) {
+        throw new Error('TODO');
+    }
+    resolveNexusOperation(_) {
+        throw new Error('TODO');
+    }
     // Intentionally non-async function so this handler doesn't show up in the stack trace
     queryWorkflowNextHandler({ queryName, args }) {
-        const fn = this.queryHandlers.get(queryName)?.handler;
+        let fn = this.queryHandlers.get(queryName)?.handler;
+        if (fn === undefined && this.defaultQueryHandler !== undefined) {
+            fn = this.defaultQueryHandler.bind(undefined, queryName);
+        }
+        // No handler or default registered, fail.
         if (fn === undefined) {
             const knownQueryTypes = [...this.queryHandlers.keys()].join(' ');
             // Fail the query
             return Promise.reject(new ReferenceError(`Workflow did not register a handler for ${queryName}. Registered queries: [${knownQueryTypes}]`));
         }
+        // Execute handler.
         try {
             const ret = fn(...args);
             if (ret instanceof Promise) {
@@ -444,8 +530,17 @@ class Activator {
         if (!protocolInstanceId) {
             throw new TypeError('Missing activation update protocolInstanceId');
         }
-        const entry = this.updateHandlers.get(name);
-        if (!entry) {
+        const entry = this.updateHandlers.get(name) ??
+            (this.defaultUpdateHandler
+                ? {
+                    handler: this.defaultUpdateHandler.bind(undefined, name),
+                    validator: undefined,
+                    // Default to a warning policy.
+                    unfinishedPolicy: common_1.HandlerUnfinishedPolicy.WARN_AND_ABANDON,
+                }
+                : null);
+        // If we don't have an entry from either source, buffer and return
+        if (entry === null) {
             this.bufferedUpdates.push(activation);
             return;
         }
@@ -506,7 +601,7 @@ class Activator {
                     this.rejectUpdate(protocolInstanceId, error);
                 }
                 else {
-                    throw error;
+                    this.handleWorkflowFailure(error);
                 }
             })
                 .finally(() => this.inProgressUpdates.delete(updateId));
@@ -526,13 +621,22 @@ class Activator {
     dispatchBufferedUpdates() {
         const bufferedUpdates = this.bufferedUpdates;
         while (bufferedUpdates.length) {
-            const foundIndex = bufferedUpdates.findIndex((update) => this.updateHandlers.has(update.name));
-            if (foundIndex === -1) {
-                // No buffered Updates have a handler yet.
-                break;
+            // We have a default update handler, so all updates are dispatchable.
+            if (this.defaultUpdateHandler) {
+                const update = bufferedUpdates.shift();
+                // Logically, this must be defined as we're in the loop.
+                // But Typescript doesn't know that so we use a non-null assertion (!).
+                this.doUpdate(update);
+            }
+            else {
+                const foundIndex = bufferedUpdates.findIndex((update) => this.updateHandlers.has(update.name));
+                if (foundIndex === -1) {
+                    // No buffered Updates have a handler yet.
+                    break;
+                }
+                const [update] = bufferedUpdates.splice(foundIndex, 1);
+                this.doUpdate(update);
             }
-            const [update] = bufferedUpdates.splice(foundIndex, 1);
-            this.doUpdate(update);
         }
     }
     rejectBufferedUpdates() {
@@ -617,6 +721,8 @@ class Activator {
         }
     }
     warnIfUnfinishedHandlers() {
+        if (this.workflowTaskError)
+            return;
         const getWarnable = (handlerExecutions) => {
             return Array.from(handlerExecutions).filter((ex) => ex.unfinishedPolicy === common_1.HandlerUnfinishedPolicy.WARN_AND_ABANDON);
         };
@@ -717,19 +823,14 @@ class Activator {
      * Transforms failures into a command to be sent to the server.
      * Used to handle any failure emitted by the Workflow.
      */
-    async handleWorkflowFailure(error) {
+    handleWorkflowFailure(error) {
         if (this.cancelled && (0, errors_1.isCancellation)(error)) {
             this.pushCommand({ cancelWorkflowExecution: {} }, true);
         }
         else if (error instanceof interfaces_1.ContinueAsNew) {
             this.pushCommand({ continueAsNewWorkflowExecution: error.command }, true);
         }
-        else {
-            if (!(error instanceof common_1.TemporalFailure)) {
-                // This results in an unhandled rejection which will fail the activation
-                // preventing it from completing.
-                throw error;
-            }
+        else if (error instanceof common_1.TemporalFailure) {
             // Fail the workflow. We do not want to issue unfinishedHandlers warnings. To achieve that, we
             // mark all handlers as completed now.
             this.inProgressSignals.clear();
@@ -740,6 +841,27 @@ class Activator {
                 },
             }, true);
         }
+        else {
+            this.recordWorkflowTaskError(error);
+        }
+    }
+    recordWorkflowTaskError(error) {
+        // Only keep the first error that bubbles up; subsequent errors will be ignored.
+        if (this.workflowTaskError === undefined)
+            this.workflowTaskError = error;
+        // Immediately rethrow the error if we know it is safe to do so (i.e. we are not running async
+        // microtasks). Otherwise, the error will be rethrown whenever we get an opportunity to do so,
+        // e.g. the next time `tryUnblockConditions()` is called.
+        if (this.rethrowSynchronously)
+            this.maybeRethrowWorkflowTaskError();
+    }
+    /**
+     * If a Workflow Task error was captured, and we are running in synchronous mode,
+     * then bubble it up now. This is safe to call even if there is no error to rethrow.
+     */
+    maybeRethrowWorkflowTaskError() {
+        if (this.workflowTaskError)
+            throw this.workflowTaskError;
     }
     completeQuery(queryId, result) {
         this.pushCommand({