@hatchet-dev/typescript-sdk 1.13.1 → 1.14.0

package/util/abort-error.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbortError = createAbortError;
+exports.isAbortError = isAbortError;
+exports.rethrowIfAborted = rethrowIfAborted;
+exports.throwIfAborted = throwIfAborted;
+function createAbortError(message = 'Operation aborted') {
+    const err = new Error(message);
+    err.name = 'AbortError';
+    err.code = 'ABORT_ERR';
+    return err;
+}
+function isAbortError(err) {
+    return err instanceof Error && (err.name === 'AbortError' || err.code === 'ABORT_ERR');
+}
+/**
+ * Helper to be used inside broad `catch` blocks so cancellation isn't accidentally swallowed.
+ *
+ * Example:
+ * ```ts
+ * try { ... } catch (e) { rethrowIfAborted(e); ... }
+ * ```
+ */
+function rethrowIfAborted(err) {
+    if (isAbortError(err)) {
+        throw err;
+    }
+}
+/**
+ * Throws an AbortError if the provided signal is aborted.
+ *
+ * Notes:
+ * - In JS/TS, `catch` can swallow any thrown value, so this is best-effort.
+ * - We prefer throwing the signal's `reason` when it is already an Error.
+ */
+function throwIfAborted(signal, optsOrDefaultMessage = 'Operation cancelled by AbortSignal') {
+    var _a, _b;
+    if (!(signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+        return;
+    }
+    const opts = typeof optsOrDefaultMessage === 'string'
+        ? { defaultMessage: optsOrDefaultMessage }
+        : (optsOrDefaultMessage !== null && optsOrDefaultMessage !== void 0 ? optsOrDefaultMessage : {});
+    if (opts.isTrigger) {
+        const ctx = opts.context ? `${opts.context} ` : '';
+        (_a = opts.warn) === null || _a === void 0 ? void 0 : _a.call(opts, `Cancellation: ${ctx}attempted to enqueue/trigger work after cancellation was signaled. ` +
+            `This usually means an AbortError was caught and not propagated. ` +
+            `See https://docs.hatchet.run/home/cancellation`);
+    }
+    const { reason } = signal;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    if (typeof reason === 'string' && reason.length > 0) {
+        throw createAbortError(reason);
+    }
+    throw createAbortError((_b = opts.defaultMessage) !== null && _b !== void 0 ? _b : 'Operation cancelled by AbortSignal');
+}

package/util/hatchet-promise/hatchet-promise.d.ts

@@ -1,6 +1,13 @@
 declare class HatchetPromise<T> {
-    cancel: Function;
+    cancel: (reason?: any) => void;
     promise: Promise<T>;
+    /**
+     * The original (non-cancelable) promise passed to the constructor.
+     *
+     * `promise` is a cancelable wrapper which rejects immediately when `cancel` is called.
+     * `inner` continues executing and will settle when the underlying work completes.
+     */
+    inner: Promise<T>;
     constructor(promise: Promise<T>);
 }
 export default HatchetPromise;

package/util/hatchet-promise/hatchet-promise.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 class HatchetPromise {
     constructor(promise) {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.cancel = (reason) => { };
+        this.cancel = (_reason) => { };
+        this.inner = Promise.resolve(promise);
         this.promise = new Promise((resolve, reject) => {
             this.cancel = reject;
-            Promise.resolve(promise).then(resolve).catch(reject);
+            this.inner.then(resolve).catch(reject);
         });
     }
 }

package/util/logger/index.d.ts

@@ -1 +1,2 @@
 export * from './logger';
+export * from './task-run-log';

package/util/logger/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./logger"), exports);
+__exportStar(require("./task-run-log"), exports);

package/util/logger/task-run-log.d.ts

@@ -0,0 +1,3 @@
+import { ActionType } from '../../protoc/dispatcher';
+export declare function actionMap(action: ActionType): string;
+export declare function taskRunLog(taskName: string, taskRunExternalId: string, action: string): string;

package/util/logger/task-run-log.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionMap = actionMap;
+exports.taskRunLog = taskRunLog;
+const dispatcher_1 = require("../../protoc/dispatcher");
+function actionMap(action) {
+    switch (action) {
+        case dispatcher_1.ActionType.START_STEP_RUN:
+            return 'starting...';
+        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
+            return 'cancelling...';
+        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
+            return 'starting to get group key...';
+        default:
+            return 'unknown';
+    }
+}
+function taskRunLog(taskName, taskRunExternalId, action) {
+    return `Task run ${action} \t ${taskName}/${taskRunExternalId} `;
+}

package/util/sleep.d.ts

@@ -3,8 +3,11 @@
  *
  * WARNING: This is not a durable sleep. It will not be honored if the worker is
  * restarted or crashes.
+ *
  * @param ms - The number of milliseconds to sleep
- * @returns A promise that resolves after the given number of milliseconds
+ * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
+ *                 Use in task handlers so cancellation can interrupt long sleeps.
+ * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
  */
-declare const sleep: (ms: number) => Promise<unknown>;
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 export default sleep;

package/util/sleep.js

@@ -5,10 +5,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
  *
  * WARNING: This is not a durable sleep. It will not be honored if the worker is
  * restarted or crashes.
+ *
  * @param ms - The number of milliseconds to sleep
- * @returns A promise that resolves after the given number of milliseconds
+ * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
+ *                 Use in task handlers so cancellation can interrupt long sleeps.
+ * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
  */
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
+function sleep(ms, signal) {
+    if (!signal) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error('Cancelled'));
+        };
+        if (signal.aborted) {
+            clearTimeout(timer);
+            reject(new Error('Cancelled'));
+            return;
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
 exports.default = sleep;

package/util/workflow-run-ref.d.ts

@@ -12,9 +12,15 @@ export default class WorkflowRunRef<T> {
     private client;
     private runs;
     _standaloneTaskName?: string;
+    /**
+     * Optional default AbortSignal used for listener-backed waits (e.g. `.result()`).
+     * This is primarily set when a run is spawned from within a task so cancellations propagate
+     * without manually threading `{ signal }` everywhere.
+     */
+    defaultSignal?: AbortSignal;
     constructor(workflowRunId: string | Promise<string> | Promise<{
         workflowRunId: string;
-    }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string, standaloneTaskName?: string);
+    }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string, standaloneTaskName?: string, defaultSignal?: AbortSignal);
     get runId(): Promise<string>;
     getWorkflowRunId(): Promise<string>;
     stream(): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;

