@hatchet-dev/typescript-sdk 1.0.0-alpha0 → 1.0.0-alpha2

package/clients/worker/worker.js

@@ -25,6 +25,7 @@ const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const handler_1 = require("./handler");
+const transformer_1 = require("../../v1/conditions/transformer");
 const step_1 = require("../../step");
 class V0Worker {
     constructor(client, options) {
@@ -61,6 +62,7 @@ class V0Worker {
                 ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name.toLowerCase()}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
     getHandler(workflows) {
+        // TODO v1
         for (const workflow of workflows) {
             const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
             this.registerActions(wf);
@@ -80,6 +82,163 @@ class V0Worker {
             return this.registerWorkflow(initWorkflow);
         });
     }
+    registerDurableActionsV1(workflow) {
+        const newActions = workflow._durableTasks.reduce((acc, task) => {
+            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.workflowInput(), ctx);
+            return acc;
+        }, {});
+        this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
+    }
+    registerActionsV1(workflow) {
+        const newActions = workflow._tasks.reduce((acc, task) => {
+            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.workflowInput(), ctx);
+            return acc;
+        }, {});
+        const onFailureFn = workflow.onFailure
+            ? typeof workflow.onFailure === 'function'
+                ? workflow.onFailure
+                : workflow.onFailure.fn
+            : undefined;
+        const onFailureAction = onFailureFn
+            ? {
+                [onFailureTaskName(workflow)]: (ctx) => onFailureFn(ctx.workflowInput(), ctx),
+            }
+            : {};
+        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+    }
+    registerWorkflowV1(initWorkflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+            // patch the namespace
+            const workflow = Object.assign(Object.assign({}, initWorkflow.definition), { name: (this.client.config.namespace + initWorkflow.definition.name).toLowerCase() });
+            try {
+                const { concurrency } = workflow;
+                let onFailureTask;
+                if (workflow.onFailure && typeof workflow.onFailure === 'function') {
+                    onFailureTask = {
+                        readableId: 'on-failure-task',
+                        action: onFailureTaskName(workflow),
+                        timeout: '60s',
+                        inputs: '{}',
+                        parents: [],
+                        retries: 0,
+                        rateLimits: [],
+                        workerLabels: {},
+                        concurrency: [],
+                    };
+                }
+                if (workflow.onFailure && typeof workflow.onFailure === 'object') {
+                    const onFailure = workflow.onFailure;
+                    onFailureTask = {
+                        readableId: 'on-failure-task',
+                        action: onFailureTaskName(workflow),
+                        timeout: onFailure.executionTimeout || ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) || '60s',
+                        scheduleTimeout: onFailure.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
+                        inputs: '{}',
+                        parents: [],
+                        retries: onFailure.retries || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.retries) || 0,
+                        rateLimits: (0, step_1.mapRateLimit)(onFailure.rateLimits || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.rateLimits)),
+                        workerLabels: toPbWorkerLabel(onFailure.workerLabels || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.workerLabels)),
+                        concurrency: [],
+                        backoffFactor: ((_f = onFailure.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
+                        backoffMaxSeconds: ((_j = onFailure.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
+                    };
+                }
+                let onSuccessTask;
+                if (workflow.onSuccess && typeof workflow.onSuccess === 'function') {
+                    const parents = getLeaves(workflow._tasks);
+                    onSuccessTask = {
+                        name: 'on-success-task',
+                        fn: workflow.onSuccess,
+                        timeout: '60s',
+                        parents,
+                        retries: 0,
+                        rateLimits: [],
+                        workerLabels: {},
+                        concurrency: [],
+                    };
+                }
+                if (workflow.onSuccess && typeof workflow.onSuccess === 'object') {
+                    const onSuccess = workflow.onSuccess;
+                    const parents = getLeaves(workflow._tasks);
+                    onSuccessTask = {
+                        name: 'on-success-task',
+                        fn: onSuccess.fn,
+                        timeout: onSuccess.executionTimeout || ((_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.executionTimeout) || '60s',
+                        scheduleTimeout: onSuccess.scheduleTimeout || ((_o = workflow.taskDefaults) === null || _o === void 0 ? void 0 : _o.scheduleTimeout),
+                        parents,
+                        retries: onSuccess.retries || ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.retries) || 0,
+                        rateLimits: onSuccess.rateLimits || ((_q = workflow.taskDefaults) === null || _q === void 0 ? void 0 : _q.rateLimits),
+                        workerLabels: onSuccess.workerLabels || ((_r = workflow.taskDefaults) === null || _r === void 0 ? void 0 : _r.workerLabels),
+                        concurrency: onSuccess.concurrency || ((_s = workflow.taskDefaults) === null || _s === void 0 ? void 0 : _s.concurrency),
+                        backoff: onSuccess.backoff || ((_t = workflow.taskDefaults) === null || _t === void 0 ? void 0 : _t.backoff),
+                    };
+                }
+                if (onSuccessTask) {
+                    workflow._tasks.push(onSuccessTask);
+                }
+                // cron and event triggers
+                if (workflow.on) {
+                    this.logger.warn(`\`on\` for event and cron triggers is deprecated and will be removed soon, use \`onEvents\` and \`onCrons\` instead for ${workflow.name}`);
+                }
+                const eventTriggers = [
+                    ...(workflow.onEvents || []),
+                    ...(((_u = workflow.on) === null || _u === void 0 ? void 0 : _u.event) ? [workflow.on.event] : []),
+                ];
+                const cronTriggers = [
+                    ...(workflow.onCrons || []),
+                    ...(((_v = workflow.on) === null || _v === void 0 ? void 0 : _v.cron) ? [workflow.on.cron] : []),
+                ];
+                const registeredWorkflow = this.client.admin.putWorkflowV1({
+                    name: workflow.name,
+                    description: workflow.description || '',
+                    version: workflow.version || '',
+                    eventTriggers,
+                    cronTriggers,
+                    sticky: workflow.sticky,
+                    concurrency,
+                    onFailureTask,
+                    tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+                        return ({
+                            readableId: task.name,
+                            action: `${workflow.name}:${task.name}`,
+                            timeout: task.executionTimeout ||
+                                task.timeout ||
+                                ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) ||
+                                '60s',
+                            scheduleTimeout: task.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
+                            inputs: '{}',
+                            parents: (_d = (_c = task.parents) === null || _c === void 0 ? void 0 : _c.map((p) => p.name)) !== null && _d !== void 0 ? _d : [],
+                            userData: '{}',
+                            retries: task.retries || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.retries) || 0,
+                            rateLimits: (0, step_1.mapRateLimit)(task.rateLimits || ((_f = workflow.taskDefaults) === null || _f === void 0 ? void 0 : _f.rateLimits)),
+                            workerLabels: toPbWorkerLabel(task.workerLabels || ((_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.workerLabels)),
+                            backoffFactor: ((_h = task.backoff) === null || _h === void 0 ? void 0 : _h.factor) || ((_k = (_j = workflow.taskDefaults) === null || _j === void 0 ? void 0 : _j.backoff) === null || _k === void 0 ? void 0 : _k.factor),
+                            backoffMaxSeconds: ((_l = task.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds) || ((_o = (_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.backoff) === null || _o === void 0 ? void 0 : _o.maxSeconds),
+                            conditions: (0, transformer_1.taskConditionsToPb)(task),
+                            concurrency: task.concurrency
+                                ? Array.isArray(task.concurrency)
+                                    ? task.concurrency
+                                    : [task.concurrency]
+                                : ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.concurrency)
+                                    ? Array.isArray(workflow.taskDefaults.concurrency)
+                                        ? workflow.taskDefaults.concurrency
+                                        : [workflow.taskDefaults.concurrency]
+                                    : [],
+                        });
+                    }),
+                });
+                this.registeredWorkflowPromises.push(registeredWorkflow);
+                yield registeredWorkflow;
+                this.workflow_registry.push(workflow);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
+            }
+            this.registerActionsV1(workflow);
+        });
+    }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -170,7 +329,8 @@ class V0Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { actionId } = action;
             try {
-                const context = new step_1.Context(action, this.client, this);
+                // Note: we always use a DurableContext since its a superset of the Context class
+                const context = new step_1.DurableContext(action, this.client, this);
                 this.contexts[action.stepRunId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
@@ -187,8 +347,6 @@ class V0Worker {
                         // Send the action event to the dispatcher
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
                         yield this.client.dispatcher.sendStepActionEvent(event);
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
                     }
                     catch (actionEventError) {
                         this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
@@ -202,6 +360,11 @@ class V0Worker {
                         }
                         this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
                     }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                        delete this.contexts[action.stepRunId];
+                    }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
                     this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
@@ -215,12 +378,15 @@ class V0Worker {
                             stack: error === null || error === void 0 ? void 0 : error.stack,
                         });
                         yield this.client.dispatcher.sendStepActionEvent(event);
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                        delete this.contexts[action.stepRunId];
+                    }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
                     let result;
