@hatchet-dev/typescript-sdk 0.16.0 → 0.17.1

package/clients/event/event-client.d.ts

@@ -2,6 +2,7 @@ import { Channel, ClientFactory } from 'nice-grpc';
 import { EventsServiceClient } from '../../protoc/events/events';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
+import { retrier } from '../../util/retrier';
 export declare enum LogLevel {
     INFO = "INFO",
     WARN = "WARN",
@@ -18,6 +19,7 @@ export interface EventWithMetadata<T> {
 export declare class EventClient {
     config: ClientConfig;
     client: EventsServiceClient;
+    retrier: typeof retrier;
     logger: Logger;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
     push<T>(type: string, input: T, options?: PushEventOptions): Promise<import("../../protoc/events/events").Event>;

package/clients/event/event-client.js

@@ -30,6 +30,7 @@ class EventClient {
         this.config = config;
         this.client = factory.create(events_1.EventsServiceDefinition, channel);
         this.logger = new logger_1.Logger(`Dispatcher`, config.log_level);
+        this.retrier = retrier_1.retrier;
     }
     push(type, input, options = {}) {
         var _a;
@@ -43,7 +44,7 @@ class EventClient {
                 : undefined,
         };
         try {
-            const e = this.client.push(req);
+            const e = this.retrier(() => __awaiter(this, void 0, void 0, function* () { return this.client.push(req); }), this.logger);
             this.logger.info(`Event pushed: ${namespacedType}`);
             return e;
         }
@@ -74,9 +75,9 @@ class EventClient {
             events,
         };
         try {
-            const e = this.client.bulkPush(req);
+            const res = this.retrier(() => __awaiter(this, void 0, void 0, function* () { return this.client.bulkPush(req); }), this.logger);
             this.logger.info(`Bulk events pushed for type: ${namespacedType}`);
-            return e;
+            return res;
         }
         catch (e) {
             throw new hatchet_error_1.default(e.message);

package/clients/worker/worker.js

@@ -48,7 +48,7 @@ class Worker {
     registerActions(workflow) {
         var _a;
         const newActions = workflow.steps.reduce((acc, step) => {
-            acc[`${workflow.id}:${step.name}`] = step.run;
+            acc[`${workflow.id}:${step.name.toLowerCase()}`] = step.run;
             return acc;
         }, {});
         const onFailureAction = workflow.onFailure
@@ -59,7 +59,7 @@ class Worker {
         this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
         this.action_registry =
             ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name.toLowerCase()}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
     getHandler(workflows) {
         for (const workflow of workflows) {
@@ -136,7 +136,7 @@ class Worker {
                             name: workflow.id,
                             description: workflow.description,
                             steps: workflow.steps.map((step) => {
-                                var _a;
+                                var _a, _b, _c;
                                 return ({
                                     readableId: step.name,
                                     action: `${workflow.id}:${step.name}`,
@@ -147,6 +147,8 @@ class Worker {
                                     retries: step.retries || 0,
                                     rateLimits: (0, step_1.mapRateLimit)(step.rate_limits),
                                     workerLabels: toPbWorkerLabel(step.worker_labels),
+                                    backoffFactor: (_b = step.backoff) === null || _b === void 0 ? void 0 : _b.factor,
+                                    backoffMaxSeconds: (_c = step.backoff) === null || _c === void 0 ? void 0 : _c.maxSeconds,
                                 });
                             }),
                         },
@@ -163,7 +165,7 @@ class Worker {
         });
     }
     registerAction(actionId, action) {
-        this.action_registry[actionId] = action;
+        this.action_registry[actionId.toLowerCase()] = action;
     }
     handleStartStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -173,6 +175,7 @@ class Worker {
                 this.contexts[action.stepRunId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
+                    this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
                     this.logger.error(`Could not find step '${actionId}'`);
                     return;
                 }

package/examples/retries-with-backoff.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/retries-with-backoff.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+let numRetries = 0;
+// ❓ Backoff
+const workflow = {
+    // ... normal workflow definition
+    id: 'retries-with-backoff',
+    description: 'Backoff',
+    // ,
+    steps: [
+        {
+            name: 'backoff-step',
+            // ... step definition
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                if (numRetries < 5) {
+                    numRetries += 1;
+                    throw new Error('failed');
+                }
+                return { backoff: 'completed' };
+            }),
+            // ,
+            retries: 10,
+            // 👀 Backoff configuration
+            backoff: {
+                // 👀 Maximum number of seconds to wait between retries
+                maxSeconds: 60,
+                // 👀 Factor to increase the wait time between retries.
+                // This sequence will be 2s, 4s, 8s, 16s, 32s, 60s... due to the maxSeconds limit
+                factor: 2,
+            },
+        },
+    ],
+};
+// ‼️
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('backoff-worker');
+        yield worker.registerWorkflow(workflow);
+        worker.start();
+    });
+}
+main();

package/index.d.ts

@@ -6,3 +6,4 @@ export * from './clients/rest';
 export * from './clients/admin';
 export * from './util/workflow-run-ref';
 export default Hatchet;
+export { Hatchet };

package/index.js

@@ -14,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hatchet = void 0;
 const hatchet_client_1 = require("./clients/hatchet-client");
+Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return hatchet_client_1.HatchetClient; } });
 __exportStar(require("./workflow"), exports);
 __exportStar(require("./step"), exports);
 __exportStar(require("./clients/worker"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -54,6 +54,7 @@
     "event:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-event.ts",
     "worker:playground": "npm run exec -- ./src/examples/playground.ts",
     "worker:retries": "npm run exec -- ./src/examples/retries-worker.ts",
+    "worker:retries-with-backoff": "npm run exec -- ./src/examples/retries-with-backoff.ts",
     "worker:multi-workflow": "npm run exec -- ./src/examples/multi-workflow.ts",
     "worker:logger": "npm run exec -- ./src/examples/logger.ts",
     "api": "npm run exec -- ./src/examples/api.ts",

package/protoc/dispatcher/dispatcher.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.3.0
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: dispatcher/dispatcher.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/events/events.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.3.0
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: events/events.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/google/protobuf/timestamp.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.3.0
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: google/protobuf/timestamp.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/protoc/workflows/workflows.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.3.0
+//   protoc-gen-ts_proto  v2.5.0
 //   protoc               v3.19.1
 // source: workflows/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });

package/step.d.ts

@@ -89,6 +89,16 @@ export declare const CreateStepSchema: z.ZodObject<{
         comparator?: WorkerLabelComparator | undefined;
         weight?: number | 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;
@@ -108,6 +118,10 @@ export declare const CreateStepSchema: z.ZodObject<{
         comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
     } | undefined> | undefined;
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    } | undefined;
 }, {
     name: string;
     timeout?: string | undefined;
@@ -127,6 +141,10 @@ export declare const CreateStepSchema: z.ZodObject<{
         comparator?: WorkerLabelComparator | undefined;
         weight?: number | undefined;
     } | undefined> | undefined;
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    } | undefined;
 }>;
 export type JsonObject = {
     [Key in string]: JsonValue;

package/step.js

@@ -84,6 +84,12 @@ exports.CreateStepSchema = z.object({
     retries: z.number().optional(),
     rate_limits: z.array(exports.CreateRateLimitSchema).optional(),
     worker_labels: z.record(z.lazy(() => exports.DesiredWorkerLabelSchema)).optional(),
+    backoff: z
+        .object({
+        factor: z.number().optional(),
+        maxSeconds: z.number().optional(),
+    })
+        .optional(),
 });
 class ContextWorker {
     constructor(worker) {

package/util/retrier.js

@@ -14,9 +14,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrier = retrier;
 const sleep_1 = __importDefault(require("./sleep"));
-const DEFAULT_RETRY_INTERVAL = 1; // seconds
+const DEFAULT_RETRY_INTERVAL = 0.1; // seconds
 const DEFAULT_RETRY_COUNT = 8;
-const MAX_JITTER = 400; // milliseconds
+const MAX_JITTER = 100; // milliseconds
 function retrier(fn_1, logger_1) {
     return __awaiter(this, arguments, void 0, function* (fn, logger, retries = DEFAULT_RETRY_COUNT, interval = DEFAULT_RETRY_INTERVAL) {
         let lastError;

package/util/workflow-run-ref.js

@@ -43,10 +43,10 @@ function getWorkflowRunId(workflowRunId) {
                 if (e.code && e.code === nice_grpc_1.Status.ALREADY_EXISTS) {
                     throw new DedupeViolationErr(e.details);
                 }
-                throw new Error('Invalid workflowRunId');
+                throw e;
             }
         }
-        throw new Error('Invalid workflowRunId');
+        throw new Error('Invalid workflowRunId: must be a string or a promise');
     });
 }
 class WorkflowRunRef {

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "0.16.0";
+export declare const HATCHET_VERSION = "0.17.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '0.16.0';
+exports.HATCHET_VERSION = '0.17.1';

package/workflow.d.ts

@@ -44,6 +44,16 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
         weight?: number | 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;
@@ -63,6 +73,10 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
         weight?: number | undefined;
     } | undefined> | undefined;
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    } | undefined;
 }, {
     name: string;
     timeout?: string | undefined;
@@ -82,6 +96,10 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
         comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
         weight?: number | 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;
@@ -178,6 +196,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | 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;
@@ -197,6 +225,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }, {
         name: string;
         timeout?: string | undefined;
@@ -216,6 +248,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }>, "many">;
     onFailure: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
@@ -260,6 +296,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | 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;
@@ -279,6 +325,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }, {
         name: string;
         timeout?: string | undefined;
@@ -298,6 +348,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     description: string;
@@ -320,6 +374,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }[];
     id: string;
     version?: string | undefined;
@@ -352,6 +410,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     } | undefined;
 }, {
     description: string;
@@ -374,6 +436,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     }[];
     id: string;
     version?: string | undefined;
@@ -406,6 +472,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
             comparator?: import("./protoc/workflows").WorkerLabelComparator | undefined;
             weight?: number | undefined;
         } | undefined> | undefined;
+        backoff?: {
+            factor?: number | undefined;
+            maxSeconds?: number | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {