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

package/v1/declaration.d.ts

@@ -0,0 +1,309 @@
+import WorkflowRunRef from '../util/workflow-run-ref';
+import { Context, DurableContext, JsonObject } from '../step';
+import { CronWorkflows, ScheduledWorkflows } from '../clients/rest/generated/data-contracts';
+import { Workflow as WorkflowV0 } from '../workflow';
+import { IHatchetClient } from './client/client.interface';
+import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskConcurrency, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts } from './task';
+import { Duration } from './client/duration';
+import { MetricsClient } from './client/features/metrics';
+/**
+ * Additional metadata that can be attached to a workflow run.
+ */
+type AdditionalMetadata = Record<string, string>;
+/**
+ * Options for running a workflow.
+ */
+export type RunOpts = {
+    /**
+     * Additional metadata to attach to the workflow run.
+     */
+    additionalMetadata?: AdditionalMetadata;
+};
+/**
+ * Extracts a property from an object type based on task name, or falls back to inferred type
+ */
+export type TaskOutputType<K, TaskName extends string, InferredType> = TaskName extends keyof K ? K[TaskName] : InferredType;
+export type CreateBaseWorkflowOpts = {
+    /**
+     * The name of the workflow.
+     */
+    name: WorkflowV0['id'];
+    /**
+     * (optional) description of the workflow.
+     */
+    description?: WorkflowV0['description'];
+    /**
+     * (optional) version of the workflow.
+     */
+    version?: WorkflowV0['version'];
+    /**
+     * (optional) sticky strategy for the workflow.
+     */
+    sticky?: WorkflowV0['sticky'];
+    /**
+     * (optional) on config for the workflow.
+     * @deprecated use onCrons and onEvents instead
+     */
+    on?: WorkflowV0['on'];
+    /**
+     * (optional) cron config for the workflow.
+     */
+    onCrons?: string[];
+    /**
+     * (optional) event config for the workflow.
+     */
+    onEvents?: string[];
+    concurrency?: TaskConcurrency;
+    /**
+     * (optional) onFailure handler for the workflow.
+     * Invoked when any task in the workflow fails.
+     * @param ctx The context of the workflow.
+     */
+    onFailure?: TaskFn<any, any> | CreateOnFailureTaskOpts<any, any>;
+    /**
+     * (optional) onSuccess handler for the workflow.
+     * Invoked when all tasks in the workflow complete successfully.
+     * @param ctx The context of the workflow.
+     */
+    onSuccess?: TaskFn<any, any> | CreateOnSuccessTaskOpts<any, any>;
+};
+export type CreateTaskWorkflowOpts<T extends JsonObject = any, K extends JsonObject = any> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<T, K, TaskFn<T, K>>;
+/**
+ * Options for creating a new workflow.
+ */
+export type CreateWorkflowOpts = CreateBaseWorkflowOpts & {
+    /**
+     * (optional) default configuration for all tasks in the workflow.
+     */
+    taskDefaults?: TaskDefaults;
+};
+/**
+ * Default configuration for all tasks in the workflow.
+ * Can be overridden by task-specific options.
+ */
+export type TaskDefaults = {
+    /**
+     * (optional) execution timeout duration for the task after it starts running
+     * go duration format (e.g., "1s", "5m", "1h").
+     *
+     * default: 60s
+     */
+    executionTimeout?: Duration;
+    /**
+     * (optional) schedule timeout for the task (max duration to allow the task to wait in the queue)
+     * go duration format (e.g., "1s", "5m", "1h").
+     *
+     * default: 5m
+     */
+    scheduleTimeout?: Duration;
+    /**
+     * (optional) number of retries for the task.
+     *
+     * default: 0
+     */
+    retries?: CreateWorkflowTaskOpts<any, any>['retries'];
+    /**
+     * (optional) backoff strategy configuration for retries.
+     * - factor: Base of the exponential backoff (base ^ retry count)
+     * - maxSeconds: Maximum backoff duration in seconds
+     */
+    backoff?: CreateWorkflowTaskOpts<any, any>['backoff'];
+    /**
+     * (optional) rate limits for the task.
+     */
+    rateLimits?: CreateWorkflowTaskOpts<any, any>['rateLimits'];
+    /**
+     * (optional) worker labels for task routing and scheduling.
+     * Each label can be a simple string/number value or an object with additional configuration:
+     * - value: The label value (string or number)
+     * - required: Whether the label is required for worker matching
+     * - weight: Priority weight for worker selection
+     * - comparator: Custom comparison logic for label matching
+     */
+    workerLabels?: CreateWorkflowTaskOpts<any, any>['desiredWorkerLabels'];
+    /**
+     * (optional) the concurrency options for the task.
+     */
+    concurrency?: TaskConcurrency | TaskConcurrency[];
+};
+/**
+ * Internal definition of a workflow and its tasks.
+ */
+export type WorkflowDefinition = CreateWorkflowOpts & {
+    /**
+     * The tasks that make up this workflow.
+     */
+    _tasks: CreateWorkflowTaskOpts<any, any>[];
+    /**
+     * The durable tasks that make up this workflow.
+     */
+    _durableTasks: CreateWorkflowDurableTaskOpts<any, any>[];
+};
+/**
+ * Represents a workflow that can be executed by Hatchet.
+ * @template T The input type for the workflow.
+ * @template K The return type of the workflow.
+ */
+export declare class BaseWorkflowDeclaration<T extends JsonObject, K extends JsonObject> {
+    /**
+     * The Hatchet client instance used to execute the workflow.
+     */
+    client: IHatchetClient | undefined;
+    /**
+     * The internal workflow definition.
+     */
+    definition: WorkflowDefinition;
+    /**
+     * Creates a new workflow instance.
+     * @param options The options for creating the workflow.
+     * @param client Optional Hatchet client instance.
+     */
+    constructor(options: CreateWorkflowOpts, client?: IHatchetClient);
+    /**
+     * Triggers a workflow run without waiting for completion.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    runNoWait(input: T, options?: RunOpts): WorkflowRunRef<K>;
+    /**
+     * @alias run
+     * Triggers a workflow run and waits for the result.
+     * @template T - The input type for the workflow
+     * @template K - The return type of the workflow
+     * @param input - The input data for the workflow
+     * @param options - Configuration options for the workflow run
+     * @returns A promise that resolves with the workflow result
+     */
+    runAndWait(input: T, options?: RunOpts): Promise<K>;
+    runAndWait(input: T[], options?: RunOpts): Promise<K[]>;
+    /**
+     * Executes the workflow with the given input and awaits the results.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the workflow result.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    run(input: T, options?: RunOpts): Promise<K>;
+    run(input: T[], options?: RunOpts): Promise<K[]>;
+    /**
+     * Schedules a workflow to run at a specific date and time in the future.
+     * @param enqueueAt The date when the workflow should be triggered.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    schedule(enqueueAt: Date, input: T, options?: RunOpts): Promise<ScheduledWorkflows>;
+    /**
+     * Schedules a workflow to run after a specified delay.
+     * @param duration The delay in seconds before the workflow should run.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    delay(duration: number, input: T, options?: RunOpts): Promise<ScheduledWorkflows>;
+    /**
+     * Creates a cron schedule for the workflow.
+     * @param name The name of the cron schedule.
+     * @param expression The cron expression defining the schedule.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the cron workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    cron(name: string, expression: string, input: T, options?: RunOpts): Promise<CronWorkflows>;
+    /**
+     * Get metrics for the workflow.
+     * @param opts Optional configuration for the metrics request.
+     * @returns A promise that resolves with the workflow metrics.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    metrics(opts?: Parameters<MetricsClient['getWorkflowMetrics']>[1]): Promise<import("../clients/rest/generated/data-contracts").WorkflowMetrics>;
+    /**
+     * Get queue metrics for the workflow.
+     * @param opts Optional configuration for the metrics request.
+     * @returns A promise that resolves with the workflow metrics.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    queueMetrics(opts?: Omit<Parameters<MetricsClient['getQueueMetrics']>[0], 'workflows'>): Promise<import("../clients/rest/generated/data-contracts").TenantQueueMetrics>;
+    /**
+     * Get the current state of the workflow.
+     * @returns A promise that resolves with the workflow state.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    get(): Promise<any>;
+    get id(): string;
+    /**
+     * Get the friendly name of the workflow.
+     * @returns The name of the workflow.
+     */
+    get name(): string;
+}
+export declare class WorkflowDeclaration<T extends JsonObject, K extends JsonObject> extends BaseWorkflowDeclaration<T, K> {
+    /**
+     * Adds a task to the workflow.
+     * The return type will be either the property on K that corresponds to the task name,
+     * or if there is no matching property, the inferred return type of the function.
+     * @template Name The literal string name of the task.
+     * @template L The inferred return type of the task function.
+     * @param options The task configuration options.
+     * @returns The task options that were added.
+     */
+    task<Name extends string, L>(options: (Omit<CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
+        name: Name;
+        fn: (input: T, ctx: Context<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
+    }) | TaskWorkflowDeclaration<any, any>): CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>;
+    /**
+     * Adds a durable task to the workflow.
+     * The return type will be either the property on K that corresponds to the task name,
+     * or if there is no matching property, the inferred return type of the function.
+     * @template Name The literal string name of the task.
+     * @template L The inferred return type of the task function.
+     * @param options The task configuration options.
+     * @returns The task options that were added.
+     */
+    durableTask<Name extends string, L>(options: Omit<CreateWorkflowTaskOpts<T, TaskOutputType<K, Name, L>>, 'fn'> & {
+        name: Name;
+        fn: (input: T, ctx: DurableContext<T>) => TaskOutputType<K, Name, L> | Promise<TaskOutputType<K, Name, L>>;
+    }): CreateWorkflowDurableTaskOpts<T, TaskOutputType<K, Name, L>>;
+}
+export declare class TaskWorkflowDeclaration<T extends JsonObject, K extends JsonObject> extends BaseWorkflowDeclaration<T, K> {
+    private _standalone_task_name;
+    constructor(options: CreateTaskWorkflowOpts<T, K>, client?: IHatchetClient);
+    run(input: T, options?: RunOpts): Promise<K>;
+    run(input: T[], options?: RunOpts): Promise<K[]>;
+    get taskDef(): CreateWorkflowTaskOpts<any, any>;
+}
+/**
+ * Creates a new task workflow declaration with types inferred from the function parameter.
+ * @template Fn The type of the task function
+ * @param options The task configuration options.
+ * @param client Optional Hatchet client instance.
+ * @returns A new TaskWorkflowDeclaration with inferred types.
+ */
+export declare function CreateTaskWorkflow<Fn extends (input: I, ctx?: any) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    fn: Fn;
+} & Omit<CreateTaskWorkflowOpts<I, O>, 'fn'>, client?: IHatchetClient): TaskWorkflowDeclaration<I, O>;
+/**
+ * Creates a new workflow instance.
+ * @template T The input type for the workflow.
+ * @template K The return type of the workflow.
+ * @param options The options for creating the workflow.
+ * @param client Optional Hatchet client instance.
+ * @returns A new Workflow instance.
+ */
+export declare function CreateWorkflow<T extends JsonObject = any, K extends JsonObject = any>(options: CreateWorkflowOpts, client?: IHatchetClient): WorkflowDeclaration<T, K>;
+/**
+ * Creates a new durable task workflow declaration with types inferred from the function parameter.
+ * @template Fn The type of the durable task function
+ * @param options The durable task configuration options.
+ * @param client Optional Hatchet client instance.
+ * @returns A new TaskWorkflowDeclaration with inferred types.
+ */
+export declare function CreateDurableTaskWorkflow<Fn extends (input: I, ctx: DurableContext<I>) => O | Promise<O>, I extends JsonObject = Parameters<Fn>[0], O extends JsonObject = ReturnType<Fn> extends Promise<infer P> ? P extends JsonObject ? P : never : ReturnType<Fn> extends JsonObject ? ReturnType<Fn> : never>(options: {
+    fn: Fn;
+} & Omit<CreateWorkflowDurableTaskOpts<I, O>, 'fn'>, client?: IHatchetClient): TaskWorkflowDeclaration<I, O>;
+export {};

