@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/src/legacy/legacy-transformer.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyWorkflow = isLegacyWorkflow;
+exports.warnLegacyWorkflow = warnLegacyWorkflow;
+exports.transformLegacyWorkflow = transformLegacyWorkflow;
+exports.normalizeWorkflow = normalizeWorkflow;
+exports.normalizeWorkflows = normalizeWorkflows;
+exports.getWorkflowName = getWorkflowName;
+const step_1 = require("../../legacy/step");
+const declaration_1 = require("../v1/declaration");
+const LEGACY_WORKFLOW_WARNING = [
+    '',
+    '\x1b[33m╔══════════════════════════════════════════════════════════════════════════════╗',
+    '║                                                                              ║',
+    '║   ⚠  DEPRECATION WARNING: Legacy workflow format detected.                   ║',
+    '║                                                                              ║',
+    '║   Please migrate to the v1 SDK:                                              ║',
+    '║   https://docs.hatchet.run/home/migration-guide-typescript                   ║',
+    '║                                                                              ║',
+    '╚══════════════════════════════════════════════════════════════════════════════╝\x1b[0m',
+    '',
+].join('\n');
+/**
+ * Type guard: returns true if the workflow is a legacy v0 Workflow (not a BaseWorkflowDeclaration).
+ */
+function isLegacyWorkflow(workflow) {
+    return (workflow != null &&
+        typeof workflow === 'object' &&
+        !(workflow instanceof declaration_1.BaseWorkflowDeclaration) &&
+        'id' in workflow &&
+        'steps' in workflow &&
+        Array.isArray(workflow.steps));
+}
+/**
+ * Emits a deprecation warning for legacy workflow usage.
+ */
+function warnLegacyWorkflow() {
+    console.warn(LEGACY_WORKFLOW_WARNING);
+}
+/**
+ * Transforms a legacy v0 Workflow into a v1 WorkflowDeclaration.
+ *
+ * The transformed declaration can be registered with a worker and executed
+ * by the v1 runtime. Legacy step `run` functions are wrapped to receive
+ * a V0Context for backwards compatibility.
+ */
+function transformLegacyWorkflow(workflow) {
+    // Map concurrency
+    let concurrency;
+    if (workflow.concurrency) {
+        if (workflow.concurrency.key) {
+            console.warn('[hatchet] Legacy concurrency key functions are not supported in v1. ' +
+                'Use CEL expressions instead: https://docs.hatchet.run/home/v1-sdk-improvements');
+        }
+        concurrency = {
+            expression: workflow.concurrency.expression || workflow.concurrency.name,
+            maxRuns: workflow.concurrency.maxRuns,
+            limitStrategy: workflow.concurrency.limitStrategy,
+        };
+    }
+    const opts = {
+        name: workflow.id,
+        description: workflow.description,
+        version: workflow.version,
+        sticky: workflow.sticky != null ? workflow.sticky : undefined,
+        on: workflow.on ? workflow.on : undefined,
+        concurrency,
+        taskDefaults: {
+            executionTimeout: workflow.timeout,
+            scheduleTimeout: workflow.scheduleTimeout,
+        },
+    };
+    const declaration = new declaration_1.WorkflowDeclaration(opts);
+    // Build task lookup for parent resolution (parents are strings in legacy, objects in v1)
+    const taskMap = {};
+    for (const step of workflow.steps) {
+        const taskOpts = legacyStepToTaskOpts(step, taskMap, workflow.timeout);
+        taskMap[step.name] = taskOpts;
+        // eslint-disable-next-line no-underscore-dangle
+        declaration.definition._tasks.push(taskOpts);
+    }
+    // Handle onFailure
+    if (workflow.onFailure) {
+        declaration.definition.onFailure = {
+            fn: wrapLegacyStepRun(workflow.onFailure),
+            executionTimeout: (workflow.onFailure.timeout || workflow.timeout),
+            retries: workflow.onFailure.retries,
+            rateLimits: mapLegacyRateLimits(workflow.onFailure.rate_limits),
+            desiredWorkerLabels: workflow.onFailure.worker_labels,
+            backoff: workflow.onFailure.backoff,
+        };
+    }
+    return declaration;
+}
+/**
+ * Converts a legacy CreateStep to a v1 CreateWorkflowTaskOpts.
+ */
+function legacyStepToTaskOpts(step, taskMap, workflowTimeout) {
+    var _a;
+    return {
+        name: step.name,
+        fn: wrapLegacyStepRun(step),
+        executionTimeout: (step.timeout || workflowTimeout),
+        retries: step.retries,
+        rateLimits: mapLegacyRateLimits(step.rate_limits),
+        desiredWorkerLabels: step.worker_labels,
+        backoff: step.backoff,
+        parents: (_a = step.parents) === null || _a === void 0 ? void 0 : _a.map((name) => taskMap[name]).filter(Boolean),
+    };
+}
+/**
+ * Wraps a legacy step's `run(ctx: V0Context)` function into a v1-compatible
+ * `fn(input, ctx: Context)` function by constructing a V0Context at runtime.
+ */
+function wrapLegacyStepRun(step) {
+    return (input, ctx) => {
+        // Access the V1Worker from the ContextWorker's private field.
+        // This is intentionally accessing a private field for legacy compatibility.
+        // eslint-disable-next-line no-underscore-dangle
+        const v1Worker = ctx.worker.worker;
+        // eslint-disable-next-line no-underscore-dangle
+        const v0ctx = new step_1.V0Context(ctx.action, ctx.v1.v0, v1Worker);
+        // Share the abort controller so cancellation propagates
+        v0ctx.controller = ctx.controller;
+        return step.run(v0ctx);
+    };
+}
+/**
+ * Maps legacy rate limits to v1 format.
+ */
+function mapLegacyRateLimits(limits) {
+    if (!limits)
+        return undefined;
+    return limits.map((l) => ({
+        staticKey: l.staticKey || l.key,
+        dynamicKey: l.dynamicKey,
+        units: l.units,
+        limit: l.limit,
+        duration: l.duration,
+    }));
+}
+/**
+ * Normalizes a workflow: if it is a legacy Workflow, emits a deprecation warning
+ * and transforms it into a BaseWorkflowDeclaration. If already a v1 declaration,
+ * returns it as-is.
+ */
+function normalizeWorkflow(workflow) {
+    if (isLegacyWorkflow(workflow)) {
+        warnLegacyWorkflow();
+        return transformLegacyWorkflow(workflow);
+    }
+    return workflow;
+}
+/**
+ * Normalizes an array of workflows, transforming any legacy workflows and
+ * emitting deprecation warnings.
+ */
+function normalizeWorkflows(workflows) {
+    return workflows.map(normalizeWorkflow);
+}
+/**
+ * Extracts the workflow name from a workflow-like value.
+ * Works for strings, BaseWorkflowDeclaration, WorkflowDefinition, and legacy Workflow.
+ * Emits a deprecation warning if a legacy workflow is detected.
+ */
+function getWorkflowName(workflow) {
+    if (typeof workflow === 'string') {
+        return workflow;
+    }
+    if (workflow instanceof declaration_1.BaseWorkflowDeclaration) {
+        return workflow.name;
+    }
+    if (isLegacyWorkflow(workflow)) {
+        warnLegacyWorkflow();
+        return workflow.id;
+    }
+    if ('name' in workflow) {
+        return workflow.name;
+    }
+    throw new Error('Invalid workflow: must be a string, BaseWorkflowDeclaration, or legacy Workflow object');
+}

