@hatchet-dev/typescript-sdk 1.0.0-alpha1 → 1.0.0

package/v1/client/features/runs.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunsClient = void 0;
+/**
+ * RunsClient is used to list and manage runs
+ */
+class RunsClient {
+    constructor(client) {
+        this.api = client.api;
+        this.tenantId = client.tenantId;
+    }
+    // TODO expose streaming methods?
+    get(run) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runId = typeof run === 'string' ? run : yield run.getWorkflowRunId();
+            const { data } = yield this.api.workflowRunGet(this.tenantId, runId);
+            return data;
+        });
+    }
+    getDetails(run) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runId = typeof run === 'string' ? run : yield run.getWorkflowRunId();
+            const { data } = yield this.api.workflowRunGetShape(this.tenantId, runId);
+            return data;
+        });
+    }
+    list(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO workflow id on opts is a uuid
+            const { data } = yield this.api.workflowRunList(this.tenantId, opts);
+            return data;
+        });
+    }
+    replay(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO is v1 check
+            // TODO   workflowIds?: string[]; on opts.filters
+            const { data } = yield this.api.v1TaskReplay(this.tenantId, opts);
+            return data;
+        });
+    }
+    cancel(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO is v1 check
+            // TODO   workflowIds?: string[]; on opts.filters
+            const { data } = yield this.api.v1TaskCancel(this.tenantId, opts);
+            return data;
+        });
+    }
+}
+exports.RunsClient = RunsClient;

package/v1/client/features/workers.d.ts

@@ -0,0 +1,14 @@
+import { HatchetClient } from '../client';
+/**
+ * WorkersClient is used to list and manage workers
+ */
+export declare class WorkersClient {
+    api: HatchetClient['api'];
+    tenantId: string;
+    constructor(client: HatchetClient);
+    get(workerId: string): Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+    list(): Promise<import("../../../clients/rest/generated/data-contracts").WorkerList>;
+    isPaused(workerId: string): Promise<boolean>;
+    pause(workerId: string): Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+    unpause(workerId: string): Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+}

package/v1/client/features/workers.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkersClient = void 0;
+/**
+ * WorkersClient is used to list and manage workers
+ */
+class WorkersClient {
+    constructor(client) {
+        this.api = client.api;
+        this.tenantId = client.tenantId;
+    }
+    get(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.workerGet(workerId);
+            return data;
+        });
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.workerList(this.tenantId);
+            return data;
+        });
+    }
+    isPaused(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wf = yield this.get(workerId);
+            return wf.status === 'PAUSED';
+        });
+    }
+    pause(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.workerUpdate(workerId, {
+                isPaused: true,
+            });
+            return data;
+        });
+    }
+    unpause(workerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.workerUpdate(workerId, {
+                isPaused: false,
+            });
+            return data;
+        });
+    }
+}
+exports.WorkersClient = WorkersClient;

package/v1/client/features/workflows.d.ts

@@ -0,0 +1,17 @@
+import { Workflow } from '../../../workflow';
+import { BaseWorkflowDeclaration } from '../..';
+import { HatchetClient } from '../client';
+export declare const workflowNameString: (workflow: string | Workflow | BaseWorkflowDeclaration<any, any>) => string;
+/**
+ * WorkflowsClient is used to list and manage workflows
+ */
+export declare class WorkflowsClient {
+    api: HatchetClient['api'];
+    tenantId: string;
+    private workflowCache;
+    private cacheTTL;
+    constructor(client: HatchetClient, cacheTTL?: number);
+    get(workflow: string | BaseWorkflowDeclaration<any, any> | Workflow): Promise<any>;
+    list(opts?: Parameters<typeof this.api.workflowList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowList>;
+    delete(workflow: string | BaseWorkflowDeclaration<any, any> | Workflow): Promise<void>;
+}

package/v1/client/features/workflows.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowsClient = exports.workflowNameString = void 0;
+const workflowNameString = (workflow) => (typeof workflow === 'string' ? workflow : workflow.id);
+exports.workflowNameString = workflowNameString;
+/**
+ * WorkflowsClient is used to list and manage workflows
+ */
+class WorkflowsClient {
+    constructor(client, cacheTTL) {
+        // Add a cache for workflows
+        this.workflowCache = new Map();
+        // Default cache TTL: 5 minutes (in ms)
+        this.cacheTTL = 5 * 60 * 1000;
+        this.api = client.api;
+        this.tenantId = client.tenantId;
+        // Allow custom cache TTL if provided
+        if (cacheTTL !== undefined) {
+            this.cacheTTL = cacheTTL;
+        }
+    }
+    get(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get workflow name string
+            const name = (0, exports.workflowNameString)(workflow);
+            // Check cache first
+            const cached = this.workflowCache.get(name);
+            if (cached && cached.expiry > Date.now()) {
+                return cached.workflow;
+            }
+            // If not in cache or expired, fetch from API
+            try {
+                // Since the API only supports listing with a name filter,
+                // we'll use the list endpoint with a name filter
+                const { data } = yield this.api.workflowList(this.tenantId, {
+                    name,
+                });
+                if (data && data.rows && data.rows.length > 0) {
+                    const wf = data.rows[0];
+                    // Cache the result
+                    this.workflowCache.set(name, {
+                        workflow: wf,
+                        expiry: Date.now() + this.cacheTTL,
+                    });
+                    return workflow;
+                }
+                throw new Error(`Workflow with name ${name} not found`);
+            }
+            catch (error) {
+                // Clear cache on error
+                this.workflowCache.delete(name);
+                throw error;
+            }
+        });
+    }
+    list(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.api.workflowList(this.tenantId, opts);
+            return data;
+        });
+    }
+    delete(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = (0, exports.workflowNameString)(workflow);
+            try {
+                // Get the workflow first to find its ID
+                const workflowObj = yield this.get(name);
+                if (!workflowObj || !workflowObj.metadata || !workflowObj.metadata.id) {
+                    throw new Error(`Could not find workflow with name ${name}`);
+                }
+                const { data } = yield this.api.workflowDelete(workflowObj.metadata.id);
+                // Remove from cache after deletion
+                this.workflowCache.delete(name);
+                return data;
+            }
+            catch (error) {
+                // Clear cache on error
+                this.workflowCache.delete(name);
+                throw error;
+            }
+        });
+    }
+}
+exports.WorkflowsClient = WorkflowsClient;