package/v1/declaration.js

@@ -0,0 +1,296 @@
+"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.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = void 0;
+exports.CreateTaskWorkflow = CreateTaskWorkflow;
+exports.CreateWorkflow = CreateWorkflow;
+exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
+const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
+/**
+ * Represents a workflow that can be executed by Hatchet.
+ * @template T The input type for the workflow.
+ * @template K The return type of the workflow.
+ */
+class BaseWorkflowDeclaration {
+    /**
+     * Creates a new workflow instance.
+     * @param options The options for creating the workflow.
+     * @param client Optional Hatchet client instance.
+     */
+    constructor(options, client) {
+        this.definition = Object.assign(Object.assign({}, options), { _tasks: [], _durableTasks: [] });
+        this.client = client;
+    }
+    /**
+     * Triggers a workflow run without waiting for completion.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    runNoWait(input, options) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client._v0.admin.runWorkflow(this.name, input, options);
+    }
+    runAndWait(input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            if (Array.isArray(input)) {
+                return Promise.all(input.map((i) => this.runAndWait(i, options)));
+            }
+            return this.run(input, options);
+        });
+    }
+    run(input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            if (Array.isArray(input)) {
+                // FIXME use bulk endpoint?
+                return Promise.all(input.map((i) => this.run(i, options)));
+            }
+            const res = this.client._v0.admin.runWorkflow(this.definition.name, input, options);
+            return res.result();
+        });
+    }
+    /**
+     * Schedules a workflow to run at a specific date and time in the future.
+     * @param enqueueAt The date when the workflow should be triggered.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    schedule(enqueueAt, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const scheduled = this.client._v0.schedule.create(this.definition.name, {
+                triggerAt: enqueueAt,
+                input,
+                additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata,
+            });
+            return scheduled;
+        });
+    }
+    /**
+     * Schedules a workflow to run after a specified delay.
+     * @param duration The delay in seconds before the workflow should run.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the scheduled workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    delay(duration, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const triggerAt = new Date(now + duration * 1000);
+            return this.schedule(triggerAt, input, options);
+        });
+    }
+    /**
+     * Creates a cron schedule for the workflow.
+     * @param name The name of the cron schedule.
+     * @param expression The cron expression defining the schedule.
+     * @param input The input data for the workflow.
+     * @param options Optional configuration for this workflow run.
+     * @returns A promise that resolves with the cron workflow details.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    cron(name, expression, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const cronDef = this.client._v0.cron.create(this.definition.name, {
+                expression,
+                input,
+                additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata,
+                name,
+            });
+            return cronDef;
+        });
+    }
+    /**
+     * Get metrics for the workflow.
+     * @param opts Optional configuration for the metrics request.
+     * @returns A promise that resolves with the workflow metrics.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    metrics(opts) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.metrics.getWorkflowMetrics(this.definition.name, opts);
+    }
+    /**
+     * Get queue metrics for the workflow.
+     * @param opts Optional configuration for the metrics request.
+     * @returns A promise that resolves with the workflow metrics.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    queueMetrics(opts) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.metrics.getQueueMetrics(Object.assign(Object.assign({}, opts), { workflows: [this.definition.name] }));
+    }
+    /**
+     * Get the current state of the workflow.
+     * @returns A promise that resolves with the workflow state.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    get() {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.workflows.get(this);
+    }
+    // // gets the pause state of the workflow
+    // isPaused() {
+    //   if (!this.client) {
+    //     throw UNBOUND_ERR;
+    //   }
+    //   return this.client.workflows.isPaused(this);
+    // }
+    // // pause assignment of workflow
+    // pause() {
+    //   if (!this.client) {
+    //     throw UNBOUND_ERR;
+    //   }
+    //   return this.client.workflows.pause(this);
+    // }
+    // // unpause assignment of workflow
+    // unpause() {
+    //   if (!this.client) {
+    //     throw UNBOUND_ERR;
+    //   }
+    //   return this.client.workflows.unpause(this);
+    // }
+    // @deprecated use definition.name instead
+    get id() {
+        return this.definition.name;
+    }
+    /**
+     * Get the friendly name of the workflow.
+     * @returns The name of the workflow.
+     */
+    get name() {
+        return this.definition.name;
+    }
+}
+exports.BaseWorkflowDeclaration = BaseWorkflowDeclaration;
+class WorkflowDeclaration extends BaseWorkflowDeclaration {
+    /**
+     * Adds a task to the workflow.
+     * The return type will be either the property on K that corresponds to the task name,
+     * or if there is no matching property, the inferred return type of the function.
+     * @template Name The literal string name of the task.
+     * @template L The inferred return type of the task function.
+     * @param options The task configuration options.
+     * @returns The task options that were added.
+     */
+    task(options) {
+        let typedOptions;
+        if (options instanceof TaskWorkflowDeclaration) {
+            typedOptions = options.taskDef;
+        }
+        else {
+            typedOptions = options;
+        }
+        this.definition._tasks.push(typedOptions);
+        return typedOptions;
+    }
+    /**
+     * Adds a durable task to the workflow.
+     * The return type will be either the property on K that corresponds to the task name,
+     * or if there is no matching property, the inferred return type of the function.
+     * @template Name The literal string name of the task.
+     * @template L The inferred return type of the task function.
+     * @param options The task configuration options.
+     * @returns The task options that were added.
+     */
+    durableTask(options) {
+        const typedOptions = options;
+        this.definition._durableTasks.push(typedOptions);
+        return typedOptions;
+    }
+}
+exports.WorkflowDeclaration = WorkflowDeclaration;
+class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
+    constructor(options, client) {
+        super(Object.assign({}, options), client);
+        this._standalone_task_name = options.name;
+        this.definition._tasks.push(Object.assign({}, options));
+    }
+    run(input, options) {
+        const _super = Object.create(null, {
+            run: { get: () => super.run }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield _super.run.call(this, input, options);
+            if (Array.isArray(res)) {
+                return res.map((r) => r[this._standalone_task_name]);
+            }
+            return res[this._standalone_task_name];
+        });
+    }
+    get taskDef() {
+        return this.definition._tasks[0];
+    }
+}
+exports.TaskWorkflowDeclaration = TaskWorkflowDeclaration;
+/**
+ * Creates a new task workflow declaration with types inferred from the function parameter.
+ * @template Fn The type of the task function
+ * @param options The task configuration options.
+ * @param client Optional Hatchet client instance.
+ * @returns A new TaskWorkflowDeclaration with inferred types.
+ */
+function CreateTaskWorkflow(options, client) {
+    return new TaskWorkflowDeclaration(options, client);
+}
+/**
+ * Creates a new workflow instance.
+ * @template T The input type for the workflow.
+ * @template K The return type of the workflow.
+ * @param options The options for creating the workflow.
+ * @param client Optional Hatchet client instance.
+ * @returns A new Workflow instance.
+ */
+function CreateWorkflow(options, client) {
+    return new WorkflowDeclaration(options, client);
+}
+/**
+ * Creates a new durable task workflow declaration with types inferred from the function parameter.
+ * @template Fn The type of the durable task function
+ * @param options The durable task configuration options.
+ * @param client Optional Hatchet client instance.
+ * @returns A new TaskWorkflowDeclaration with inferred types.
+ */
+function CreateDurableTaskWorkflow(options, client) {
+    // Note: We're using TaskWorkflowDeclaration here since task and durableTask
+    // share the same declaration structure but with different task types
+    const taskWorkflow = new TaskWorkflowDeclaration(options, client);
+    // Move the task from tasks to durableTasks
+    if (taskWorkflow.definition._tasks.length > 0) {
+        const task = taskWorkflow.definition._tasks[0];
+        taskWorkflow.definition._tasks = [];
+        taskWorkflow.definition._durableTasks.push(task);
+    }
+    return taskWorkflow;
+}

