@hatchet-dev/typescript-sdk 0.0.3 → 0.0.8

package/{dist/protoc → protoc}/workflows/workflows.js

@@ -23,11 +23,50 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowServiceDefinition = exports.GetWorkflowByNameRequest = exports.DeleteWorkflowRequest = exports.Step = exports.Job = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowTriggers = exports.WorkflowVersion = exports.Workflow = exports.ListWorkflowsForEventRequest = exports.ListWorkflowsResponse = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateWorkflowStepOpts = exports.CreateWorkflowJobOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.protobufPackage = void 0;
+exports.WorkflowServiceDefinition = exports.GetWorkflowByNameRequest = exports.DeleteWorkflowRequest = exports.Step = exports.Job = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowTriggers = exports.WorkflowVersion = exports.Workflow = exports.ListWorkflowsForEventRequest = exports.ListWorkflowsResponse = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateWorkflowStepOpts = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.concurrencyLimitStrategyToJSON = exports.concurrencyLimitStrategyFromJSON = exports.ConcurrencyLimitStrategy = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 const wrappers_1 = require("../google/protobuf/wrappers");
 exports.protobufPackage = "";
+var ConcurrencyLimitStrategy;
+(function (ConcurrencyLimitStrategy) {
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_IN_PROGRESS"] = 0] = "CANCEL_IN_PROGRESS";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["DROP_NEWEST"] = 1] = "DROP_NEWEST";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["QUEUE_NEWEST"] = 2] = "QUEUE_NEWEST";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ConcurrencyLimitStrategy || (exports.ConcurrencyLimitStrategy = ConcurrencyLimitStrategy = {}));
+function concurrencyLimitStrategyFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "CANCEL_IN_PROGRESS":
+            return ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS;
+        case 1:
+        case "DROP_NEWEST":
+            return ConcurrencyLimitStrategy.DROP_NEWEST;
+        case 2:
+        case "QUEUE_NEWEST":
+            return ConcurrencyLimitStrategy.QUEUE_NEWEST;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ConcurrencyLimitStrategy.UNRECOGNIZED;
+    }
+}
+exports.concurrencyLimitStrategyFromJSON = concurrencyLimitStrategyFromJSON;
+function concurrencyLimitStrategyToJSON(object) {
+    switch (object) {
+        case ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS:
+            return "CANCEL_IN_PROGRESS";
+        case ConcurrencyLimitStrategy.DROP_NEWEST:
+            return "DROP_NEWEST";
+        case ConcurrencyLimitStrategy.QUEUE_NEWEST:
+            return "QUEUE_NEWEST";
+        case ConcurrencyLimitStrategy.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.concurrencyLimitStrategyToJSON = concurrencyLimitStrategyToJSON;
 function createBasePutWorkflowRequest() {
     return { opts: undefined };
 }
@@ -89,6 +128,7 @@ function createBaseCreateWorkflowVersionOpts() {
         cronTriggers: [],
         scheduledTriggers: [],
         jobs: [],
+        concurrency: undefined,
     };
 }
 exports.CreateWorkflowVersionOpts = {
@@ -114,6 +154,9 @@ exports.CreateWorkflowVersionOpts = {
         for (const v of message.jobs) {
             exports.CreateWorkflowJobOpts.encode(v, writer.uint32(58).fork()).ldelim();
         }
+        if (message.concurrency !== undefined) {
+            exports.WorkflowConcurrencyOpts.encode(message.concurrency, writer.uint32(66).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
@@ -165,6 +208,12 @@ exports.CreateWorkflowVersionOpts = {
                     }
                     message.jobs.push(exports.CreateWorkflowJobOpts.decode(reader, reader.uint32()));
                     continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.concurrency = exports.WorkflowConcurrencyOpts.decode(reader, reader.uint32());
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -190,6 +239,7 @@ exports.CreateWorkflowVersionOpts = {
             jobs: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.jobs)
                 ? object.jobs.map((e) => exports.CreateWorkflowJobOpts.fromJSON(e))
                 : [],
+            concurrency: isSet(object.concurrency) ? exports.WorkflowConcurrencyOpts.fromJSON(object.concurrency) : undefined,
         };
     },
     toJSON(message) {
@@ -216,6 +266,9 @@ exports.CreateWorkflowVersionOpts = {
         if ((_d = message.jobs) === null || _d === void 0 ? void 0 : _d.length) {
             obj.jobs = message.jobs.map((e) => exports.CreateWorkflowJobOpts.toJSON(e));
         }
+        if (message.concurrency !== undefined) {
+            obj.concurrency = exports.WorkflowConcurrencyOpts.toJSON(message.concurrency);
+        }
         return obj;
     },
     create(base) {
@@ -231,6 +284,90 @@ exports.CreateWorkflowVersionOpts = {
         message.cronTriggers = ((_e = object.cronTriggers) === null || _e === void 0 ? void 0 : _e.map((e) => e)) || [];
         message.scheduledTriggers = ((_f = object.scheduledTriggers) === null || _f === void 0 ? void 0 : _f.map((e) => e)) || [];
         message.jobs = ((_g = object.jobs) === null || _g === void 0 ? void 0 : _g.map((e) => exports.CreateWorkflowJobOpts.fromPartial(e))) || [];
+        message.concurrency = (object.concurrency !== undefined && object.concurrency !== null)
+            ? exports.WorkflowConcurrencyOpts.fromPartial(object.concurrency)
+            : undefined;
+        return message;
+    },
+};
+function createBaseWorkflowConcurrencyOpts() {
+    return { action: "", maxRuns: 0, limitStrategy: 0 };
+}
+exports.WorkflowConcurrencyOpts = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.action !== "") {
+            writer.uint32(10).string(message.action);
+        }
+        if (message.maxRuns !== 0) {
+            writer.uint32(16).int32(message.maxRuns);
+        }
+        if (message.limitStrategy !== 0) {
+            writer.uint32(24).int32(message.limitStrategy);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWorkflowConcurrencyOpts();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.action = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.maxRuns = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.limitStrategy = reader.int32();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            action: isSet(object.action) ? globalThis.String(object.action) : "",
+            maxRuns: isSet(object.maxRuns) ? globalThis.Number(object.maxRuns) : 0,
+            limitStrategy: isSet(object.limitStrategy) ? concurrencyLimitStrategyFromJSON(object.limitStrategy) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.action !== "") {
+            obj.action = message.action;
+        }
+        if (message.maxRuns !== 0) {
+            obj.maxRuns = Math.round(message.maxRuns);
+        }
+        if (message.limitStrategy !== 0) {
+            obj.limitStrategy = concurrencyLimitStrategyToJSON(message.limitStrategy);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WorkflowConcurrencyOpts.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseWorkflowConcurrencyOpts();
+        message.action = (_a = object.action) !== null && _a !== void 0 ? _a : "";
+        message.maxRuns = (_b = object.maxRuns) !== null && _b !== void 0 ? _b : 0;
+        message.limitStrategy = (_c = object.limitStrategy) !== null && _c !== void 0 ? _c : 0;
         return message;
     },
 };

package/{dist/step.d.ts → step.d.ts}

@@ -2,12 +2,15 @@ import * as z from 'zod';
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     parents?: string[] | undefined;
+    timeout?: string | undefined;
 }, {
     name: string;
     parents?: string[] | undefined;
+    timeout?: string | undefined;
 }>;
 export type NextStep = {
     [key: string]: string;

package/{dist/step.js → step.js}

@@ -29,9 +29,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.CreateStepSchema = void 0;
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
+const workflow_1 = require("./workflow");
 exports.CreateStepSchema = z.object({
     name: z.string(),
     parents: z.array(z.string()).optional(),
+    timeout: workflow_1.HatchetTimeoutSchema.optional(),
 });
 class Context {
     constructor(payload) {

package/{dist/workflow.d.ts → workflow.d.ts}

@@ -1,19 +1,40 @@
 import * as z from 'zod';
 import { CreateStep } from './step';
+import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy } 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>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     parents?: string[] | undefined;
+    timeout?: string | undefined;
 }, {
     name: string;
     parents?: string[] | undefined;
+    timeout?: string | undefined;
 }>, "many">;
 export type Steps = z.infer<typeof StepsSchema>;
+export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
+export declare const WorkflowConcurrency: z.ZodObject<{
+    action: z.ZodOptional<z.ZodString>;
+    maxRuns: z.ZodOptional<z.ZodNumber>;
+    limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
+}, "strip", z.ZodTypeAny, {
+    action?: string | undefined;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+}, {
+    action?: string | undefined;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+}>;
+export declare const HatchetTimeoutSchema: z.ZodString;
 export declare const CreateWorkflowSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodString>;
     on: z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
         event: z.ZodUndefined;
@@ -36,18 +57,22 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        timeout: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         parents?: string[] | undefined;
+        timeout?: string | undefined;
     }, {
         name: string;
         parents?: string[] | undefined;
+        timeout?: string | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     description: string;
     steps: {
         name: string;
         parents?: string[] | undefined;
+        timeout?: string | undefined;
     }[];
     id: string;
     on: {
@@ -57,11 +82,14 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     };
+    version?: string | undefined;
+    timeout?: string | undefined;
 }, {
     description: string;
     steps: {
         name: string;
         parents?: string[] | undefined;
+        timeout?: string | undefined;
     }[];
     id: string;
     on: {
@@ -71,8 +99,13 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     };
+    version?: string | undefined;
+    timeout?: string | undefined;
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
+    concurrency?: z.infer<typeof WorkflowConcurrency> & {
+        key: (ctx: any) => string;
+    };
     steps: CreateStep<any>[];
 }
 export {};

package/{dist/workflow.js → workflow.js}

@@ -23,9 +23,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateWorkflowSchema = void 0;
+exports.CreateWorkflowSchema = 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(),
@@ -36,9 +37,18 @@ const EventConfigSchema = z.object({
 });
 const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
 const StepsSchema = z.array(step_1.CreateStepSchema);
+exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
+exports.WorkflowConcurrency = z.object({
+    action: z.string().optional(),
+    maxRuns: z.number().optional(),
+    limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
+});
+exports.HatchetTimeoutSchema = z.string();
 exports.CreateWorkflowSchema = z.object({
     id: z.string(),
     description: z.string(),
+    version: z.string().optional(),
+    timeout: exports.HatchetTimeoutSchema.optional(),
     on: OnConfigSchema,
     steps: StepsSchema,
 });

package/README.md

@@ -1,3 +0,0 @@
-# Hatchet - Typescript SDK
-
-Please refer to the [Hatchet Typescript SDK documentation](https://docs.hatchet.run/typescript-sdk/setup) for setup instructions and usage details.

package/dist/clients/dispatcher/dispatcher-client.d.ts

@@ -1,17 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import { DispatcherClient as PbDispatcherClient, ActionEvent } from '../../protoc/dispatcher';
-import { ClientConfig } from '../hatchet-client/client-config';
-import { ActionListener } from './action-listener';
-interface GetActionListenerOptions {
-    workerName: string;
-    services: string[];
-    actions: string[];
-}
-export declare class DispatcherClient {
-    config: ClientConfig;
-    client: PbDispatcherClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
-    get_action_listener(options: GetActionListenerOptions): Promise<ActionListener>;
-    send_action_event(in_: ActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
-}
-export {};