@@ -279,12 +445,15 @@ class V0Worker {
                         this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                             this.logger.error(`Could not send action event: ${e.message}`);
                         });
-                        // delete the run from the futures
-                        delete this.futures[key];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[key];
+                        delete this.contexts[key];
+                    }
                 };
                 const failure = (error) => {
                     this.logger.error(`Step run ${key} failed: ${error.message}`);
@@ -294,12 +463,15 @@ class V0Worker {
                         this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                             this.logger.error(`Could not send action event: ${e.message}`);
                         });
-                        // delete the run from the futures
-                        delete this.futures[key];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[key];
+                        delete this.contexts[key];
+                    }
                 };
                 const future = new hatchet_promise_1.default(run().then(success).catch(failure));
                 this.futures[key] = future;
@@ -344,14 +516,13 @@ class V0Worker {
     }
     handleCancelStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { stepRunId } = action;
             try {
                 this.logger.info(`Cancelling step run ${action.stepRunId}`);
-                const { stepRunId } = action;
                 const future = this.futures[stepRunId];
                 const context = this.contexts[stepRunId];
                 if (context && context.controller) {
                     context.controller.abort('Cancelled by worker');
-                    delete this.contexts[stepRunId];
                 }
                 if (future) {
                     future.promise.catch(() => {
@@ -359,12 +530,15 @@ class V0Worker {
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
-                    delete this.futures[stepRunId];
                 }
             }
             catch (e) {
                 this.logger.error('Could not cancel step run: ', e);
             }
+            finally {
+                delete this.futures[stepRunId];
+                delete this.contexts[stepRunId];
+            }
         });
     }
     stop() {
@@ -398,6 +572,9 @@ class V0Worker {
             var _a, e_1, _b, _c;
             // ensure all workflows are registered
             yield Promise.all(this.registeredWorkflowPromises);
+            if (Object.keys(this.action_registry).length === 0) {
+                return;
+            }
             try {
                 this.listener = yield this.client.dispatcher.getActionListener({
                     workerName: this.name,
@@ -427,7 +604,6 @@ class V0Worker {
                 }
             }
             catch (e) {
-                // TODO TEMP this needs to be handled better
                 if (this.killing) {
                     this.logger.info(`Exiting worker, ignoring error: ${e.message}`);
                     return;
@@ -501,3 +677,12 @@ function toPbWorkerLabel(in_) {
             } });
     }, {});
 }
+function onFailureTaskName(workflow) {
+    return `${workflow.name}:on-failure-task`;
+}
+function getLeaves(tasks) {
+    return tasks.filter((task) => isLeafTask(task, tasks));
+}
+function isLeafTask(task, allTasks) {
+    return !allTasks.some((t) => { var _a; return (_a = t.parents) === null || _a === void 0 ? void 0 : _a.some((p) => p.name === task.name); });
+}

package/examples/affinity-workers.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const workflows_1 = require("../protoc/workflows");
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
+// ❓ AffinityWorkflow
 const workflow = {
     id: 'affinity-workflow',
     description: 'test',
@@ -26,7 +27,7 @@ const workflow = {
                 // eslint-disable-next-line no-plusplus
                 for (let i = 0; i < 50; i++) {
                     const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
-                    results.push(result.result());
+                    results.push(result.output);
                 }
                 console.log('Spawned 50 child workflows');
                 console.log('Results:', yield Promise.all(results));
@@ -35,6 +36,7 @@ const workflow = {
         },
     ],
 };
+// ‼️
 const childWorkflow = {
     id: 'child-affinity-workflow',
     description: 'test',
@@ -70,12 +72,14 @@ const childWorkflow = {
 };
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
+        // ❓ AffinityWorker
         const worker1 = yield hatchet.worker('affinity-worker-1', {
             labels: {
                 model: 'abc',
                 memory: 1024,
             },
         });
+        // ‼️
         yield worker1.registerWorkflow(workflow);
         yield worker1.registerWorkflow(childWorkflow);
         worker1.start();

package/examples/api.js

@@ -49,7 +49,7 @@ function main() {
         const { admin } = hatchet;
         yield admin.putWorkflow(opts);
         const worker = yield hatchet.worker('example-worker');
-        worker.v0.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
+        worker.nonDurable.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
             const setData = ctx.userData();
             console.log('executed step1!', setData);
             return { step1: 'step1' };

package/examples/bulk-fanout-worker.js

@@ -32,7 +32,7 @@ const parentWorkflow = {
                     options: { additionalMetadata: { childKey: 'childValue' } },
                 }));
                 const spawnedWorkflows = yield ctx.spawnWorkflows(workflowRequests);
-                const results = yield Promise.all(spawnedWorkflows.map((workflowRef) => workflowRef.result().then((result) => {
+                const results = yield Promise.all(spawnedWorkflows.map((workflowRef) => workflowRef.output.then((result) => {
                     ctx.log('spawned workflow result:');
                     return result;
                 })));

package/examples/byo-logger.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // eslint-disable-next-line import/no-extraneous-dependencies
 const pino_1 = __importDefault(require("pino"));
 const sdk_1 = __importDefault(require("../sdk"));
+// ❓ Create Pino logger
 const logger = (0, pino_1.default)();
 class PinoLogger {
     constructor(context, logLevel = 'DEBUG') {
@@ -41,6 +42,8 @@ const hatchet = sdk_1.default.init({
     log_level: 'DEBUG',
     logger: (ctx, level) => new PinoLogger(ctx, level),
 });
+// !!
+// ❓ Use the logger
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -64,6 +67,7 @@ const workflow = {
         },
     ],
 };
+// !!
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet.worker('byo-logger-worker', 1);

package/examples/concurrency/cancel-in-progress/concurrency-event.js

@@ -19,7 +19,7 @@ const sleep = (ms) => new Promise((resolve) => {
 });
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        hatchet.event.push('concurrency:create', {
+        hatchet.events.push('concurrency:create', {
             data: 'event 1',
             userId: 'user1',
         });
@@ -28,7 +28,7 @@ function main() {
         // before that will cancel
         // the first run and run the second event
         yield sleep(1000);
-        hatchet.event.push('concurrency:create', {
+        hatchet.events.push('concurrency:create', {
             data: 'event 2',
             userId: 'user1',
         });

package/examples/concurrency/group-round-robin/concurrency-event.js

@@ -25,7 +25,7 @@ function main() {
             if (i > 10) {
                 group = 1;
             }
-            hatchet.event.push('concurrency:create', {
+            hatchet.events.push('concurrency:create', {
                 data: `event ${i}`,
                 group,
             });

package/examples/crons/programatic-crons.js

@@ -21,7 +21,7 @@ function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // ? Create
         // You can create dynamic cron triggers programmatically via the API
-        const createdCron = yield hatchet.cron.create(cron_worker_1.simpleCronWorkflow, // workflow object or string workflow id
+        const createdCron = yield hatchet.crons.create(cron_worker_1.simpleCronWorkflow, // workflow object or string workflow id
         {
             name: 'customer-a-daily-report', // friendly name for the cron trigger
             expression: '0 12 * * *', // every day at noon
@@ -36,16 +36,16 @@ function main() {
         // !!
         // ? Get
         // You can get a specific cron trigger by passing in the cron trigger id
-        const cron = yield hatchet.cron.get(id);
+        const cron = yield hatchet.crons.get(id);
         // !!
         // ? Delete
         // You can delete a cron trigger by passing the cron object
         // or a cron Id to the delete method
-        yield hatchet.cron.delete(cron);
+        yield hatchet.crons.delete(cron);
         // !!
         // ? List
         // You can list all cron triggers by passing in a query object
-        const cronList = yield hatchet.cron.list({
+        const cronList = yield hatchet.crons.list({
             offset: 0,
             limit: 10,
         });

package/examples/dag-worker.js

@@ -59,7 +59,6 @@ const workflow = {
                 // simulate a really slow network call
                 setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
                     yield sleep(1000);
-                    ctx.playground('slow', 'call');
                 }), 5000);
                 return { step4: 'step4' };
             }),

package/examples/example-event.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
 // Push a single event (example)
-hatchet.event.push('user:create', {
+hatchet.events.push('user:create', {
     test: 'test',
 });
 // Example events to be pushed in bulk
@@ -25,7 +25,7 @@ const events = [
     },
 ];
 // Bulk push the events and compare the keys
-hatchet.event
+hatchet.events
     .bulkPush('user:create:bulk', events)
     .then((result) => {
     const returnedEvents = result.events;

package/examples/logger.js

@@ -19,6 +19,7 @@ const hatchet = sdk_1.default.init({
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
+// ❓ Logger
 const workflow = {
     id: 'logger-example',
     description: 'test',
@@ -40,6 +41,7 @@ const workflow = {
         },
     ],
 };
+// ‼️
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet.worker('logger-worker', 1);

package/examples/on-failure.js

@@ -41,7 +41,7 @@ const workflow = {
             // 👀 we can do things like perform cleanup logic
             // or notify a user here
             // 👀 you can access the error from the failed step(s) like this
-            console.log(ctx.stepRunErrors());
+            console.log(ctx.errors());
             return { onFailure: 'step' };
         }),
     },

package/examples/rate-limit/events.js

@@ -5,12 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../../sdk"));
 const hatchet = sdk_1.default.init();
-hatchet.event.push('rate-limit:create', {
+hatchet.events.push('rate-limit:create', {
     test: '1',
 });
-hatchet.event.push('rate-limit:create', {
+hatchet.events.push('rate-limit:create', {
     test: '2',
 });
-hatchet.event.push('rate-limit:create', {
+hatchet.events.push('rate-limit:create', {
     test: '3',
 });

package/examples/scheduled-runs/programatic-schedules.js

@@ -21,7 +21,7 @@ function main() {
     return __awaiter(this, void 0, void 0, function* () {
         // ? Create
         // You can create dynamic scheduled runs programmatically via the API
-        const createdScheduledRun = yield hatchet.schedule.create(simple_worker_1.simpleWorkflow, // workflow object or string workflow id
+        const createdScheduledRun = yield hatchet.schedules.create(simple_worker_1.simpleWorkflow, // workflow object or string workflow id
         {
             triggerAt: new Date(Date.now() + 1000 * 60 * 60 * 24), // 24 hours from now
             input: {
@@ -35,16 +35,16 @@ function main() {
         // !!
         // ? Get
         // You can get a specific scheduled run by passing in the scheduled run id
-        const scheduledRun = yield hatchet.schedule.get(id);
+        const scheduledRun = yield hatchet.schedules.get(id);
         // !!
         // ? Delete
         // You can delete a scheduled run by passing the scheduled run object
         // or a scheduled run Id to the delete method
-        yield hatchet.schedule.delete(scheduledRun);
+        yield hatchet.schedules.delete(scheduledRun);
         // !!
         // ? List
         // You can list all scheduled runs by passing in a query object
-        const scheduledRunList = yield hatchet.schedule.list({
+        const scheduledRunList = yield hatchet.schedules.list({
             offset: 0,
             limit: 10,
         });

package/examples/sticky-worker-with-check.js

@@ -28,9 +28,9 @@ const workflow = {
                 // eslint-disable-next-line no-plusplus
                 for (let i = 0; i < count; i++) {
                     const result = yield ctx.spawnWorkflow(childWorkflow, {}, { sticky: true });
-                    results.push(result.result());
+                    results.push(result.output);
                     const result2 = yield ctx.spawnWorkflow(softChildWorkflow, {}, { sticky: true });
-                    results.push(result2.result());
+                    results.push(result2.output);
                 }
                 console.log('Spawned ', count, ' child workflows of each type');
                 console.log('Results:', yield Promise.all(results));

package/examples/sticky-worker.js

@@ -15,6 +15,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../sdk"));
 const workflow_1 = require("../workflow");
 const hatchet = sdk_1.default.init();
+// ❓ StickyWorker
 const workflow = {
     id: 'sticky-workflow',
     description: 'test',
@@ -35,9 +36,12 @@ const workflow = {
         },
     ],
 };
+// ‼️
+// ❓ StickyChild
 const childWorkflow = {
     id: 'child-sticky-workflow',
     description: 'test',
+    // 👀 Specify a sticky strategy when declaring the workflow
     sticky: workflow_1.StickyStrategy.HARD,
     steps: [
         {
@@ -58,6 +62,7 @@ const childWorkflow = {
         },
     ],
 };
+// ‼️
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker1 = yield hatchet.worker('sticky-worker-1');

package/index.d.ts

@@ -5,7 +5,6 @@ export * from './clients/worker';
 export * from './clients/rest';
 export * from './clients/admin';
 export * from './util/workflow-run-ref';
-export * from './v1/client/client';
-export * from './v1/client/worker';
+export * from './v1';
 export default Hatchet;
 export { Hatchet };

package/index.js

@@ -23,6 +23,5 @@ __exportStar(require("./clients/worker"), exports);
 __exportStar(require("./clients/rest"), exports);
 __exportStar(require("./clients/admin"), exports);
 __exportStar(require("./util/workflow-run-ref"), exports);
-__exportStar(require("./v1/client/client"), exports);
-__exportStar(require("./v1/client/worker"), exports);
+__exportStar(require("./v1"), exports);
 exports.default = client_1.HatchetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.0.0-alpha0",
+  "version": "1.0.0-alpha2",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -15,7 +15,7 @@
     "url": "https://github.com/hatchet-dev/hatchet-typescript.git"
   },
   "scripts": {
-    "build": "echo 'build hatchet sdk with `npn run tsc:build` to ensure it is not build during the publish step' && exit 0",
+    "build": "echo 'build hatchet sdk with `npm run tsc:build` to ensure it is not build during the publish step' && exit 0",
     "prepare": "npm run build",
     "dump-version": "node -e \"console.log('export const HATCHET_VERSION = \\'' + require('./package.json').version + '\\';');\" > src/version.ts",
     "tsc:build": "npm run dump-version && tsc && resolve-tspaths",

package/protoc/dispatcher/dispatcher.d.ts

@@ -130,6 +130,8 @@ export interface AssignedAction {
     workflowRunId: string;
     /** the get group key run id (optional) */
     getGroupKeyRunId: string;
+    /** task id */
+    taskId?: number;
     /** the job id */
     jobId: string;
     /** the job name */