package/util/workflow-run-ref.js

@@ -50,12 +50,13 @@ function getWorkflowRunId(workflowRunId) {
     });
 }
 class WorkflowRunRef {
-    constructor(workflowRunId, client, runsClient, parentWorkflowRunId, standaloneTaskName) {
+    constructor(workflowRunId, client, runsClient, parentWorkflowRunId, standaloneTaskName, defaultSignal) {
         this.workflowRunId = workflowRunId;
         this.parentWorkflowRunId = parentWorkflowRunId;
         this.client = client;
         this.runs = runsClient;
         this._standaloneTaskName = standaloneTaskName;
+        this.defaultSignal = defaultSignal;
     }
     // TODO docstrings
     get runId() {
@@ -88,8 +89,9 @@ class WorkflowRunRef {
                 (() => __awaiter(this, void 0, void 0, function* () {
                     var _a, e_1, _b, _c;
                     var _d, _e;
+                    const signal = this.defaultSignal;
                     try {
-                        for (var _f = true, _g = __asyncValues(streamable.stream()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                        for (var _f = true, _g = __asyncValues(streamable.stream({ signal })), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
                             _c = _h.value;
                             _f = false;
                             const event = _c;
@@ -143,7 +145,7 @@ class WorkflowRunRef {
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
-                }))();
+                }))().catch(reject);
             });
         });
     }

package/v1/client/admin.d.ts

@@ -4,6 +4,7 @@ import { Priority, RateLimitDuration, RunsClient } from './..';
 import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
 import { Api } from '../../clients/rest/generated/Api';
 import { WorkflowServiceClient } from '../../protoc/workflows';
+import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
 import { Logger } from '../../util/logger';
 export type WorkflowRun<T = object> = {
     workflowName: string;
@@ -28,11 +29,17 @@ export type WorkflowRun<T = object> = {
 };
 export declare class AdminClient {
     config: ClientConfig;
-    grpc: WorkflowServiceClient;
+    workflowsGrpc: WorkflowServiceClient;
+    adminGrpc: AdminServiceClient;
     listenerClient: RunListenerClient;
     runs: RunsClient;
     logger: Logger;
     constructor(config: ClientConfig, api: Api, runs: RunsClient);
+    /**
+     * Creates a new workflow or updates an existing workflow via the v1 admin service.
+     * @param workflow a workflow definition to create
+     */
+    putWorkflow(workflow: CreateWorkflowVersionRequest): Promise<import("../../protoc/v1/workflows").CreateWorkflowVersionResponse>;
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.

package/v1/client/admin.js

@@ -29,6 +29,7 @@ const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"
 const grpc_helpers_1 = require("../../util/grpc-helpers");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
 const workflows_1 = require("../../protoc/workflows");
+const workflows_2 = require("../../protoc/v1/workflows");
 const retrier_1 = require("../../util/retrier");
 const batch_1 = require("../../util/batch");
 const apply_namespace_1 = require("../../util/apply-namespace");
@@ -37,10 +38,25 @@ class AdminClient {
         this.config = config;
         this.logger = config.logger(`Admin`, config.log_level);
         const { client, channel, factory } = (0, grpc_helpers_1.createGrpcClient)(config, workflows_1.WorkflowServiceDefinition);
-        this.grpc = client;
+        this.workflowsGrpc = client;
+        this.adminGrpc = factory.create(workflows_2.AdminServiceDefinition, channel);
         this.listenerClient = new child_listener_client_1.RunListenerClient(config, channel, factory, api);
         this.runs = runs;
     }
+    /**
+     * Creates a new workflow or updates an existing workflow via the v1 admin service.
+     * @param workflow a workflow definition to create
+     */
+    putWorkflow(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.adminGrpc.putWorkflow(workflow); }), this.logger);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.
@@ -52,14 +68,14 @@ class AdminClient {
     runWorkflow(workflowName, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace);
+                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace).toLowerCase();
                 const inputStr = JSON.stringify(input);
                 const opts = options !== null && options !== void 0 ? options : {};
                 const { additionalMetadata, parentStepRunId, parentTaskRunExternalId } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId"]);
                 const request = Object.assign(Object.assign({ name: computedName, input: inputStr }, rest), { 
                     // API expects `parentTaskRunExternalId`; accept old names as aliases.
                     parentTaskRunExternalId: parentTaskRunExternalId !== null && parentTaskRunExternalId !== void 0 ? parentTaskRunExternalId : parentStepRunId, additionalMetadata: additionalMetadata ? JSON.stringify(additionalMetadata) : undefined, priority: opts.priority });
-                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.grpc.triggerWorkflow(request); }), this.logger);
+                const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.triggerWorkflow(request); }), this.logger);
                 const id = resp.workflowRunId;
                 const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, 
                 // eslint-disable-next-line no-underscore-dangle