package/v1/client/worker.d.ts

@@ -3,64 +3,72 @@ import { InternalHatchetClient } from '../../clients/hatchet-client';
 import { V0Worker } from '../../clients/worker';
 import { Workflow as V0Workflow } from '../../workflow';
 import { WebhookWorkerCreateRequest } from '../../clients/rest/generated/data-contracts';
-import { WorkflowDeclaration } from '../workflow';
+import { BaseWorkflowDeclaration } from '../declaration';
+import { HatchetClient } from '..';
 /**
  * Options for creating a new hatchet worker
  * @interface CreateWorkerOpts
  */
 export interface CreateWorkerOpts {
-    /** Maximum number of concurrent runs on this worker */
+    /** (optional) Maximum number of concurrent runs on this worker, defaults to 100 */
     slots?: number;
-    /** Array of workflows to register */
-    workflows?: WorkflowDeclaration<any, any>[] | V0Workflow[];
-    /** Worker labels for affinity-based assignment */
+    /** (optional) Array of workflows to register */
+    workflows?: BaseWorkflowDeclaration<any, any>[] | V0Workflow[];
+    /** (optional) Worker labels for affinity-based assignment */
     labels?: WorkerLabels;
-    /** Whether to handle kill signals */
+    /** (optional) Whether to handle kill signals */
     handleKill?: boolean;
     /** @deprecated Use slots instead */
     maxRuns?: number;
+    /** (optional) Maximum number of concurrent runs on the durable worker, defaults to 1,000 */
+    durableSlots?: number;
 }
 /**
  * HatchetWorker class for workflow execution runtime
  */
 export declare class Worker {
+    config: CreateWorkerOpts;
+    name: string;
+    _v1: HatchetClient;
+    _v0: InternalHatchetClient;
     /** Internal reference to the underlying V0 worker implementation */
-    v0: V0Worker;
+    nonDurable: V0Worker;
+    durable?: V0Worker;
     /**
      * Creates a new HatchetWorker instance
-     * @param v0 - The V0 worker implementation
+     * @param nonDurable - The V0 worker implementation
      */
-    constructor(v0: V0Worker);
+    constructor(v1: HatchetClient, v0: InternalHatchetClient, nonDurable: V0Worker, config: CreateWorkerOpts, name: string);
     /**
      * Creates and initializes a new HatchetWorker
      * @param v0 - The HatchetClient instance
      * @param options - Worker creation options
      * @returns A new HatchetWorker instance
      */
-    static create(v0: InternalHatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
+    static create(v1: HatchetClient, v0: InternalHatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
     /**
      * Registers workflows with the worker
      * @param workflows - Array of workflows to register
      * @returns Array of registered workflow promises
      */
-    registerWorkflows(workflows?: Array<WorkflowDeclaration<any, any> | V0Workflow>): Promise<void[]>;
+    registerWorkflows(workflows?: Array<BaseWorkflowDeclaration<any, any> | V0Workflow>): Promise<void[]>;
     /**
      * Registers a single workflow with the worker
      * @param workflow - The workflow to register
      * @returns A promise that resolves when the workflow is registered
      * @deprecated use registerWorkflows instead
      */
-    registerWorkflow(workflow: WorkflowDeclaration<any, any> | V0Workflow): Promise<void[]>;
+    registerWorkflow(workflow: BaseWorkflowDeclaration<any, any> | V0Workflow): Promise<void[]>;
     /**
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed
      */
-    start(): Promise<void>;
+    start(): Promise<void[]>;
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
-    stop(): Promise<void>;
+    stop(): Promise<void[]>;
     /**
      * Updates or inserts worker labels
      * @param labels - Worker labels to update
@@ -78,5 +86,7 @@ export declare class Worker {
      * @returns A promise that resolves when the webhook is registered
      */
     registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    isPaused(): Promise<boolean>;
+    pause(): Promise<any[]>;
+    unpause(): Promise<any[]>;
 }
-export declare function toV0Workflow(wf: WorkflowDeclaration<any, any> | V0Workflow): V0Workflow;

package/v1/client/worker.js

@@ -10,18 +10,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Worker = void 0;
-exports.toV0Workflow = toV0Workflow;
-const workflow_1 = require("../workflow");
+const declaration_1 = require("../declaration");
+const DEFAULT_DURABLE_SLOTS = 1000;
 /**
  * HatchetWorker class for workflow execution runtime
  */
 class Worker {
     /**
      * Creates a new HatchetWorker instance
-     * @param v0 - The V0 worker implementation
+     * @param nonDurable - The V0 worker implementation
      */
-    constructor(v0) {
-        this.v0 = v0;
+    constructor(v1, v0, nonDurable, config, name) {
+        this._v1 = v1;
+        this._v0 = v0;
+        this.nonDurable = nonDurable;
+        this.config = config;
+        this.name = name;
     }
     /**
      * Creates and initializes a new HatchetWorker
@@ -29,10 +33,10 @@ class Worker {
      * @param options - Worker creation options
      * @returns A new HatchetWorker instance
      */
-    static create(v0, name, options) {
+    static create(v1, v0, name, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const v0worker = yield v0.worker(name, Object.assign(Object.assign({}, options), { maxRuns: options.slots || options.maxRuns }));
-            const worker = new Worker(v0worker);
+            const worker = new Worker(v1, v0, v0worker, options, name);
             yield worker.registerWorkflows(options.workflows);
             return worker;
         });
@@ -44,9 +48,21 @@ class Worker {
      */
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            return Promise.all((workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => {
-                return this.v0.registerWorkflow(toV0Workflow(wf));
-            })) || []);
+            return Promise.all((workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => __awaiter(this, void 0, void 0, function* () {
+                if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    // TODO check if tenant is V1
+                    const register = this.nonDurable.registerWorkflowV1(wf);
+                    if (wf.definition._durableTasks.length > 0) {
+                        if (!this.durable) {
+                            this.durable = yield this._v0.worker(`${this.name}-durable`, Object.assign(Object.assign({}, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS }));
+                        }
+                        this.durable.registerDurableActionsV1(wf.definition);
+                    }
+                    return register;
+                }
+                // fallback to v0 client for backwards compatibility
+                return this.nonDurable.registerWorkflow(wf);
+            }))) || []);
         });
     }
     /**
@@ -63,14 +79,22 @@ class Worker {
      * @returns Promise that resolves when the worker is stopped or killed
      */
     start() {
-        return this.v0.start();
+        const workers = [this.nonDurable];
+        if (this.durable) {
+            workers.push(this.durable);
+        }
+        return Promise.all(workers.map((w) => w.start()));
     }
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
     stop() {
-        return this.v0.stop();
+        const workers = [this.nonDurable];
+        if (this.durable) {
+            workers.push(this.durable);
+        }
+        return Promise.all(workers.map((w) => w.stop()));
     }
     /**
      * Updates or inserts worker labels
@@ -78,14 +102,14 @@ class Worker {
      * @returns Promise that resolves when labels are updated
      */
     upsertLabels(labels) {
-        return this.v0.upsertLabels(labels);
+        return this.nonDurable.upsertLabels(labels);
     }
     /**
      * Get the labels for the worker
      * @returns The labels for the worker
      */
     getLabels() {
-        return this.v0.labels;
+        return this.nonDurable.labels;
     }
     /**
      * Register a webhook with the worker
@@ -93,39 +117,44 @@ class Worker {
      * @returns A promise that resolves when the webhook is registered
      */
     registerWebhook(webhook) {
-        return this.v0.registerWebhook(webhook);
+        return this.nonDurable.registerWebhook(webhook);
     }
