@hatchet-dev/typescript-sdk 1.3.2 → 1.4.0-alpha.2

package/v1/client/client.js

@@ -22,12 +22,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 declaration_1 = require("../declaration");
-const worker_1 = require("./worker");
+const worker_1 = require("./worker/worker");
 const metrics_1 = require("./features/metrics");
 const workers_1 = require("./features/workers");
 const workflows_1 = require("./features/workflows");
 const runs_1 = require("./features/runs");
 const features_1 = require("./features");
+const admin_1 = require("./admin");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -60,14 +61,16 @@ class HatchetClient {
                 logConstructor = hatchet_logger_1.DEFAULT_LOGGER;
             }
             const clientConfig = Object.assign(Object.assign({}, valid), { logger: logConstructor });
+            // FIXME: Remove this once we have a proper namespace validation
             if (clientConfig.namespace) {
                 clientConfig.namespace = clientConfig.namespace.endsWith('_')
                     ? clientConfig.namespace.slice(0, -1)
                     : clientConfig.namespace;
             }
+            this._config = clientConfig;
             this.tenantId = clientConfig.tenant_id;
             this._api = (0, rest_1.default)(clientConfig.api_url, clientConfig.token, axiosConfig);
-            this._v0 = new hatchet_client_1.InternalHatchetClient(clientConfig, options, axiosConfig, this.runs);
+            this._v0 = new hatchet_client_1.LegacyHatchetClient(clientConfig, options, axiosConfig, this.runs);
         }
         catch (e) {
             if (e instanceof zod_1.z.ZodError) {
@@ -86,6 +89,9 @@ class HatchetClient {
     static init(config, options, axiosConfig) {
         return new HatchetClient(config, options, axiosConfig);
     }
+    get config() {
+        return this._config;
+    }
     /**
      * Creates a new workflow definition.
      * @template I - The input type for the workflow
@@ -119,17 +125,19 @@ class HatchetClient {
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
     runNoWait(workflow, input, options) {
-        let name;
-        if (typeof workflow === 'string') {
-            name = workflow;
-        }
-        else if ('id' in workflow) {
-            name = workflow.id;
-        }
-        else {
-            throw new Error('unable to identify workflow');
-        }
-        return this._v0.admin.runWorkflow(name, 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');
+            }
+            return this.admin.runWorkflow(name, input, options);
+        });
     }
     /**
      * @alias run
@@ -157,7 +165,7 @@ class HatchetClient {
      */
     run(workflow_1, input_1) {
         return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
-            const run = this.runNoWait(workflow, input, options);
+            const run = yield this.runNoWait(workflow, input, options);
             return run.output;
         });
     }
@@ -272,10 +280,14 @@ class HatchetClient {
         return this._api;
     }
     /**
-     * @deprecated use workflow.run, client.run, or client.* feature methods instead
+     * Get the admin client for creating and managing workflows
+     * @returns A admin client instance
      */
     get admin() {
-        return this._v0.admin;
+        if (!this._admin) {
+            this._admin = new admin_1.AdminClient(this._v0.config, this.api, this.runs);
+        }
+        return this._admin;
     }
     /**
      * Creates a new worker instance for processing workflow tasks.

package/v1/client/worker/context.d.ts

@@ -0,0 +1,246 @@
+import { Priority, RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from '../../declaration';
+import { JsonObject } from '@bufbuild/protobuf';
+import { Action } from '../../../clients/dispatcher/action-listener';
+import { Logger, LogLevel } from '../../../util/logger';
+import WorkflowRunRef from '../../../util/workflow-run-ref';
+import { Conditions } from '../../conditions';
+import { CreateWorkflowTaskOpts } from '../../task';
+import { OutputType } from '../../types';
+import { Workflow } from '../../../workflow';
+import { HatchetClient } from '../..';
+import { ContextWorker, NextStep } from '../../../step';
+import { V1Worker } from './worker-internal';
+import { Duration } from '../duration';
+type TriggerData = Record<string, Record<string, any>>;
+type ChildRunOpts = RunOpts & {
+    key?: string;
+    sticky?: boolean;
+};
+interface ContextData<T, K> {
+    input: T;
+    triggers: TriggerData;
+    parents: Record<string, any>;
+    triggered_by: string;
+    user_data: K;
+    step_run_errors: Record<string, string>;
+}
+export declare class Context<T, K = {}> {
+    data: ContextData<T, K>;
+    input: T;
+    controller: AbortController;
+    action: Action;
+    v1: HatchetClient;
+    worker: ContextWorker;
+    overridesData: Record<string, any>;
+    logger: Logger;
+    spawnIndex: number;
+    constructor(action: Action, v1: HatchetClient, worker: V1Worker);
+    get abortController(): AbortController;
+    get cancelled(): boolean;
+    /**
+     * Retrieves the output of a parent task.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
+     * @returns The output of the specified parent task.
+     * @throws An error if the task output is not found.
+     */
+    parentOutput<L extends OutputType>(parentTask: CreateWorkflowTaskOpts<any, L> | string): Promise<L>;
+    /**
+     * Returns errors from any task runs in the workflow.
+     * @returns A record mapping task names to error messages.
+     * @throws A warning if no errors are found (this method should be used in on-failure tasks).
+     * @deprecated use ctx.errors() instead
+     */
+    stepRunErrors(): Record<string, string>;
+    /**
+     * Returns errors from any task runs in the workflow.
+     * @returns A record mapping task names to error messages.
+     * @throws A warning if no errors are found (this method should be used in on-failure tasks).
+     */
+    errors(): Record<string, string>;
+    /**
+     * Gets the dag conditional triggers for the current workflow run.
+     * @returns The triggers for the current workflow.
+     */
+    triggers(): TriggerData;
+    /**
+     * Determines if the workflow was triggered by an event.
+     * @returns True if the workflow was triggered by an event, otherwise false.
+     */
+    triggeredByEvent(): boolean;
+    /**
+     * Gets the name of the current workflow.
+     * @returns The name of the workflow.
+     */
+    workflowName(): string;
+    /**
+     * Gets the user data associated with the workflow.
+     * @returns The user data.
+     */
+    userData(): K;
+    /**
+     * Gets the name of the current running task.
+     * @returns The name of the task.
+     */
+    taskName(): string;
+    /**
+     * Gets the ID of the current workflow run.
+     * @returns The workflow run ID.
+     */
+    workflowRunId(): string;
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId(): string;
+    /**
+     * Gets the number of times the current task has been retried.
+     * @returns The retry count.
+     */
+    retryCount(): number;
+    /**
+     * Logs a message from the current task.
+     * @param message - The message to log.
+     * @param level - The log level (optional).
+     */
+    log(message: string, level?: LogLevel): void;
+    /**
+     * Refreshes the timeout for the current task.
+     * @param incrementBy - The interval by which to increment the timeout.
+     * The interval should be specified in the format of '10s' for 10 seconds, '1m' for 1 minute, or '1d' for 1 day.
+     */
+    refreshTimeout(incrementBy: Duration): Promise<void>;
+    /**
+     * Releases a worker slot for a task run such that the worker can pick up another task.
+     * Note: this is an advanced feature that may lead to unexpected behavior if used incorrectly.
+     * @returns A promise that resolves when the slot has been released.
+     */
+    releaseSlot(): Promise<void>;
+    /**
+     * Streams data from the current task run.
+     * @param data - The data to stream (string or binary).
+     * @returns A promise that resolves when the data has been streamed.
+     */
+    putStream(data: string | Uint8Array): Promise<void>;
+    private spawnOptions;
+    private spawn;
+    private spawnBulk;
+    /**
+     * Runs multiple children workflows in parallel without waiting for their results.
+     * @param children - An array of  objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of workflow run references to the enqueued runs.
+     */
+    bulkRunNoWaitChildren<Q extends JsonObject = any, P extends JsonObject = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: ChildRunOpts;
+    }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Runs multiple children workflows in parallel and waits for all results.
+     * @param children - An array of objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of results from the children workflows.
+     */
+    bulkRunChildren<Q extends JsonObject = any, P extends JsonObject = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: ChildRunOpts;
+    }>): Promise<P[]>;
+    /**
+     * Runs a new workflow and waits for its result.
+     *
+     * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - An options object containing key, sticky, priority, and additionalMetadata.
+     * @returns The result of the workflow.
+     */
+    runChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, options?: ChildRunOpts): Promise<P>;
+    /**
+     * Enqueues a new workflow without waiting for its result.
+     *
+     * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - An options object containing key, sticky, priority, and additionalMetadata.
+     * @returns A reference to the spawned workflow run.
+     */
+    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: ChildRunOpts): Promise<WorkflowRunRef<P>>;
+    /**
+     * Retrieves additional metadata associated with the current workflow run.
+     * @returns A record of metadata key-value pairs.
+     */
+    additionalMetadata(): Record<string, string>;
+    /**
+     * Gets the index of this workflow if it was spawned as part of a bulk operation.
+     * @returns The child index number, or undefined if not set.
+     */
+    childIndex(): number | undefined;
+    /**
+     * Gets the key associated with this workflow if it was spawned as a child workflow.
+     * @returns The child key, or undefined if not set.
+     */
+    childKey(): string | undefined;
+    /**
+     * Gets the ID of the parent workflow run if this workflow was spawned as a child.
+     * @returns The parent workflow run ID, or undefined if not a child workflow.
+     */
+    parentWorkflowRunId(): string | undefined;
+    priority(): Priority | undefined;
+    /**
+     * Get the output of a task.
+     * @param task - The name of the task to get the output for.
+     * @returns The output of the task.
+     * @throws An error if the task output is not found.
+     * @deprecated use ctx.parentOutput instead
+     */
+    stepOutput<L = NextStep>(step: string): L;
+    /**
+     * Gets the input data for the current workflow.
+     * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
+     */
+    workflowInput(): T;
+    /**
+     * Gets the name of the current task.
+     * @returns The name of the task.
+     * @deprecated use ctx.taskName instead
+     */
+    stepName(): string;
+    /**
+     * Spawns multiple workflows.
+     *
+     * @param workflows - An array of objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of references to the spawned workflow runs.
+     * @deprecated Use bulkRunNoWaitChildren or bulkRunChildren instead.
+     */
+    spawnWorkflows<Q extends JsonObject = any, P extends JsonObject = any>(workflows: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: ChildRunOpts;
+    }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Spawns a new workflow.
+     *
+     * @param workflow - The workflow to spawn (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - Additional options for spawning the workflow.
+     * @returns A reference to the spawned workflow run.
+     * @deprecated Use runChild or runNoWaitChild instead.
+     */
+    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, options?: ChildRunOpts): Promise<WorkflowRunRef<P>>;
+}
+export declare class DurableContext<T, K = {}> extends Context<T, K> {
+    waitKey: number;
+    /**
+     * Pauses execution for the specified duration.
+     * Duration is "global" meaning it will wait in real time regardless of transient failures like worker restarts.
+     * @param duration - The duration to sleep for.
+     * @returns A promise that resolves when the sleep duration has elapsed.
+     */
+    sleepFor(duration: Duration, readableDataKey?: string): Promise<Record<string, any>>;
+    /**
+     * Pauses execution until the specified conditions are met.
+     * Conditions are "global" meaning they will wait in real time regardless of transient failures like worker restarts.
+     * @param conditions - The conditions to wait for.
+     * @returns A promise that resolves with the event that satisfied the conditions.
+     */
+    waitFor(conditions: Conditions | Conditions[]): Promise<Record<string, any>>;
+}
+export {};