@@ -82,7 +98,7 @@ class AdminClient {
         return __awaiter(this, arguments, void 0, function* (workflowRuns, batchSize = 500) {
             // Prepare workflows to be triggered in bulk
             const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => {
-                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace);
+                const computedName = (0, apply_namespace_1.applyNamespace)(workflowName, this.config.namespace).toLowerCase();
                 const inputStr = JSON.stringify(input);
                 const opts = options !== null && options !== void 0 ? options : {};
                 const { additionalMetadata, parentStepRunId, parentTaskRunExternalId } = opts, rest = __rest(opts, ["additionalMetadata", "parentStepRunId", "parentTaskRunExternalId"]);
@@ -101,7 +117,7 @@ class AdminClient {
                         workflows: payloads,
                     });
                     // Call the bulk trigger workflow method for this batch
-                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.grpc.bulkTriggerWorkflow(request); }), this.logger);
+                    const bulkTriggerWorkflowResponse = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.bulkTriggerWorkflow(request); }), this.logger);
                     this.logger.debug(`batch ${batchIndex + 1} of ${batches.length}`);
                     // Map the results back to their original indices
                     const batchResults = bulkTriggerWorkflowResponse.workflowRunIds.map((resp, index) => {
@@ -127,7 +143,7 @@ class AdminClient {
                 limit,
                 duration,
             };
-            yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.grpc.putRateLimit(request); }), this.logger);
+            yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.putRateLimit(request); }), this.logger);
         });
     }
 }

