@hatchet-dev/typescript-sdk 1.13.1 → 1.14.0

package/legacy/workflow.d.ts

@@ -0,0 +1,488 @@
+import * as z from 'zod';
+import { CreateStep } from '../step';
+import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy, StickyStrategy as PbStickyStrategy } from '../protoc/workflows';
+declare const StepsSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodString>;
+    retries: z.ZodOptional<z.ZodNumber>;
+    rate_limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodOptional<z.ZodString>;
+        staticKey: z.ZodOptional<z.ZodString>;
+        dynamicKey: z.ZodOptional<z.ZodString>;
+        units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+        limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        duration: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+    }, "strip", z.ZodTypeAny, {
+        units: string | number;
+        key?: string | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+    }, {
+        units: string | number;
+        key?: string | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: import("../protoc/workflows").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]>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        weight: z.ZodOptional<z.ZodNumber>;
+        comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").WorkerLabelComparator>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string | number;
+        required?: boolean | undefined;
+        weight?: number | undefined;
+        comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+    }, {
+        value: string | number;
+        required?: boolean | undefined;
+        weight?: number | undefined;
+        comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+    }>]>>>>>;
+    backoff: z.ZodOptional<z.ZodObject<{
+        factor: z.ZodOptional<z.ZodNumber>;
+        maxSeconds: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    }, {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    timeout?: string | undefined;
+    parents?: string[] | undefined;
+    retries?: number | undefined;
+    rate_limits?: {
+        units: string | number;
+        key?: string | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+    }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        weight?: number | undefined;
+        comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+    } | undefined> | undefined;
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    } | undefined;
+}, {
+    name: string;
+    timeout?: string | undefined;
+    parents?: string[] | undefined;
+    retries?: number | undefined;
+    rate_limits?: {
+        units: string | number;
+        key?: string | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
+        limit?: string | number | undefined;
+        duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+    }[] | undefined;
+    worker_labels?: Record<string, string | number | {
+        value: string | number;
+        required?: boolean | undefined;
+        weight?: number | undefined;
+        comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+    } | undefined> | undefined;
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    } | undefined;
+}>, "many">;
+export type Steps = z.infer<typeof StepsSchema>;
+export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
+export declare const WorkflowConcurrency: z.ZodObject<{
+    name: z.ZodString;
+    maxRuns: z.ZodOptional<z.ZodNumber>;
+    limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
+    expression: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+    expression?: string | undefined;
+}, {
+    name: string;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+    expression?: string | undefined;
+}>;
+export declare const HatchetTimeoutSchema: z.ZodString;
+export declare const StickyStrategy: typeof PbStickyStrategy;
+export declare const CreateWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    sticky: z.ZodOptional<z.ZodUnion<[z.ZodNativeEnum<typeof PbStickyStrategy>, z.ZodEnum<["soft", "hard"]>]>>;
+    scheduleTimeout: z.ZodOptional<z.ZodString>;
+    /**
+     * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
+     */
+    timeout: z.ZodOptional<z.ZodString>;
+    on: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        cron: z.ZodString;
+        event: z.ZodUndefined;
+    }, "strip", z.ZodTypeAny, {
+        cron: string;
+        event?: undefined;
+    }, {
+        cron: string;
+        event?: undefined;
+    }>, z.ZodObject<{
+        cron: z.ZodUndefined;
+        event: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        event: string;
+        cron?: undefined;
+    }, {
+        event: string;
+        cron?: undefined;
+    }>]>>;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodString>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        rate_limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            staticKey: z.ZodOptional<z.ZodString>;
+            dynamicKey: z.ZodOptional<z.ZodString>;
+            units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+            limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+            duration: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+        }, "strip", z.ZodTypeAny, {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }, {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").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]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").WorkerLabelComparator>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        }, {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        }>]>>>>>;
+        backoff: z.ZodOptional<z.ZodObject<{
+            factor: z.ZodOptional<z.ZodNumber>;
+            maxSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        }, {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }>, "many">;
+    onFailure: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodString>;
+        retries: z.ZodOptional<z.ZodNumber>;
+        rate_limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            staticKey: z.ZodOptional<z.ZodString>;
+            dynamicKey: z.ZodOptional<z.ZodString>;
+            units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+            limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+            duration: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").RateLimitDuration>>;
+        }, "strip", z.ZodTypeAny, {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }, {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").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]>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            weight: z.ZodOptional<z.ZodNumber>;
+            comparator: z.ZodOptional<z.ZodNativeEnum<typeof import("../protoc/workflows").WorkerLabelComparator>>;
+        }, "strip", z.ZodTypeAny, {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        }, {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        }>]>>>>>;
+        backoff: z.ZodOptional<z.ZodObject<{
+            factor: z.ZodOptional<z.ZodNumber>;
+            maxSeconds: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        }, {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }, {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    steps: {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }[];
+    version?: string | undefined;
+    timeout?: string | undefined;
+    sticky?: PbStickyStrategy | "soft" | "hard" | undefined;
+    scheduleTimeout?: string | undefined;
+    on?: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    } | undefined;
+    onFailure?: {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    id: string;
+    description: string;
+    steps: {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    }[];
+    version?: string | undefined;
+    timeout?: string | undefined;
+    sticky?: PbStickyStrategy | "soft" | "hard" | undefined;
+    scheduleTimeout?: string | undefined;
+    on?: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    } | undefined;
+    onFailure?: {
+        name: string;
+        timeout?: string | undefined;
+        parents?: string[] | undefined;
+        retries?: number | undefined;
+        rate_limits?: {
+            units: string | number;
+            key?: string | undefined;
+            staticKey?: string | undefined;
+            dynamicKey?: string | undefined;
+            limit?: string | number | undefined;
+            duration?: import("../protoc/workflows").RateLimitDuration | undefined;
+        }[] | undefined;
+        worker_labels?: Record<string, string | number | {
+            value: string | number;
+            required?: boolean | undefined;
+            weight?: number | undefined;
+            comparator?: import("../protoc/workflows").WorkerLabelComparator | undefined;
+        } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+/**
+ * @deprecated Use client.workflow instead (TODO link to migration doc)
+ */
+export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
+    concurrency?: z.infer<typeof WorkflowConcurrency> & {
+        key?: (ctx: any) => string;
+    };
+    steps: CreateStep<any, any>[];
+    onFailure?: CreateStep<any, any>;
+}
+export {};

