@hatchet-dev/typescript-sdk 1.16.0 → 1.17.1

package/README.md

@@ -63,9 +63,21 @@ pnpm install
 pnpm build
 ```
 
-3. Run tests:
+3. Run unit tests:
 ```bash
-pnpm test
+pnpm test:unit
+```
+
+4. Run e2e tests (requires a running Hatchet engine):
+```bash
+# Run all e2e tests
+pnpm test:e2e
+
+# Run a specific e2e test file
+pnpm test:e2e durable.e2e.ts
+
+# Run a specific test by name
+pnpm test:e2e durable.e2e.ts -t "durable replay reset"
 ```
 
 ## Contributing

package/clients/admin/admin-client.d.ts

@@ -1,10 +1,10 @@
 import { Channel, ClientFactory } from 'nice-grpc';
-import { CreateWorkflowVersionOpts, RateLimitDuration, WorkerLabelComparator, WorkflowServiceClient } from '../../protoc/workflows';
+import { CreateWorkflowVersionOpts, RateLimitDuration, WorkflowServiceClient } from '../../protoc/workflows';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
-import { Priority, RunsClient } from '../../v1';
+import { Priority, RunsClient, WorkerLabelComparator } from '../../v1';
 import { Api } from '../rest';
 import { WebhookWorkerCreateRequest, WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
 import { RunListenerClient } from '../listeners/run-listener/child-listener-client';

package/clients/dispatcher/action-listener.d.ts

@@ -7,14 +7,11 @@ declare enum ListenStrategy {
     LISTEN_STRATEGY_V1 = 1,
     LISTEN_STRATEGY_V2 = 2
 }
+export type ActionKey = `${string}/${number}`;
 export type Action = AssignedAction & {
-    /** @deprecated use taskRunId */
-    stepRunId?: string;
-    /** @deprecated use taskId */
-    stepId?: string;
+    readonly key: ActionKey;
 };
-export type ActionKey = string;
-export declare function createActionKey(action: Action): ActionKey;
+export declare function createAction(assignedAction: AssignedAction): Action;
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;

package/clients/dispatcher/action-listener.js

@@ -66,8 +66,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionListener = void 0;
-exports.createActionKey = createActionKey;
-const dispatcher_1 = require("../../protoc/dispatcher");
+exports.createAction = createAction;
 const nice_grpc_1 = require("nice-grpc");
 const grpc_error_1 = require("../../util/grpc-error");
 const abort_controller_x_1 = require("abort-controller-x");
@@ -81,19 +80,16 @@ var ListenStrategy;
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
 })(ListenStrategy || (ListenStrategy = {}));
-function createActionKey(action) {
-    switch (action.actionType) {
-        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
-            return `${action.getGroupKeyRunId}/${action.retryCount}`;
-        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
-        case dispatcher_1.ActionType.START_STEP_RUN:
-        case dispatcher_1.ActionType.UNRECOGNIZED:
-            return `${action.taskRunExternalId}/${action.retryCount}`;
-        default:
-            // eslint-disable-next-line no-case-declarations
-            const exhaustivenessCheck = action.actionType;
-            throw new Error(`Unhandled action type: ${exhaustivenessCheck}`);
-    }
+function createAction(assignedAction) {
+    const action = assignedAction;
+    Object.defineProperty(action, 'key', {
+        get() {
+            return `${this.taskRunExternalId}/${this.retryCount}`;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    return action;
 }
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
@@ -117,8 +113,7 @@ class ActionListener {
                                 _c = listenClient_1_1.value;
                                 _d = false;
                                 const assignedAction = _c;
-                                const action = Object.assign(Object.assign({}, assignedAction), { stepRunId: assignedAction.taskRunExternalId, stepId: assignedAction.taskId });
-                                yield yield __await(action);
+                                yield yield __await(createAction(assignedAction));
                             }
                         }
                         catch (e_1_1) { e_1 = { error: e_1_1 }; }

package/clients/listeners/durable-listener/durable-listener-client.d.ts

@@ -1,31 +1,132 @@
+import { EventEmitter } from 'events';
 import { Channel, ClientFactory } from 'nice-grpc';
 import { ClientConfig } from '../../hatchet-client/client-config';
 import { Logger } from '../../../util/logger';
-import { V1DispatcherClient } from '../../../protoc/v1/dispatcher';
-import { SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
-import { Api } from '../../rest';
-import { DurableEventGrpcPooledListener } from './pooled-durable-listener-client';
+import { V1DispatcherClient, DurableEvent, RegisterDurableEventResponse } from '../../../protoc/v1/dispatcher';
+import { DurableEventListenerConditions, SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
+import { TriggerWorkflowRequest } from '../../../protoc/v1/shared/trigger';
+export interface DurableTaskRunAckEntryResult {
+    nodeId: number;
+    branchId: number;
+    workflowRunExternalId: string;
+}
+export interface DurableTaskEventRunAck {
+    ackType: 'run';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    runEntries: DurableTaskRunAckEntryResult[];
+}
+export interface DurableTaskEventMemoAck {
+    ackType: 'memo';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    branchId: number;
+    nodeId: number;
+    memoAlreadyExisted: boolean;
+    memoResultPayload?: Uint8Array;
+}
+export interface DurableTaskEventWaitForAck {
+    ackType: 'waitFor';
+    invocationCount: number;
+    durableTaskExternalId: string;
+    branchId: number;
+    nodeId: number;
+}
+export type DurableTaskEventAck = DurableTaskEventRunAck | DurableTaskEventMemoAck | DurableTaskEventWaitForAck;
+export interface DurableTaskEventLogEntryResult {
+    durableTaskExternalId: string;
+    nodeId: number;
+    payload: Record<string, unknown> | undefined;
+}
+export interface WaitForEvent {
+    kind: 'waitFor';
+    waitForConditions: DurableEventListenerConditions;
+}
+export interface RunChildrenEvent {
+    kind: 'runChildren';
+    triggerOpts: TriggerWorkflowRequest[];
+}
+export interface MemoEvent {
+    kind: 'memo';
+    memoKey: Uint8Array;
+    payload?: Uint8Array;
+}
+export type DurableTaskSendEvent = WaitForEvent | RunChildrenEvent | MemoEvent;
 export declare class DurableListenerClient {
     config: ClientConfig;
     client: V1DispatcherClient;
     logger: Logger;
-    api: Api;
-    pooledListener: DurableEventGrpcPooledListener | undefined;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
+    private _workerId;
+    private _running;
+    private _requestQueue;
+    private _requestNotify;
+    private _pendingEventAcks;
+    private _pendingCallbacks;
+    private _bufferedCompletions;
+    private _pendingEvictionAcks;
+    private _receiveAbort;
+    private _statusInterval;
+    private _startLock;
+    onServerEvict: ((durableTaskExternalId: string, invocationCount: number) => void) | undefined;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    get workerId(): string | undefined;
+    start(workerId: string): Promise<void>;
+    private _doStart;
+    ensureStarted(workerId: string): Promise<void>;
+    stop(): Promise<void>;
+    private _connect;
+    private _streamLoop;
+    private _requestIterator;
+    private _enqueueRequest;
+    private _startStatusPolling;
+    private _pollWorkerStatus;
+    private _failPendingAcks;
+    private _failAllPending;
+    private _handleResponse;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: RunChildrenEvent): Promise<DurableTaskEventRunAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: WaitForEvent): Promise<DurableTaskEventWaitForAck>;
+    sendEvent(durableTaskExternalId: string, invocationCount: number, event: MemoEvent): Promise<DurableTaskEventMemoAck>;
+    waitForCallback(durableTaskExternalId: string, invocationCount: number, branchId: number, nodeId: number, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableTaskEventLogEntryResult>;
+    cleanupTaskState(durableTaskExternalId: string, invocationCount: number): void;
+    sendEvictInvocation(durableTaskExternalId: string, invocationCount: number, reason?: string): Promise<void>;
+    sendMemoCompletedNotification(durableTaskExternalId: string, nodeId: number, branchId: number, invocationCount: number, memoKey: Uint8Array, memoResultPayload?: Uint8Array): Promise<void>;
+    /**
+     * @deprecated Legacy backward-compat: uses the old unary RegisterDurableEvent RPC.
+     */
+    registerDurableEvent(request: {
+        taskId: string;
+        signalKey: string;
+        sleepConditions: Array<SleepMatchCondition>;
+        userEventConditions: Array<UserEventMatchCondition>;
+    }): Promise<RegisterDurableEventResponse>;
+    /**
+     * @deprecated Legacy backward-compat: uses the old streaming ListenForDurableEvent RPC.
+     */
     subscribe(request: {
         taskId: string;
         signalKey: string;
-    }): import("./pooled-durable-listener-client").DurableEventStreamable;
+    }): LegacyDurableEventStreamable;
+    /**
+     * @deprecated Legacy backward-compat: subscribes and waits for a single result.
+     */
     result(request: {
         taskId: string;
         signalKey: string;
     }, opts?: {
         signal?: AbortSignal;
-    }): Promise<import("../../../protoc/v1/dispatcher").DurableEvent>;
-    registerDurableEvent(request: {
-        taskId: string;
-        signalKey: string;
-        sleepConditions: Array<SleepMatchCondition>;
-        userEventConditions: Array<UserEventMatchCondition>;
-    }): Promise<import("../../../protoc/v1/dispatcher").RegisterDurableEventResponse>;
+    }): Promise<DurableEvent>;
+    private _legacyPooledListener;
+}
+/**
+ * @deprecated Legacy support for the old streaming ListenForDurableEvent RPC.
+ */
+export declare class LegacyDurableEventStreamable {
+    responseEmitter: EventEmitter<[never]>;
+    private _onCleanup;
+    constructor(onCleanup: () => void);
+    get(opts?: {
+        signal?: AbortSignal;
+    }): Promise<DurableEvent>;
 }