@restatedev/restate-sdk 1.3.2 → 1.4.0

package/dist/cjs/src/promise_combinator_tracker.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromiseCombinatorTracker = exports.newJournalEntryPromiseId = exports.PromiseType = void 0;
-const promises_js_1 = require("./utils/promises.js");
-var PromiseType;
-(function (PromiseType) {
-    PromiseType[PromiseType["JournalEntry"] = 0] = "JournalEntry";
-    // Combinator?,
-    // SideEffect?
-})(PromiseType || (exports.PromiseType = PromiseType = {}));
-function newJournalEntryPromiseId(entryIndex) {
-    return {
-        type: PromiseType.JournalEntry,
-        id: entryIndex,
-    };
-}
-exports.newJournalEntryPromiseId = newJournalEntryPromiseId;
-/**
- * Prepare a Promise combinator
- *
- * @param combinatorIndex the index of this combinator
- * @param combinatorConstructor the function that creates the combinator promise, e.g. Promise.all/any/race/allSettled
- * @param promises the promises given by the user, and the respective ids
- * @param readReplayOrder the function to read the replay order
- * @param onNewCompleted callback when a child entry is resolved
- * @param onCombinatorResolved callback when the combinator is resolved
- * @param onCombinatorReplayed callback when the combinator is replayed
- */
-function preparePromiseCombinator(combinatorIndex, combinatorConstructor, promises, readReplayOrder, onNewCompleted, onCombinatorResolved, onCombinatorReplayed) {
-    // Create the proxy promises and index them
-    const promisesWithProxyPromise = promises.map((v) => ({
-        id: v.id,
-        originalPromise: v.promise,
-        proxyPromise: new promises_js_1.CompletablePromise(),
-    }));
-    const promisesMap = new Map(promisesWithProxyPromise.map((v) => [
-        // We need to define a key format for this map...
-        v.id.type.toString() + "-" + v.id.id.toString(),
-        { originalPromise: v.originalPromise, proxyPromise: v.proxyPromise },
-    ]));
-    // Create the combinator using the proxy promises
-    const combinator = combinatorConstructor(promisesWithProxyPromise.map((v) => v.proxyPromise.promise)).finally(
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    async () => 
-    // Once the combinator is resolved, notify back.
-    await onCombinatorResolved(combinatorIndex));
-    return (0, promises_js_1.wrapDeeply)(combinator, () => {
-        const replayOrder = readReplayOrder(combinatorIndex);
-        if (replayOrder === undefined) {
-            // We're in processing mode! We need to wire up original promises with proxy promises
-            for (const { originalPromise, proxyPromise, id, } of promisesWithProxyPromise) {
-                originalPromise
-                    // This code works deterministically because the javascript runtime will enqueue
-                    // the listeners of the proxy promise (which are mounted in Promise.all/any) in a single FIFO queue,
-                    // so a subsequent resolve on another proxy promise can't overtake this one.
-                    //
-                    // Some resources:
-                    // * https://stackoverflow.com/questions/38059284/why-does-javascript-promise-then-handler-run-after-other-code
-                    // * https://262.ecma-international.org/6.0/#sec-jobs-and-job-queues
-                    // * https://tr.javascript.info/microtask-queue
-                    .then((v) => {
-                    onNewCompleted(combinatorIndex, id);
-                    proxyPromise.resolve(v);
-                }, (e) => {
-                    onNewCompleted(combinatorIndex, id);
-                    proxyPromise.reject(e);
-                });
-            }
-            return;
-        }
-        // We're in replay mode, Now follow the replayIndexes order.
-        onCombinatorReplayed(combinatorIndex);
-        for (const promiseId of replayOrder) {
-            // These are already completed, so once we set the then callback they will be immediately resolved.
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const { originalPromise, proxyPromise } = promisesMap.get(promiseId.type.toString() + "-" + promiseId.id.toString());
-            // Because this promise is already completed, promise.then will immediately enqueue in the promise microtask queue
-            // the handlers to execute.
-            // See the comment below for more details.
-            originalPromise.then((v) => proxyPromise.resolve(v), (e) => proxyPromise.reject(e));
-        }
-    });
-}
-/**
- * This class takes care of creating and managing deterministic promise combinators.
- *
- * It should be wired up to the journal/state machine methods to read and write entries.
- */
-class PromiseCombinatorTracker {
-    readReplayOrder;
-    onWriteCombinatorOrder;
-    nextCombinatorIndex = 0;
-    pendingCombinators = new Map();
-    constructor(readReplayOrder, onWriteCombinatorOrder) {
-        this.readReplayOrder = readReplayOrder;
-        this.onWriteCombinatorOrder = onWriteCombinatorOrder;
-    }
-    createCombinator(combinatorConstructor, promises) {
-        const combinatorIndex = this.nextCombinatorIndex;
-        this.nextCombinatorIndex++;
-        // Prepare combinator order
-        this.pendingCombinators.set(combinatorIndex, []);
-        return preparePromiseCombinator(combinatorIndex, combinatorConstructor, promises, this.readReplayOrder, this.appendOrder.bind(this), this.onCombinatorResolved.bind(this), this.onCombinatorReplayed.bind(this));
-    }
-    appendOrder(idx, promiseId) {
-        const order = this.pendingCombinators.get(idx);
-        if (order === undefined) {
-            // The order was already published, nothing to do here.
-            return;
-        }
-        order.push(promiseId);
-    }
-    onCombinatorReplayed(idx) {
-        // This avoids republishing the order
-        this.pendingCombinators.delete(idx);
-    }
-    async onCombinatorResolved(idx) {
-        const order = this.pendingCombinators.get(idx);
-        if (order === undefined) {
-            // It was already published
-            return;
-        }
-        // We don't need this list anymore.
-        this.pendingCombinators.delete(idx);
-        // Publish the combinator order
-        await this.onWriteCombinatorOrder(idx, order);
-    }
-}
-exports.PromiseCombinatorTracker = PromiseCombinatorTracker;
-//# sourceMappingURL=promise_combinator_tracker.js.map

package/dist/cjs/src/promise_combinator_tracker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise_combinator_tracker.js","sourceRoot":"","sources":["../../../src/promise_combinator_tracker.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/state_machine.d.ts

@@ -1,85 +0,0 @@
-/// <reference types="node" />
-import * as p from "./types/protocol.js";
-import type { Connection, RestateStreamConsumer } from "./connection/connection.js";
-import { Message } from "./types/types.js";
-import type { StateMachineConsole } from "./utils/message_logger.js";
-import type { Invocation } from "./invocation.js";
-import type { JournalErrorContext } from "./types/errors.js";
-import type { LocalStateStore } from "./local_state_store.js";
-import type { Logger, LoggerContext } from "./logger.js";
-import type { WrappedPromise } from "./utils/promises.js";
-import type { PromiseId } from "./promise_combinator_tracker.js";
-import { Buffer } from "node:buffer";
-import type { HandlerKind } from "./types/rpc.js";
-import type { Empty } from "./generated/proto/protocol_pb.js";
-export declare class StateMachine implements RestateStreamConsumer {
-    private readonly connection;
-    private readonly invocation;
-    private readonly suspensionMillis;
-    private journal;
-    private restateContext;
-    private readonly invocationComplete;
-    private stateMachineClosed;
-    readonly localStateStore: LocalStateStore;
-    private inputChannelClosed;
-    private suspensionTimeout?;
-    private promiseCombinatorTracker;
-    console: StateMachineConsole;
-    constructor(connection: Connection, invocation: Invocation, handlerKind: HandlerKind, logger: Logger, loggerContext: LoggerContext, extraArgs: unknown[], suspensionMillis?: number);
-    handleMessage(m: Message): boolean;
-    handleUserCodeMessage(messageType: bigint, message: p.ProtocolMessage, completedFlag?: boolean, requiresAckFlag?: boolean): WrappedPromise<Uint8Array | Empty | void>;
-    createCombinator(combinatorConstructor: (promises: PromiseLike<unknown>[]) => Promise<unknown>, promises: Array<{
-        id: PromiseId;
-        promise: Promise<unknown>;
-    }>): WrappedPromise<unknown>;
-    readCombinatorOrderEntry(combinatorId: number): PromiseId[] | undefined;
-    writeCombinatorOrderEntry(combinatorId: number, order: PromiseId[]): Promise<void>;
-    /**
-     * Invokes the RPC function and returns a promise that completes when the state machine
-     * stops processing the invocation, meaning when:
-     *   - The function completes with a result or an exception
-     *   - The execution suspends
-     *   - An error is raised in the state machine (network, API violation, ...)
-     *
-     * The returned promise resolves successfully for all the cases above, because the are (from
-     * the perspective of the state machine) expected outcomes in which it send out corresponding
-     * result messages and cleanly closed the connection.
-     *
-     * The returned promise is rejected when an unhandled error arises and the caller would be
-     * expected to ensure that resources are properly cleaned up.
-     */
-    invoke(): Promise<Buffer | void>;
-    sendErrorAndFinish(e: Error, ctx?: JournalErrorContext): Promise<void>;
-    private sendRetryableError;
-    private sendTerminalError;
-    private send;
-    /**
-     * Closes the state machine, flushes all output, and resolves the invocation promise.
-     */
-    private finish;
-    /**
-     * This function propagates errors up to the completion promise, to be handled
-     * on the connection layer.
-     */
-    private unhandledError;
-    /**
-     * This method is invoked when we hit a suspension point. A suspension point is everytime the user "await"s a Promise returned by RestateContext that might be completed at a later point in time by a CompletionMessage/AckMessage.
-     *
-     * Depending on the state of the read channel, it might either immediately suspend, or schedule a suspension to happen at a later point in time.
-     */
-    private hitSuspensionPoint;
-    private getSuspensionMillis;
-    private suspend;
-    /**
-     * WARNING: make sure you use this at the right point in the code
-     * After the index has been incremented...
-     * This is error-prone... Would be good to have a better solution for this.
-     */
-    getUserCodeJournalIndex(): number;
-    handleInputClosed(): void;
-    handleStreamError(e: Error): void;
-    handleDanglingPromiseError(e: Error): void;
-    nextEntryWillBeReplayed(): boolean;
-    private clearSuspensionTimeout;
-}
-//# sourceMappingURL=state_machine.d.ts.map