package/{step.d.ts → src/legacy/step.d.ts}

@@ -1,20 +1,19 @@
 import * as z from 'zod';
 import { JsonObject } from '@bufbuild/protobuf';
 import { Workflow } from './workflow';
-import { Action } from './clients/dispatcher/action-listener';
-import { LogLevel } from './clients/event/event-client';
-import { Logger } from './util/logger';
-import WorkflowRunRef from './util/workflow-run-ref';
-import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
-import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
-import { CreateWorkflowTaskOpts, Priority } from './v1';
-import { RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from './v1/declaration';
-import { Conditions } from './v1/conditions';
-import { Duration } from './v1/client/duration';
-import { JsonValue, OutputType } from './v1/types';
-import { V1Worker } from './v1/client/worker/worker-internal';
-import { V0Worker } from './clients/worker';
-import { LegacyHatchetClient } from './clients/hatchet-client';
+import { Action } from '../clients/dispatcher/action-listener';
+import { LogLevel } from '../clients/event/event-client';
+import { Logger } from '../util/logger';
+import WorkflowRunRef from '../util/workflow-run-ref';
+import { WorkerLabels } from '../clients/dispatcher/dispatcher-client';
+import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from '../protoc/workflows';
+import { CreateWorkflowTaskOpts, Priority } from '../v1';
+import { RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from '../v1/declaration';
+import { Conditions } from '../v1/conditions';
+import { Duration } from '../v1/client/duration';
+import { JsonValue, OutputType } from '../v1/types';
+import { InternalWorker } from '../v1/client/worker/worker-internal';
+import { LegacyHatchetClient } from './legacy-client';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -25,17 +24,17 @@ export declare const CreateRateLimitSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     units: string | number;
     key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
     staticKey?: string | undefined;
     dynamicKey?: string | undefined;
     limit?: string | number | undefined;
-    duration?: RateLimitDuration | undefined;
 }, {
     units: string | number;
     key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
     staticKey?: string | undefined;
     dynamicKey?: string | undefined;
     limit?: string | number | undefined;
-    duration?: RateLimitDuration | undefined;
 }>;
 export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
     value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -45,13 +44,13 @@ export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodSt
 }, "strip", z.ZodTypeAny, {
     value: string | number;
     required?: boolean | undefined;
-    weight?: number | undefined;
     comparator?: WorkerLabelComparator | undefined;
+    weight?: number | undefined;
 }, {
     value: string | number;
     required?: boolean | undefined;
-    weight?: number | undefined;
     comparator?: WorkerLabelComparator | undefined;
+    weight?: number | undefined;
 }>]>>;
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
@@ -68,17 +67,17 @@ export declare const CreateStepSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         units: string | number;
         key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
         limit?: string | number | undefined;