package/v1/client/client.d.ts

@@ -1,11 +1,14 @@
 import { ClientConfig, HatchetClientOptions, LegacyHatchetClient, TaskMiddleware, InferMiddlewareBefore, InferMiddlewareAfter } from '../../clients/hatchet-client';
 import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
-import { Workflow as V0Workflow } from '../../workflow';
-import { V0DurableContext } from '../../step';
 import { Api } from '../../clients/rest';
+import { EventClient } from '../../clients/event/event-client';
+import { DispatcherClient } from '../../clients/dispatcher/dispatcher-client';
+import { Logger } from '../../util/logger';
 import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
+import { DurableListenerClient } from '../../clients/listeners/durable-listener/durable-listener-client';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration, CreateDurableTaskWorkflowOpts } from '../declaration';
+import type { LegacyWorkflow } from '../../legacy/legacy-transformer';
 import { IHatchetClient } from './client.interface';
 import { CreateWorkerOpts, Worker } from './worker/worker';
 import { MetricsClient } from './features/metrics';
@@ -21,6 +24,7 @@ import { CronClient } from './features/crons';
 import { CELClient } from './features/cel';
 import { TenantClient } from './features/tenant';
 import { WebhooksClient } from './features/webhooks';
+import { DurableContext } from './worker/context';
 type MergeIfNonEmpty<Base, Extra extends Record<string, any>> = keyof Extra extends never ? Base : Base & Extra;
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
@@ -31,16 +35,20 @@ type MergeIfNonEmpty<Base, Extra extends Record<string, any>> = keyof Extra exte
  * @template MiddlewareAfter - Extra fields merged into task output by post-middleware hooks. Inferred from middleware config.
  */
 export declare class HatchetClient<GlobalInput extends Record<string, any> = {}, GlobalOutput extends Record<string, any> = {}, MiddlewareBefore extends Record<string, any> = {}, MiddlewareAfter extends Record<string, any> = {}> implements IHatchetClient {
-    /** The underlying v0 client instance */
-    _v0: LegacyHatchetClient;
+    private _v0;
     _api: Api;
     _listener: RunListenerClient;
+    private _options;
+    private _axiosConfig;
+    private _clientFactory;
+    private _credentials;
     /**
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
     get v0(): LegacyHatchetClient;
     /** The tenant ID for the Hatchet client */
     tenantId: string;
+    logger: Logger;
     _isV1: boolean | undefined;
     get isV1(): boolean;
     /**
@@ -112,7 +120,7 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @param options Durable task configuration options with function that defines types
      * @returns A TaskWorkflowDeclaration instance with inferred types
      */
-    durableTask<Fn extends (input: I, ctx: V0DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
+    durableTask<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends InputType = Parameters<Fn>[0], O extends OutputType = ReturnType<Fn> extends Promise<infer P> ? P extends OutputType ? P : void : ReturnType<Fn> extends OutputType ? ReturnType<Fn> : void>(options: {
         fn: Fn;
     } & Omit<CreateDurableTaskWorkflowOpts<I, O>, 'fn'>): TaskWorkflowDeclaration<I, O, GlobalInput, GlobalOutput, MiddlewareBefore, MiddlewareAfter>;
     /**
@@ -124,7 +132,7 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): Promise<WorkflowRunRef<O>>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | LegacyWorkflow | string, input: I, options: RunOpts): Promise<WorkflowRunRef<O>>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -135,7 +143,7 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    runAndWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
+    runAndWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | LegacyWorkflow | string, input: I, options?: RunOpts): Promise<O>;
     /**
      * Triggers a workflow run and waits for the result.
      * @template I - The input type for the workflow
@@ -145,7 +153,7 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @param options - Configuration options for the workflow run
      * @returns A promise that resolves with the workflow result
      */
-    run<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<O>;
+    run<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | LegacyWorkflow | string, input: I, options?: RunOpts): Promise<O>;
     private _cel;
     /**
      * Get the CEL client for debugging CEL expressions
@@ -180,17 +188,33 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @alias scheduled
      */
     get schedules(): ScheduleClient;
+    private _dispatcher;
     /**
-     * Get the event client for creating and managing event workflow runs
-     * @returns A event client instance
+     * Get the dispatcher client for sending action events and managing worker registration
+     * @returns A dispatcher client instance
      */
-    get events(): import("../../clients/event/event-client").EventClient;
+    get dispatcher(): DispatcherClient;
+    private _event;
     /**
      * Get the event client for creating and managing event workflow runs
      * @returns A event client instance
+     */
+    get events(): EventClient;
+    private _durableListener;
+    /**
+     * Get the durable listener client for managing durable event subscriptions
+     * @returns A durable listener client instance
+     */
+    get durableListener(): DurableListenerClient;
+    /**
+     * Get the run listener client for streaming workflow run results
+     * @returns A run listener client instance
+     */
+    get listener(): RunListenerClient;
+    /**
      * @deprecated use client.events instead
      */
-    get event(): import("../../clients/event/event-client").EventClient;
+    get event(): EventClient;
     private _metrics;
     /**
      * Get the metrics client for creating and managing metrics
@@ -262,12 +286,6 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @returns A promise that resolves with a new HatchetWorker instance
      */
     worker(name: string, options?: CreateWorkerOpts | number): Promise<Worker>;
-    /**
-     * Register a webhook with the worker
-     * @param workflows - The workflows to register on the webhooks
-     * @returns A promise that resolves when the webhook is registered
-     */
-    v0webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }
 export {};