package/dist/cjs/src/state_machine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state_machine.d.ts","sourceRoot":"","sources":["../../../src/state_machine.ts"],"names":[],"mappings":";AAWA,OAAO,KAAK,CAAC,MAAM,qBAAqB,CAAC;AAEzC,OAAO,KAAK,EACV,UAAU,EACV,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAerE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAO7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAMjE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAE9D,qBAAa,YAAa,YAAW,qBAAqB;IA4BtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAK3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAjCnC,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,cAAc,CAAc;IAEpC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA2C;IAO9E,OAAO,CAAC,kBAAkB,CAAS;IAEnC,SAAgB,eAAe,EAAE,eAAe,CAAC;IAKjD,OAAO,CAAC,kBAAkB,CAAS;IAGnC,OAAO,CAAC,iBAAiB,CAAC,CAAiB;IAE3C,OAAO,CAAC,wBAAwB,CAA2B;IAE3D,OAAO,EAAE,mBAAmB,CAAC;gBAGV,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,EAC5B,SAAS,EAAE,OAAO,EAAE,EACH,gBAAgB,GAAE,MAAe;IA6B7C,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO;IAwClC,qBAAqB,CAC1B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,CAAC,CAAC,eAAe,EAC1B,aAAa,CAAC,EAAE,OAAO,EACvB,eAAe,CAAC,EAAE,OAAO,GACxB,cAAc,CAAC,UAAU,GAAG,KAAK,GAAG,IAAI,CAAC;IAyCrC,gBAAgB,CACrB,qBAAqB,EAAE,CACrB,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,KAC7B,OAAO,CAAC,OAAO,CAAC,EACrB,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;IAe/D,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,SAAS;IA8CjE,yBAAyB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE;IA+BxE;;;;;;;;;;;;;OAaG;IACI,MAAM,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAuG1B,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,mBAAmB;IAWnE,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,iBAAiB;IAsBzB,OAAO,CAAC,IAAI;IAMZ;;OAEG;YACW,MAAM;IAcpB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAOtB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,mBAAmB;YAIb,OAAO;IAmCrB;;;;OAIG;IACI,uBAAuB,IAAI,MAAM;IAIjC,iBAAiB,IAAI,IAAI;IAmBzB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI;IASjC,0BAA0B,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI;IAS1C,uBAAuB;IAI9B,OAAO,CAAC,sBAAsB;CAM/B"}