package/legacy/workflow.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateWorkflowSchema = exports.StickyStrategy = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
+const z = __importStar(require("zod"));
+const step_1 = require("../step");
+const workflows_1 = require("../protoc/workflows");
+const CronConfigSchema = z.object({
+    cron: z.string(),
+    event: z.undefined(),
+});
+const EventConfigSchema = z.object({
+    cron: z.undefined(),
+    event: z.string(),
+});
+const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]).optional();
+const StepsSchema = z.array(step_1.CreateStepSchema);
+exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
+exports.WorkflowConcurrency = z.object({
+    name: z.string(),
+    maxRuns: z.number().optional(),
+    limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
+    expression: z.string().optional(),
+});
+exports.HatchetTimeoutSchema = z.string();
+exports.StickyStrategy = workflows_1.StickyStrategy;
+exports.CreateWorkflowSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    version: z.string().optional(),
+    sticky: z.union([z.nativeEnum(workflows_1.StickyStrategy), z.enum(['soft', 'hard'])]).optional(),
+    scheduleTimeout: z.string().optional(),
+    /**
+     * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
+     */
+    timeout: exports.HatchetTimeoutSchema.optional(),
+    on: OnConfigSchema,
+    steps: StepsSchema,
+    onFailure: step_1.CreateStepSchema === null || step_1.CreateStepSchema === void 0 ? void 0 : step_1.CreateStepSchema.optional(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -77,7 +77,7 @@
     "dump-version": "node -e \"console.log('export const HATCHET_VERSION = \\'' + require('./package.json').version + '\\';');\" > src/version.ts",
     "tsc:build": "pnpm run dump-version && tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
-    "test:e2e": "jest --testMatch='**/*.e2e.ts'",
+    "test:e2e": "jest --config jest.e2e.config.ts --silent --forceExit --runInBand",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",
     "generate-api": "npx swagger-typescript-api@13.2.7 generate -p ../../bin/oas/openapi.yaml -o ./src/clients/rest/generated -n hatchet.ts --modular --axios",