-}
-exports.Worker = Worker;
-function toV0Workflow(wf) {
-    if (wf instanceof workflow_1.WorkflowDeclaration) {
-        const { definition } = wf;
-        return {
-            id: definition.name,
-            description: definition.description || '',
-            version: definition.version || '',
-            sticky: definition.sticky,
-            scheduleTimeout: definition.scheduleTimeout,
-            on: definition.on,
-            concurrency: definition.concurrency,
-            onFailure: definition.onFailure && {
-                name: 'on-failure',
-                run: (ctx) => definition.onFailure(ctx),
-            },
-            steps: definition.tasks.map((task) => {
-                var _a;
-                return ({
-                    name: task.name,
-                    parents: (_a = task.parents) === null || _a === void 0 ? void 0 : _a.map((p) => p.name),
-                    run: (ctx) => task.fn(ctx.workflowInput(), ctx),
-                    timeout: task.timeout,
-                    retries: task.retries,
-                    rate_limits: task.rateLimits,
-                    worker_labels: task.workerLabels,
-                    backoff: task.backoff,
-                });
-            }),
-        };
+    isPaused() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const promises = [];
+            if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
+                promises.push(this._v1.workers.isPaused(this.nonDurable.workerId));
+            }
+            if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
+                promises.push(this._v1.workers.isPaused(this.durable.workerId));
+            }
+            const res = yield Promise.all(promises);
+            return !res.includes(false);
+        });
+    }
+    // TODO docstrings
+    pause() {
+        var _a, _b;
+        const promises = [];
+        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
+            promises.push(this._v1.workers.pause(this.nonDurable.workerId));
+        }
+        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
+            promises.push(this._v1.workers.pause(this.durable.workerId));
+        }
+        return Promise.all(promises);
+    }
+    unpause() {
+        var _a, _b;
+        const promises = [];
+        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
+            promises.push(this._v1.workers.unpause(this.nonDurable.workerId));
+        }
+        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
+            promises.push(this._v1.workers.unpause(this.durable.workerId));
+        }
+        return Promise.all(promises);
     }