package/dist/cjs/src/state_machine.js

@@ -1,426 +0,0 @@
-"use strict";
-/*
- * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
- *
- * This file is part of the Restate SDK for Node.js/TypeScript,
- * which is released under the MIT license.
- *
- * You can find a copy of the license in file LICENSE in the root
- * directory of this repository or package, or at
- * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateMachine = void 0;
-const p = __importStar(require("./types/protocol.js"));
-const context_impl_js_1 = require("./context_impl.js");
-const types_js_1 = require("./types/types.js");
-const message_logger_js_1 = require("./utils/message_logger.js");
-const protocol_js_1 = require("./types/protocol.js");
-const journal_js_1 = require("./journal.js");
-const errors_js_1 = require("./types/errors.js");
-const logger_js_1 = require("./logger.js");
-const promises_js_1 = require("./utils/promises.js");
-const promise_combinator_tracker_js_1 = require("./promise_combinator_tracker.js");
-const javascript_pb_js_1 = require("./generated/proto/javascript_pb.js");
-const node_buffer_1 = require("node:buffer");
-class StateMachine {
-    connection;
-    invocation;
-    suspensionMillis;
-    journal;
-    restateContext;
-    invocationComplete = new promises_js_1.CompletablePromise();
-    // when this flag is true, no more work will (and may) happen
-    // this is set to true in case of
-    //  - a completed invocation
-    //  - a suspension
-    //  - an error in the state machine
-    stateMachineClosed = false;
-    localStateStore;
-    // Whether the input channel (runtime -> service) is closed
-    // If it is closed, then we suspend immediately upon the next suspension point
-    // If it is open, then we suspend later because we might still get completions
-    inputChannelClosed = false;
-    // Suspension timeout that gets set and cleared based on completion messages;
-    suspensionTimeout;
-    promiseCombinatorTracker;
-    console;
-    constructor(connection, invocation, handlerKind, logger, loggerContext, extraArgs, suspensionMillis = 30_000) {
-        this.connection = connection;
-        this.invocation = invocation;
-        this.suspensionMillis = suspensionMillis;
-        this.localStateStore = invocation.localStateStore;
-        this.console = (0, message_logger_js_1.createStateMachineConsole)(logger, loggerContext);
-        this.journal = new journal_js_1.Journal(this.invocation);
-        this.restateContext = new context_impl_js_1.ContextImpl(this.invocation.id, 
-        // The console exposed by RestateContext filters logs in replay, while the internal one is based on the ENV variables.
-        (0, logger_js_1.createRestateConsole)(logger, logger_js_1.LogSource.USER, loggerContext, this.journal.nextEntryWillBeReplayed.bind(this.journal)), handlerKind, invocation.userKey, invocation.invocationValue, invocation.invocationHeaders, connection.headers(), extraArgs, this);
-        this.promiseCombinatorTracker = new promise_combinator_tracker_js_1.PromiseCombinatorTracker(this.readCombinatorOrderEntry.bind(this), this.writeCombinatorOrderEntry.bind(this));
-    }
-    handleMessage(m) {
-        if (this.stateMachineClosed) {
-            // ignore this message
-            return false;
-        }
-        if (m.messageType === protocol_js_1.COMPLETION_MESSAGE_TYPE) {
-            this.console.debugJournalMessage("Received completion message from Restate, adding to journal.", m.messageType, m.message);
-            this.journal.handleRuntimeCompletionMessage(m.message);
-        }
-        else if (m.messageType === protocol_js_1.ENTRY_ACK_MESSAGE_TYPE) {
-            this.console.debugJournalMessage("Received entry ack message from Restate, adding to journal.", m.messageType, m.message);
-            this.journal.handleEntryAckMessage(m.message);
-        }
-        else {
-            throw errors_js_1.RetryableError.protocolViolation(`Received message of type ${m.messageType}. Can only accept completion or acks messages after replay has finished.`);
-        }
-        // Remove lingering suspension timeouts, if we are not waiting for completions anymore
-        if (this.suspensionTimeout !== undefined &&
-            this.journal.getCompletableIndices().length === 0) {
-            clearTimeout(this.suspensionTimeout);
-            this.suspensionTimeout = undefined;
-        }
-        return false; // we are never complete
-    }
-    handleUserCodeMessage(messageType, message, completedFlag, requiresAckFlag) {
-        // if the state machine is already closed, return a promise that never
-        // completes, so that the user code does not resume
-        if (this.stateMachineClosed) {
-            return promises_js_1.WRAPPED_PROMISE_PENDING;
-        }
-        const promise = this.journal.handleUserSideMessage(messageType, message);
-        const journalIndex = this.journal.getUserCodeJournalIndex();
-        // Only send the message to restate if we are not in replaying mode
-        if (this.journal.isProcessing()) {
-            this.console.debugJournalMessage("Adding message to journal and sending to Restate", messageType, message);
-            this.send(new types_js_1.Message(messageType, message, completedFlag, requiresAckFlag));
-        }
-        else {
-            this.console.debugJournalMessage("Matched and replayed message from journal", messageType, message);
-        }
-        return (0, promises_js_1.wrapDeeply)(promise, () => {
-            if (!p.SUSPENSION_TRIGGERS.includes(messageType)) {
-                return;
-            }
-            if (this.journal.isUnResolved(journalIndex)) {
-                this.hitSuspensionPoint();
-            }
-        });
-    }
-    // -- Methods related to combinators to wire up promise combinator API with PromiseCombinatorTracker
-    createCombinator(combinatorConstructor, promises) {
-        if (this.stateMachineClosed) {
-            return promises_js_1.WRAPPED_PROMISE_PENDING;
-        }
-        // We don't need the promise wrapping here to schedule a suspension,
-        // because the combined promises will already have that, so once we call then() on them,
-        // if we have to suspend we will suspend.
-        return this.promiseCombinatorTracker.createCombinator(combinatorConstructor, promises);
-    }
-    readCombinatorOrderEntry(combinatorId) {
-        const wannabeCombinatorEntry = this.journal.readNextReplayEntry();
-        if (wannabeCombinatorEntry === undefined) {
-            // We're in processing mode
-            return undefined;
-        }
-        if (wannabeCombinatorEntry.messageType !== protocol_js_1.COMBINATOR_ENTRY_MESSAGE) {
-            throw errors_js_1.RetryableError.journalMismatch(this.journal.getUserCodeJournalIndex(), wannabeCombinatorEntry, {
-                messageType: protocol_js_1.COMBINATOR_ENTRY_MESSAGE,
-                message: {
-                    combinatorId,
-                },
-            });
-        }
-        const combinatorMessage = wannabeCombinatorEntry.message;
-        if (combinatorMessage.combinatorId != combinatorId) {
-            throw errors_js_1.RetryableError.journalMismatch(this.journal.getUserCodeJournalIndex(), wannabeCombinatorEntry, {
-                messageType: protocol_js_1.COMBINATOR_ENTRY_MESSAGE,
-                message: {
-                    combinatorId,
-                },
-            });
-        }
-        this.console.debugJournalMessage("Matched and replayed message from journal", protocol_js_1.COMBINATOR_ENTRY_MESSAGE, combinatorMessage);
-        return combinatorMessage.journalEntriesOrder.map((id) => ({
-            id,
-            type: promise_combinator_tracker_js_1.PromiseType.JournalEntry,
-        }));
-    }
-    async writeCombinatorOrderEntry(combinatorId, order) {
-        if (this.journal.isProcessing()) {
-            const combinatorMessage = new javascript_pb_js_1.CombinatorEntryMessage({
-                combinatorId,
-                journalEntriesOrder: order.map((pid) => pid.id),
-            });
-            this.console.debugJournalMessage("Adding message to journal and sending to Restate", protocol_js_1.COMBINATOR_ENTRY_MESSAGE, combinatorMessage);
-            const ackPromise = this.journal.appendJournalEntry(protocol_js_1.COMBINATOR_ENTRY_MESSAGE, combinatorMessage);
-            this.send(new types_js_1.Message(protocol_js_1.COMBINATOR_ENTRY_MESSAGE, combinatorMessage, undefined, true));
-            this.hitSuspensionPoint();
-            await ackPromise;
-        }
-    }
-    /**
-     * Invokes the RPC function and returns a promise that completes when the state machine
-     * stops processing the invocation, meaning when:
-     *   - The function completes with a result or an exception
-     *   - The execution suspends
-     *   - An error is raised in the state machine (network, API violation, ...)
-     *
-     * The returned promise resolves successfully for all the cases above, because the are (from
-     * the perspective of the state machine) expected outcomes in which it send out corresponding
-     * result messages and cleanly closed the connection.
-     *
-     * The returned promise is rejected when an unhandled error arises and the caller would be
-     * expected to ensure that resources are properly cleaned up.
-     */
-    invoke() {
-        // --------------------------------------------------------------------------------------------
-        // Implementation note:
-        //
-        // This method is not async, because we don't want to actually await anything
-        // in there. We cannot await the completion of the actual invocation, because for long-running
-        // code (that suspends), the function invocation never completes. Instead, the state machine
-        // triggers a suspension.
-        // We need to do a bit of promise chaining for the rpc function promise, and return a different
-        // promise that completes in also in suspension and error cases.
-        // --------------------------------------------------------------------------------------------
-        // it is unexpected for the state machine to be closed here, so we raise an error in
-        // that case, unlike in other places, where we simply ignore things
-        if (this.stateMachineClosed) {
-            return Promise.reject(new Error("state machine is already closed"));
-        }
-        if (this.journal.nextEntryWillBeReplayed()) {
-            this.console.info("Resuming (replaying) function.");
-        }
-        else {
-            this.console.info("Invoking function.");
-        }
-        this.invocation.handler
-            .invoke(this.restateContext, this.invocation.invocationValue)
-            .then((bytes) => {
-            // invocation successfully returned with a result value
-            try {
-                // the state machine might be closed here in some cases like when there was an error (like
-                // API violation) or a suspension, but the function code still completed
-                if (this.stateMachineClosed) {
-                    this.console.warn("Unexpected successful completion of the function after the state machine closed. " +
-                        "This may indicate that: \n" +
-                        "- the function code does not properly await some Restate calls " +
-                        "and did not notice an error \n" +
-                        "- the function code was delayed for longer than the suspension timeout \n" +
-                        "- the function code contained a try-catch block around a side effect which throws retryable errors. " +
-                        "This try-catch block should be placed inside the side effect.");
-                    return;
-                }
-                const value = node_buffer_1.Buffer.from(bytes);
-                // handle the result value
-                const msg = new types_js_1.Message(protocol_js_1.OUTPUT_ENTRY_MESSAGE_TYPE, new protocol_js_1.OutputEntryMessage({
-                    result: { case: "value", value },
-                }));
-                void this.journal.handleUserSideMessage(msg.messageType, msg.message);
-                if (!this.journal.outputMsgWasReplayed()) {
-                    this.send(msg);
-                    this.console.debugJournalMessage("Journaled and sent output message", msg.messageType, msg.message);
-                }
-                else {
-                    this.console.debugJournalMessage("Replayed and matched output message from journal", msg.messageType, msg.message);
-                }
-                this.console.info("Function completed successfully.");
-                // Mark the end of the invocation
-                this.send(new types_js_1.Message(protocol_js_1.END_MESSAGE_TYPE, new protocol_js_1.EndMessage()));
-                void this.finish(value);
-            }
-            catch (e) {
-                this.unhandledError((0, errors_js_1.ensureError)(e));
-            }
-        })
-            .catch((e) => {
-            // because of how we try/catch in the promise handler above, this here exclusively handles
-            // errors coming from the rpc function
-            try {
-                // Sometimes the function code fails as a consequence of the state machine encountering
-                // an error before (possibly Restate closed the connection).
-                if (this.stateMachineClosed) {
-                    return;
-                }
-                void this.sendErrorAndFinish((0, errors_js_1.ensureError)(e));
-            }
-            catch (ee) {
-                this.unhandledError((0, errors_js_1.ensureError)(ee));
-            }
-        });
-        // this promise here completes under any completion, including the cases where the
-        // rpc function does not end (error, suspension, ...)
-        return this.invocationComplete.promise;
-    }
-    async sendErrorAndFinish(e, ctx) {
-        this.console.warn("Function completed with an error.\n", e);
-        if (e instanceof errors_js_1.TerminalError) {
-            this.sendTerminalError(e);
-        }
-        else {
-            this.sendRetryableError(e, ctx);
-        }
-        await this.finish();
-    }
-    sendRetryableError(e, ctx) {
-        const msg = new types_js_1.Message(protocol_js_1.ERROR_MESSAGE_TYPE, (0, errors_js_1.errorToErrorMessage)(e, ctx));
-        this.console.debugJournalMessage("Invocation ended with retryable error.", msg.messageType, msg.message);
-        this.send(msg);
-    }
-    sendTerminalError(e) {
-        const msg = new types_js_1.Message(protocol_js_1.OUTPUT_ENTRY_MESSAGE_TYPE, new protocol_js_1.OutputEntryMessage({
-            result: { case: "failure", value: e.toFailure() },
-        }));
-        this.console.debugJournalMessage("Invocation ended with failure message.", msg.messageType, msg.message);
-        void this.journal.handleUserSideMessage(msg.messageType, msg.message);
-        if (!this.journal.outputMsgWasReplayed()) {
-            this.send(msg);
-        }
-        // Mark the end of the invocation
-        this.send(new types_js_1.Message(protocol_js_1.END_MESSAGE_TYPE, new protocol_js_1.EndMessage()));
-    }
-    send(message) {
-        this.connection.send(message).catch((err) => {
-            this.handleStreamError(err);
-        });
-    }
-    /**
-     * Closes the state machine, flushes all output, and resolves the invocation promise.
-     */
-    async finish(value) {
-        try {
-            this.stateMachineClosed = true;
-            this.journal.close();
-            this.clearSuspensionTimeout();
-            await this.connection.end();
-            this.invocationComplete.resolve(value);
-        }
-        catch (e) {
-            this.invocationComplete.reject((0, errors_js_1.ensureError)(e));
-        }
-    }
-    /**
-     * This function propagates errors up to the completion promise, to be handled
-     * on the connection layer.
-     */
-    unhandledError(e) {
-        this.invocationComplete.reject(e);
-        this.stateMachineClosed = true;
-        this.journal.close();
-        this.clearSuspensionTimeout();
-    }
-    /**
-     * This method is invoked when we hit a suspension point. A suspension point is everytime the user "await"s a Promise returned by RestateContext that might be completed at a later point in time by a CompletionMessage/AckMessage.
-     *
-     * Depending on the state of the read channel, it might either immediately suspend, or schedule a suspension to happen at a later point in time.
-     */
-    hitSuspensionPoint() {
-        // If there was already a timeout set, we want to reset the time to postpone suspension as long as we make progress.
-        // So we first clear the old timeout, and then we set a new one.
-        this.clearSuspensionTimeout();
-        const delay = this.getSuspensionMillis();
-        this.console.debugJournalMessage("Scheduling suspension in " + delay + " ms");
-        if (delay >= 0) {
-            // Set a new suspension with a new timeout
-            // The suspension will only be sent if the timeout is not canceled due to a completion.
-            // In case the delay is 0 we still schedule a timeout in order to process the suspension on the next process tick,
-            // without interrupting the current work.
-            this.suspensionTimeout = setTimeout(() => {
-                void this.suspend();
-            }, delay);
-        }
-    }
-    // Suspension timeouts:
-    // - suspend after 30 seconds if input channel is still open (can still get completions)
-    // - suspend immediately if input channel is closed (cannot get completions)
-    getSuspensionMillis() {
-        return this.inputChannelClosed ? 0 : this.suspensionMillis;
-    }
-    async suspend() {
-        const indices = this.journal.getCompletableIndices();
-        // If the state is closed then we either already send a suspension
-        // or something else bad happened...
-        if (this.journal.isClosed() || indices.length === 0) {
-            return;
-        }
-        // There need to be journal entries to complete, otherwise this timeout should have been removed.
-        // A suspension message is the end of the invocation.
-        // Resolve the root call with the suspension message
-        // This will lead to a onCallSuccess call where this msg will be sent.
-        const msg = new types_js_1.Message(protocol_js_1.SUSPENSION_MESSAGE_TYPE, new protocol_js_1.SuspensionMessage({
-            entryIndexes: indices,
-        }));
-        this.console.debugJournalMessage("Writing suspension message to journal.", msg.messageType, msg.message);
-        void this.journal.handleUserSideMessage(msg.messageType, msg.message);
-        if (!this.journal.outputMsgWasReplayed()) {
-            this.send(msg);
-        }
-        this.console.info("Suspending function.");
-        await this.finish();
-    }
-    /**
-     * WARNING: make sure you use this at the right point in the code
-     * After the index has been incremented...
-     * This is error-prone... Would be good to have a better solution for this.
-     */
-    getUserCodeJournalIndex() {
-        return this.journal.getUserCodeJournalIndex();
-    }
-    handleInputClosed() {
-        if (this.journal.isClosed() ||
-            this.stateMachineClosed ||
-            this.inputChannelClosed) {
-            return;
-        }
-        this.inputChannelClosed = true;
-        this.console.debug("Restate closed connection to trigger suspension.");
-        // If there is a timeout planned, reset the timout to execute immediately when the work is done.
-        if (this.suspensionTimeout !== undefined) {
-            this.hitSuspensionPoint();
-        }
-    }
-    handleStreamError(e) {
-        this.console.info("Aborting function execution and closing state machine due to connection error: " +
-            e.message);
-        this.unhandledError(e);
-    }
-    handleDanglingPromiseError(e) {
-        this.console.info("Aborting function execution and closing state machine due to an error: " +
-            e.message);
-        this.unhandledError(e);
-    }
-    nextEntryWillBeReplayed() {
-        return this.journal.nextEntryWillBeReplayed();
-    }
-    clearSuspensionTimeout() {
-        if (this.suspensionTimeout !== undefined) {
-            clearTimeout(this.suspensionTimeout);
-            this.suspensionTimeout = undefined;
-        }
-    }
-}
-exports.StateMachine = StateMachine;
-//# sourceMappingURL=state_machine.js.map