package/v1/client/client.interface.d.ts

@@ -1,4 +1,7 @@
-import { LegacyHatchetClient } from '../../clients/hatchet-client';
+import { EventClient } from '../../clients/event/event-client';
+import { DispatcherClient } from '../../clients/dispatcher/dispatcher-client';
+import { Logger } from '../../util/logger';
+import { LegacyHatchetClient } from '../../legacy/legacy-client';
 import { MetricsClient } from './features/metrics';
 import { RunsClient } from './features/runs';
 import { WorkersClient } from './features/workers';
@@ -8,8 +11,12 @@ import { ScheduleClient } from './features/schedules';
 import { CronClient } from './features/crons';
 import { CELClient } from './features/cel';
 export interface IHatchetClient {
-    _v0: LegacyHatchetClient;
+    /** @deprecated v0 client will be removed in a future release, please upgrade to v1 */
+    v0: LegacyHatchetClient;
     cel: CELClient;
+    dispatcher: DispatcherClient;
+    events: EventClient;
+    logger: Logger;
     metrics: MetricsClient;
     runs: RunsClient;
     workflows: WorkflowsClient;

package/v1/client/client.js

@@ -21,10 +21,13 @@ const config_loader_1 = require("../../util/config-loader");
 const hatchet_logger_1 = require("../../clients/hatchet-client/hatchet-logger");
 const zod_1 = require("zod");
 const event_client_1 = require("../../clients/event/event-client");
+const dispatcher_client_1 = require("../../clients/dispatcher/dispatcher-client");
 const child_listener_client_1 = require("../../clients/listeners/run-listener/child-listener-client");
+const durable_listener_client_1 = require("../../clients/listeners/durable-listener/durable-listener-client");
 const grpc_helpers_1 = require("../../util/grpc-helpers");
 const nice_grpc_1 = require("nice-grpc");
 const declaration_1 = require("../declaration");
+const legacy_transformer_1 = require("../../legacy/legacy-transformer");
 const worker_1 = require("./worker/worker");
 const metrics_1 = require("./features/metrics");
 const workers_1 = require("./features/workers");
@@ -51,6 +54,9 @@ class HatchetClient {
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
     get v0() {
+        if (!this._v0) {
+            this._v0 = new hatchet_client_1.LegacyHatchetClient(this._config, this._options, this._axiosConfig, this.runs, this._listener, this.events, this.dispatcher, this.logger, this.durableListener);
+        }
         return this._v0;
     }
     get isV1() {
@@ -77,11 +83,14 @@ class HatchetClient {
             const clientConfig = Object.assign(Object.assign({}, valid), { logger: logConstructor });
             this._config = clientConfig;
             this.tenantId = clientConfig.tenant_id;
+            this.logger = clientConfig.logger('HatchetClient', clientConfig.log_level);
             this._api = (0, rest_1.default)(clientConfig.api_url, clientConfig.token, axiosConfig);
-            const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, grpc_helpers_1.addTokenMiddleware)(this.config.token));
-            const credentials = (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
-            this._listener = new child_listener_client_1.RunListenerClient(this.config, (0, grpc_helpers_1.channelFactory)(this.config, credentials), clientFactory, this.api);
-            this._v0 = new hatchet_client_1.LegacyHatchetClient(clientConfig, options, axiosConfig, this.runs, this._listener);
+            this._clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, grpc_helpers_1.addTokenMiddleware)(this.config.token));
+            this._credentials =
+                (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
+            this._listener = new child_listener_client_1.RunListenerClient(this.config, (0, grpc_helpers_1.channelFactory)(this.config, this._credentials), this._clientFactory, this.api);
+            this._options = options;
+            this._axiosConfig = axiosConfig;
         }
         catch (e) {
             if (e instanceof zod_1.z.ZodError) {
@@ -178,16 +187,7 @@ class HatchetClient {
      */
     runNoWait(workflow, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            let name;
-            if (typeof workflow === 'string') {
-                name = workflow;
-            }
-            else if ('id' in workflow) {
-                name = workflow.id;
-            }
-            else {
-                throw new Error('unable to identify workflow');
-            }
+            const name = (0, legacy_transformer_1.getWorkflowName)(workflow);
             return this.admin.runWorkflow(name, input, options);
         });
     }
@@ -273,16 +273,44 @@ class HatchetClient {
     get schedules() {
         return this.scheduled;
     }
+    /**
+     * Get the dispatcher client for sending action events and managing worker registration
+     * @returns A dispatcher client instance
+     */
+    get dispatcher() {
+        if (!this._dispatcher) {
+            this._dispatcher = new dispatcher_client_1.DispatcherClient(this._config, (0, grpc_helpers_1.channelFactory)(this._config, this._credentials), this._clientFactory);
+        }
+        return this._dispatcher;
+    }
     /**
      * Get the event client for creating and managing event workflow runs
      * @returns A event client instance
      */
     get events() {
-        return this._v0.event;
+        if (!this._event) {
+            this._event = new event_client_1.EventClient(this._config, (0, grpc_helpers_1.channelFactory)(this._config, this._credentials), this._clientFactory, this.api);
+        }
+        return this._event;
+    }
+    /**
+     * Get the durable listener client for managing durable event subscriptions
+     * @returns A durable listener client instance
+     */
+    get durableListener() {
+        if (!this._durableListener) {
+            this._durableListener = new durable_listener_client_1.DurableListenerClient(this._config, (0, grpc_helpers_1.channelFactory)(this._config, this._credentials), this._clientFactory, this.api);
+        }
+        return this._durableListener;
+    }
+    /**
+     * Get the run listener client for streaming workflow run results
+     * @returns A run listener client instance
+     */
+    get listener() {
+        return this._listener;
     }
     /**
-     * Get the event client for creating and managing event workflow runs
-     * @returns A event client instance
      * @deprecated use client.events instead
      */
     get event() {
@@ -389,7 +417,7 @@ class HatchetClient {
      */
     get admin() {
         if (!this._admin) {
-            this._admin = new admin_1.AdminClient(this._v0.config, this.api, this.runs);
+            this._admin = new admin_1.AdminClient(this._config, this.api, this.runs);
         }
         return this._admin;
     }
@@ -406,15 +434,7 @@ class HatchetClient {
         else {
             opts = options || {};
         }
-        return worker_1.Worker.create(this, this._v0, name, opts);
-    }
-    /**
-     * Register a webhook with the worker
-     * @param workflows - The workflows to register on the webhooks
-     * @returns A promise that resolves when the webhook is registered
-     */
-    v0webhooks(workflows) {
-        return this._v0.webhooks(workflows);
+        return worker_1.Worker.create(this, name, opts);
     }
     runRef(id) {
         return this.runs.runRef(id);