-    return wf;
 }
+exports.Worker = Worker;

package/v1/conditions/base.d.ts

@@ -0,0 +1,18 @@
+export declare enum Action {
+    CREATE = 0,
+    QUEUE = 1,
+    CANCEL = 2,
+    SKIP = 3,
+    UNRECOGNIZED = -1
+}
+export interface BaseCondition {
+    readableDataKey?: string;
+    action?: Action;
+    /** a UUID defining the OR group for this condition */
+    orGroupId?: string;
+    expression?: string;
+}
+export declare abstract class Condition {
+    base: BaseCondition;
+    constructor(base: BaseCondition);
+}

package/v1/conditions/base.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Condition = exports.Action = void 0;
+/* eslint-disable no-shadow */
+var Action;
+(function (Action) {
+    Action[Action["CREATE"] = 0] = "CREATE";
+    Action[Action["QUEUE"] = 1] = "QUEUE";
+    Action[Action["CANCEL"] = 2] = "CANCEL";
+    Action[Action["SKIP"] = 3] = "SKIP";
+    Action[Action["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Action || (exports.Action = Action = {}));
+class Condition {
+    constructor(base) {
+        this.base = base;
+    }
+}
+exports.Condition = Condition;

package/v1/conditions/index.d.ts

@@ -0,0 +1,31 @@
+import { Condition, Action } from './base';
+import { Parent } from './parent-condition';
+import { Sleep, SleepCondition } from './sleep-condition';
+import { UserEvent, UserEventCondition } from './user-event-condition';
+export { Sleep, SleepCondition, UserEvent, UserEventCondition };
+export type IConditions = Sleep | UserEvent | Parent;
+export type Conditions = Condition | OrCondition | IConditions;
+export declare class OrCondition {
+    conditions: Condition[];
+    constructor(conditions: Condition[]);
+}
+/**
+ * Creates a condition that waits for all provided conditions to be met (AND logic)
+ * use Or() to create a condition that waits for any of the provided conditions to be met (OR logic)
+ * @param conditions - Conditions or OrConditions to be rendered
+ * @returns A flattened array of Conditions
+ *
+ * @example
+ * const conditions = Render(
+ *   Or({ sleepFor: 5 }, { eventKey: 'user:update' }),
+ *   { eventKey: 'user:create' },
+ *   Or({ eventKey: 'user:update' }, { eventKey: 'user:delete' })
+ * );
+ */
+export declare function Render(action?: Action, conditions?: Conditions | Conditions[]): Condition[];
+/**
+ * Creates a condition group with OR logic
+ * Flattens nested Or conditions to ensure proper grouping
+ */
+export declare function Or(...conditionsOrObjs: (IConditions | Condition)[]): OrCondition;
+export declare function generateGroupId(): string;