-        duration?: RateLimitDuration | undefined;
     }, {
         units: string | number;
         key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
         limit?: string | number | undefined;
-        duration?: RateLimitDuration | undefined;
     }>, "many">>;
     worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
         value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -88,13 +87,13 @@ export declare const CreateStepSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         value: string | number;
         required?: boolean | undefined;
-        weight?: number | undefined;
         comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
     }, {
         value: string | number;
         required?: boolean | undefined;
-        weight?: number | undefined;
         comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
     }>]>>>>>;
     backoff: z.ZodOptional<z.ZodObject<{
         factor: z.ZodOptional<z.ZodNumber>;
@@ -114,16 +113,16 @@ export declare const CreateStepSchema: z.ZodObject<{
     rate_limits?: {
         units: string | number;
         key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
         limit?: string | number | undefined;
-        duration?: RateLimitDuration | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
         required?: boolean | undefined;
-        weight?: number | undefined;
         comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
     } | undefined> | undefined;
     backoff?: {
         factor?: number | undefined;
@@ -137,16 +136,16 @@ export declare const CreateStepSchema: z.ZodObject<{
     rate_limits?: {
         units: string | number;
         key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
         staticKey?: string | undefined;
         dynamicKey?: string | undefined;
         limit?: string | number | undefined;
-        duration?: RateLimitDuration | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
         required?: boolean | undefined;
-        weight?: number | undefined;
         comparator?: WorkerLabelComparator | undefined;
+        weight?: number | undefined;
     } | undefined> | undefined;
     backoff?: {
         factor?: number | undefined;
@@ -169,9 +168,9 @@ interface ContextData<T, K> {
     user_data: K;
     step_run_errors: Record<string, string>;
 }
-export declare class ContextWorker {
+export declare class V0ContextWorker {
     private worker;
-    constructor(worker: V0Worker | V1Worker);
+    constructor(worker: InternalWorker);
     /**
      * Gets the ID of the worker.
      * @returns The ID of the worker.
@@ -201,11 +200,11 @@ export declare class V0Context<T, K = {}> {
     controller: AbortController;
     action: Action;
     v0: LegacyHatchetClient;
-    worker: ContextWorker;
+    worker: V0ContextWorker;
     overridesData: Record<string, any>;
     logger: Logger;
     spawnIndex: number;
-    constructor(action: Action, client: LegacyHatchetClient, worker: V0Worker | V1Worker);
+    constructor(action: Action, client: LegacyHatchetClient, worker: InternalWorker);
     get abortController(): AbortController;
     get cancelled(): boolean;
     /**
@@ -286,7 +285,7 @@ export declare class V0Context<T, K = {}> {
     /**
      * Gets the ID of the current task run.
      * @returns The task run ID.
-     * @deprecated use taskRunExternalId() instead
+     * @deprecated use taskRunExternalId instead
      */
     taskRunId(): string;
     /**

package/{step.js → src/legacy/step.js}

@@ -45,20 +45,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.V0DurableContext = exports.V0Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
+exports.V0DurableContext = exports.V0Context = exports.V0ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
 exports.mapRateLimit = mapRateLimit;
 /* eslint-disable no-underscore-dangle */
 /* eslint-disable max-classes-per-file */
-const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
-const parse_1 = require("./util/parse");
-const workflows_1 = require("./protoc/workflows");
-const v1_1 = require("./v1");
-const declaration_1 = require("./v1/declaration");
-const conditions_1 = require("./v1/conditions");
-const condition_1 = require("./protoc/v1/shared/condition");
-const transformer_1 = require("./v1/conditions/transformer");
-const apply_namespace_1 = require("./util/apply-namespace");
+const parse_1 = require("../util/parse");
+const workflows_1 = require("../protoc/workflows");
+const v1_1 = require("../v1");
+const declaration_1 = require("../v1/declaration");
+const conditions_1 = require("../v1/conditions");
+const condition_1 = require("../protoc/v1/shared/condition");
+const transformer_1 = require("../v1/conditions/transformer");
+const apply_namespace_1 = require("../util/apply-namespace");
 exports.CreateRateLimitSchema = z.object({
     key: z.string().optional(),
     staticKey: z.string().optional(),
@@ -96,7 +96,7 @@ exports.CreateStepSchema = z.object({
     })
         .optional(),
 });
-class ContextWorker {
+class V0ContextWorker {
     constructor(worker) {
         this.worker = worker;
     }
@@ -131,7 +131,7 @@ class ContextWorker {
         return this.worker.upsertLabels(labels);
     }
 }
-exports.ContextWorker = ContextWorker;
+exports.V0ContextWorker = V0ContextWorker;
 class V0Context {
     constructor(action, client, worker) {
         // @deprecated use ctx.abortController instead
@@ -143,7 +143,7 @@ class V0Context {
             this.data = data;
             this.action = action;
             this.v0 = client;
-            this.worker = new ContextWorker(worker);
+            this.worker = new V0ContextWorker(worker);
             this.logger = client.config.logger(`Context Logger`, client.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
@@ -286,10 +286,10 @@ class V0Context {
     /**
      * Gets the ID of the current task run.
      * @returns The task run ID.
-     * @deprecated use taskRunExternalId() instead
+     * @deprecated use taskRunExternalId instead
      */
     taskRunId() {
-        return this.taskRunExternalId();
+        return this.action.taskRunExternalId;
     }
     /**
      * Gets the number of times the current task has been retried.
@@ -654,7 +654,8 @@ function mapRateLimit(limits) {
     });
 }
 // Helper function to validate CEL expressions
-function validateCelExpression(_expr) {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function validateCelExpression(expr) {
     // This is a placeholder. In a real implementation, you'd need to use a CEL parser or validator.
     // For now, we'll just return true to mimic the behavior.
     return true;