package/v1/examples/child_workflows/worker.js

@@ -9,11 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("../client");
+const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield client_1.hatchet.worker('child-workflow-worker', {
+        const worker = yield hatchet_client_1.hatchet.worker('child-workflow-worker', {
             workflows: [workflow_1.parent, workflow_1.child],
         });
         yield worker.start();

package/v1/examples/child_workflows/workflow.d.ts

@@ -6,7 +6,7 @@ type ChildOutput = {
         Value: number;
     };
 };
-export declare const child: import("../../workflow").WorkflowDeclaration<ChildInput, ChildOutput>;
+export declare const child: import("../..").WorkflowDeclaration<ChildInput, ChildOutput>;
 type ParentInput = {
     N: number;
 };
@@ -15,5 +15,5 @@ type ParentOutput = {
         Result: number;
     };
 };
-export declare const parent: import("../../workflow").WorkflowDeclaration<ParentInput, ParentOutput>;
+export declare const parent: import("../..").WorkflowDeclaration<ParentInput, ParentOutput>;
 export {};

package/v1/examples/child_workflows/workflow.js

@@ -1,4 +1,5 @@
 "use strict";
+// ❓ Declaring a Child
 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) {
@@ -10,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parent = exports.child = void 0;
-const client_1 = require("../client");
-exports.child = client_1.hatchet.workflow({
+const hatchet_client_1 = require("../hatchet-client");
+exports.child = hatchet_client_1.hatchet.workflow({
     name: 'child',
 });
 exports.child.task({
@@ -22,7 +23,7 @@ exports.child.task({
         };
     },
 });
-exports.parent = client_1.hatchet.workflow({
+exports.parent = hatchet_client_1.hatchet.workflow({
     name: 'parent',
 });
 exports.parent.task({
@@ -41,3 +42,4 @@ exports.parent.task({
         };
     }),
 });
+// !!

package/v1/examples/concurrency-rr/load.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-plusplus */
-const client_1 = require("../client");
+const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function generateRandomString(length) {
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -45,7 +45,7 @@ function main() {
         // Process workflows in batches
         for (let i = 0; i < workflowRuns.length; i += BATCH_SIZE) {
             const batch = workflowRuns.slice(i, i + BATCH_SIZE);
-            yield client_1.hatchet.admin.runWorkflows(batch);
+            yield hatchet_client_1.hatchet.admin.runWorkflows(batch);
         }
     });
 }