@hatchet-dev/typescript-sdk 1.1.1 → 1.1.3

package/README.md

@@ -32,39 +32,7 @@ pnpm add @hatchet-dev/typescript-sdk
 
 ## Quick Start
 
-Here's a simple example of how to use the Hatchet TypeScript SDK:
-
-```typescript
-import { HatchetClient } from '@hatchet-dev/typescript-sdk';
-
-export const hatchet = HatchetClient.init();
-
-export type SimpleInput = {
-  Message: string;
-};
-
-export const simple = hatchet.task({
-  name: 'simple',
-  fn: (input: SimpleInput) => {
-    return {
-      TransformedMessage: input.Message.toLowerCase(),
-    };
-  },
-});
-
-async function main() {
-  const worker = await hatchet.worker('simple-worker', {
-    workflows: [simple],
-    slots: 100,
-  });
-
-  await worker.start();
-}
-
-if (require.main === module) {
-  main();
-}
-```
+For examples of how to use the Hatchet TypeScript SDK, including worker setup and task execution, please see our [official documentation](https://docs.hatchet.run/home/setup).
 
 ## Features
 

package/clients/worker/worker.d.ts

@@ -51,7 +51,7 @@ export declare class V0Worker {
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
     handleStartStepRun(action: Action): Promise<void>;
     handleStartGroupKeyRun(action: Action): Promise<void>;
-    getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any): StepActionEvent;
+    getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any, retryCount?: number): StepActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
     handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;

package/clients/worker/worker.js

@@ -346,13 +346,13 @@ class V0Worker {
                     this.logger.info(`Step run ${action.stepRunId} succeeded`);
                     try {
                         // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null);
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
                         yield this.client.dispatcher.sendStepActionEvent(event);
                     }
                     catch (actionEventError) {
                         this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
                         // send a failure event
-                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, false, actionEventError.message);
+                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, false, actionEventError.message, action.retryCount);
                         try {
                             yield this.client.dispatcher.sendStepActionEvent(failureEvent);
                         }
@@ -378,7 +378,7 @@ class V0Worker {
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, shouldNotRetry, {
                             message: error === null || error === void 0 ? void 0 : error.message,
                             stack: error === null || error === void 0 ? void 0 : error.stack,
-                        });
+                        }, action.retryCount);
                         yield this.client.dispatcher.sendStepActionEvent(event);
                     }
                     catch (e) {
@@ -403,7 +403,7 @@ class V0Worker {
                 }))());
                 this.futures[action.stepRunId] = future;
                 // Send the action event to the dispatcher
-                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false);
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
                 this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
                 });
@@ -489,7 +489,7 @@ class V0Worker {
             }
         });
     }
-    getStepActionEvent(action, eventType, shouldNotRetry, payload = '') {
+    getStepActionEvent(action, eventType, shouldNotRetry, payload = '', retryCount = 0) {
         return {
             workerId: this.name,
             jobId: action.jobId,
@@ -501,6 +501,7 @@ class V0Worker {
             eventType,
             eventPayload: JSON.stringify(payload),
             shouldNotRetry,
+            retryCount,
         };
     }
     getGroupKeyActionEvent(action, eventType, payload = '') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -32,42 +32,11 @@
     "eslint:fix": "eslint \"{src,tests}/**/*.{ts,tsx,js}\" --fix",
     "prettier:check": "prettier \"src/**/*.{ts,tsx}\" --list-different",
     "prettier:fix": "prettier \"src/**/*.{ts,tsx}\" --write",
-    "exec": "npx dotenv -- ts-node -r tsconfig-paths/register --project tsconfig.json",
-    "example:event": "npm run exec -- ./src/examples/example-event.ts",
-    "example:event-listen": "npm run exec -- ./src/examples/example-event-with-results.ts",
-    "worker:namespaced": "npm run exec -- ./src/examples/namespaced-worker.ts",
-    "worker:rate": "npm run exec -- ./src/examples/rate-limit/worker.ts",
-    "example:rate": "npm run exec -- ./src/examples/rate-limit/events.ts",
-    "worker:fanout": "npm run exec -- ./src/examples/fanout-worker.ts",
-    "worker:simple": "npm run exec -- ./src/examples/simple-worker.ts",
-    "worker:affinity": "npm run exec -- ./src/examples/affinity-workers.ts",
-    "worker:sticky": "npm run exec -- ./src/examples/sticky-worker.ts",
-    "worker:sticky-with-check": "npm run exec -- ./src/examples/sticky-worker-with-check.ts",
-    "trigger:sticky": "npm run exec -- ./src/examples/sticky-trigger.ts",
-    "worker:on-failure": "npm run exec -- ./src/examples/on-failure.ts",
-    "manual:trigger": "npm run exec -- ./src/examples/manual-trigger.ts",
-    "manual:meta": "npm run exec -- ./src/examples/stream-by-additional-meta.ts",
-    "bulk:trigger": "npm run exec -- ./src/examples/bulk-trigger.ts",
-    "bulk:fanout:worker": "npm run exec -- ./src/examples/bulk-fanout-worker.ts",
-    "bulk:fanout:trigger": "npm run exec -- ./src/examples/bulk-fanout-trigger.ts",
-    "worker:dag": "npm run exec -- ./src/examples/dag-worker.ts",
-    "worker:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-worker.ts",
-    "event:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-event.ts",
-    "worker:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-worker-expression.ts",
-    "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",
-    "worker:byo-logger": "npm run exec -- ./src/examples/byo-logger.ts",
-    "worker:no-retry": "npm run exec -- ./src/v1/examples/non_retryable/worker.ts",
-    "worker:no-retry:trigger": "npm run exec -- ./src/v1/examples/non_retryable/run.ts",
-    "api": "npm run exec -- ./src/examples/api.ts",
     "prepublish": "cp package.json dist/package.json; cp README.md dist/",
     "publish:ci": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
     "publish:ci:alpha": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
-    "generate-docs": "typedoc"
+    "generate-docs": "typedoc",
+    "exec": "npx dotenv -- ts-node -r tsconfig-paths/register --project tsconfig.json"
   },
   "keywords": [],
   "author": "",

package/step.js

@@ -413,10 +413,10 @@ class Context {
                 return resp;
             });
             try {
-                // Batch workflowRuns in groups of 500
+                const batchSize = 1000;
                 let resp = [];
-                for (let i = 0; i < workflowRuns.length; i += 500) {
-                    const batch = workflowRuns.slice(i, i + 500);
+                for (let i = 0; i < workflowRuns.length; i += batchSize) {
+                    const batch = workflowRuns.slice(i, i + batchSize);
                     const batchResp = yield this.client.admin.runWorkflows(batch);
                     resp = resp.concat(batchResp);
                 }

package/v1/client/client.d.ts

@@ -13,6 +13,7 @@ import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
 import { CreateStandaloneDurableTaskOpts } from '../task';
 import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } from '../types';
+import { RatelimitsClient } from './features';
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -159,6 +160,12 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A metrics client instance
      */
     get metrics(): MetricsClient;
+    private _ratelimits;
+    /**
+     * Get the rate limits client for creating and managing rate limits
+     * @returns A rate limits client instance
+     */
+    get ratelimits(): RatelimitsClient;
     private _runs;
     /**
      * Get the runs client for creating and managing runs
@@ -171,6 +178,11 @@ export declare class HatchetClient implements IHatchetClient {
      * @returns A workflows client instance
      */
     get workflows(): WorkflowsClient;
+    /**
+     * Get the tasks client for creating and managing tasks
+     * @returns A tasks client instance
+     */
+    get tasks(): WorkflowsClient;
     private _workers;
     /**
      * Get the workers client for creating and managing workers

package/v1/client/client.js

@@ -27,6 +27,7 @@ const metrics_1 = require("./features/metrics");
 const workers_1 = require("./features/workers");
 const workflows_1 = require("./features/workflows");
 const runs_1 = require("./features/runs");
+const features_1 = require("./features");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -210,6 +211,16 @@ class HatchetClient {
         }
         return this._metrics;
     }
+    /**
+     * Get the rate limits client for creating and managing rate limits
+     * @returns A rate limits client instance
+     */
+    get ratelimits() {
+        if (!this._ratelimits) {
+            this._ratelimits = new features_1.RatelimitsClient(this);
+        }
+        return this._ratelimits;
+    }
     /**
      * Get the runs client for creating and managing runs
      * @returns A runs client instance
@@ -230,6 +241,13 @@ class HatchetClient {
         }
         return this._workflows;
     }
+    /**
+     * Get the tasks client for creating and managing tasks
+     * @returns A tasks client instance
+     */
+    get tasks() {
+        return this.workflows;
+    }
     /**
      * Get the workers client for creating and managing workers
      * @returns A workers client instance

package/v1/client/features/runs.d.ts

@@ -3,7 +3,7 @@ import { V1TaskStatus } from '../../../clients/rest/generated/data-contracts';
 import { WorkflowsClient } from './workflows';
 import { HatchetClient } from '../client';
 export type RunFilter = {
-    since: Date;
+    since?: Date;
     until?: Date;
     statuses?: V1TaskStatus[];
     workflowNames?: string[];
@@ -17,6 +17,35 @@ export type ReplayRunOpts = {
     ids?: string[];
     filters?: RunFilter;
 };
+export interface ListRunsOpts extends RunFilter {
+    /**
+     * The number to skip
+     * @format int64
+     */
+    offset?: number;
+    /**
+     * The number to limit by
+     * @format int64
+     */
+    limit?: number;
+    /** A list of statuses to filter by */
+    /**
+     * The worker id to filter by
+     * @format uuid
+     * @minLength 36
+     * @maxLength 36
+     */
+    workerId?: string;
+    /** Whether to include DAGs or only to include tasks */
+    onlyTasks: boolean;
+    /**
+     * The parent task external id to filter by
+     * @format uuid
+     * @minLength 36
+     * @maxLength 36
+     */
+    parentTaskExternalId?: string;
+}
 /**
  * RunsClient is used to list and manage runs
  */
@@ -27,8 +56,9 @@ export declare class RunsClient {
     constructor(client: HatchetClient);
     get<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRun>;
     getDetails<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunShape>;
-    list(opts?: Parameters<typeof this.api.workflowRunList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunList>;
+    list(opts?: Partial<ListRunsOpts>): Promise<import("../../../clients/rest/generated/data-contracts").V1TaskSummaryList>;
     cancel(opts: CancelRunOpts): Promise<import("axios").AxiosResponse<void, any>>;
     replay(opts: ReplayRunOpts): Promise<import("axios").AxiosResponse<void, any>>;
     private prepareFilter;
+    private prepareListFilter;
 }

package/v1/client/features/runs.js

@@ -35,14 +35,13 @@ class RunsClient {
     }
     list(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO workflow id on opts is a uuid
-            const { data } = yield this.api.workflowRunList(this.tenantId, opts);
+            const { data } = yield this.api.v1WorkflowRunList(this.tenantId, Object.assign({}, (yield this.prepareListFilter(opts || {}))));
             return data;
         });
     }
     cancel(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filter = opts.filters && (yield this.prepareFilter(opts.filters));
+            const filter = yield this.prepareFilter(opts.filters || {});
             return this.api.v1TaskCancel(this.tenantId, {
                 externalIds: opts.ids,
                 filter,
@@ -51,7 +50,7 @@ class RunsClient {
     }
     replay(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const filter = opts.filters && (yield this.prepareFilter(opts.filters));
+            const filter = yield this.prepareFilter(opts.filters || {});
             return this.api.v1TaskReplay(this.tenantId, {
                 externalIds: opts.ids,
                 filter,
@@ -60,12 +59,32 @@ class RunsClient {
     }
     prepareFilter(_a) {
         return __awaiter(this, arguments, void 0, function* ({ since, until, statuses, workflowNames, additionalMetadata, }) {
+            const am = Object.entries(additionalMetadata || {}).map(([key, value]) => `${key}:${value}`);
             return {
-                since: since.toISOString(),
+                // default to 1 hour ago
+                since: since ? since.toISOString() : new Date(Date.now() - 1000 * 60 * 60).toISOString(),
                 until: until === null || until === void 0 ? void 0 : until.toISOString(),
                 statuses,
                 workflowIds: yield Promise.all((workflowNames === null || workflowNames === void 0 ? void 0 : workflowNames.map((name) => __awaiter(this, void 0, void 0, function* () { return (yield this.workflows.get(name)).metadata.id; }))) || []),
-                additionalMetadata: Object.entries(additionalMetadata || {}).map(([key, value]) => `${key}:${value}`),
+                additionalMetadata: am,
+            };
+        });
+    }
+    prepareListFilter(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const am = Object.entries(opts.additionalMetadata || {}).map(([key, value]) => `${key}:${value}`);
+            return {
+                // default to 1 hour ago
+                since: opts.since
+                    ? opts.since.toISOString()
+                    : new Date(Date.now() - 1000 * 60 * 60).toISOString(),
+                until: (_a = opts.until) === null || _a === void 0 ? void 0 : _a.toISOString(),
+                statuses: opts.statuses,
+                worker_id: opts.workerId,
+                workflow_ids: yield Promise.all(((_b = opts.workflowNames) === null || _b === void 0 ? void 0 : _b.map((name) => __awaiter(this, void 0, void 0, function* () { return (yield this.workflows.get(name)).metadata.id; }))) || []),
+                additional_metadata: am,
+                only_tasks: opts.onlyTasks || false,
             };
         });
     }

package/v1/examples/cancellations/workflow.d.ts

@@ -1,3 +1,4 @@
 export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
     Completed: true;
 }>;
+export declare const abortSignal: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void>;

package/v1/examples/cancellations/workflow.js

@@ -12,11 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cancellation = void 0;
-// ❓ Declaring a Task
+exports.abortSignal = exports.cancellation = void 0;
 const sleep_1 = __importDefault(require("../../../util/sleep"));
+const axios_1 = __importDefault(require("axios"));
 const hatchet_client_1 = require("../hatchet-client");
-// (optional) Define the input type for the workflow
+// ❓ Declaring a Task
 exports.cancellation = hatchet_client_1.hatchet.task({
     name: 'cancellation',
     fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { cancelled }) {
@@ -30,4 +30,26 @@ exports.cancellation = hatchet_client_1.hatchet.task({
     }),
 });
 // !!
+// ❓ Abort Signal
+exports.abortSignal = hatchet_client_1.hatchet.task({
+    name: 'abort-signal',
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { controller }) {
+        try {
+            const response = yield axios_1.default.get('https://api.example.com/data', {
+                signal: controller.signal,
+            });
+            // Handle the response
+        }
+        catch (error) {
+            if (axios_1.default.isCancel(error)) {
+                // Request was canceled
+                console.log('Request canceled');
+            }
+            else {
+                // Handle other errors
+            }
+        }
+    }),
+});
+// !!
 // see ./worker.ts and ./run.ts for how to run the workflow

package/v1/examples/child_workflows/worker.js

@@ -15,6 +15,7 @@ function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const worker = yield hatchet_client_1.hatchet.worker('child-workflow-worker', {
             workflows: [workflow_1.parent, workflow_1.child],
+            slots: 100,
         });
         yield worker.start();
     });

package/v1/examples/dag_match_condition/complex-workflow.d.ts

@@ -0,0 +1 @@
+export declare const taskConditionWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;

package/v1/examples/dag_match_condition/complex-workflow.js

@@ -0,0 +1,107 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskConditionWorkflow = void 0;
+// ❓ Create a workflow
+const conditions_1 = require("../../conditions");
+const parent_condition_1 = require("../../conditions/parent-condition");
+const hatchet_client_1 = require("../hatchet-client");
+exports.taskConditionWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'TaskConditionWorkflow',
+});
+// !!
+// ❓ Add base task
+const start = exports.taskConditionWorkflow.task({
+    name: 'start',
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// ❓ Add wait for sleep
+const waitForSleep = exports.taskConditionWorkflow.task({
+    name: 'waitForSleep',
+    parents: [start],
+    waitFor: [new conditions_1.SleepCondition('10s')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// ❓ Add skip on event
+const skipOnEvent = exports.taskConditionWorkflow.task({
+    name: 'skipOnEvent',
+    parents: [start],
+    waitFor: [new conditions_1.SleepCondition('10s')],
+    skipIf: [new conditions_1.UserEventCondition('skip_on_event:skip', 'true')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// ❓ Add branching
+const leftBranch = exports.taskConditionWorkflow.task({
+    name: 'leftBranch',
+    parents: [waitForSleep],
+    skipIf: [new parent_condition_1.ParentCondition(waitForSleep, 'output.randomNumber > 50')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+const rightBranch = exports.taskConditionWorkflow.task({
+    name: 'rightBranch',
+    parents: [waitForSleep],
+    skipIf: [new parent_condition_1.ParentCondition(waitForSleep, 'output.randomNumber <= 50')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// ❓ Add wait for event
+const waitForEvent = exports.taskConditionWorkflow.task({
+    name: 'waitForEvent',
+    parents: [start],
+    waitFor: [(0, conditions_1.Or)(new conditions_1.SleepCondition('1m'), new conditions_1.UserEventCondition('wait_for_event:start', 'true'))],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// ❓ Add sum
+exports.taskConditionWorkflow.task({
+    name: 'sum',
+    parents: [start, waitForSleep, waitForEvent, skipOnEvent, leftBranch, rightBranch],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const one = (yield ctx.parentOutput(start)).randomNumber;
+        const two = (yield ctx.parentOutput(waitForEvent)).randomNumber;
+        const three = (yield ctx.parentOutput(waitForSleep)).randomNumber;
+        const four = ((_a = (yield ctx.parentOutput(skipOnEvent))) === null || _a === void 0 ? void 0 : _a.randomNumber) || 0;
+        const five = ((_b = (yield ctx.parentOutput(leftBranch))) === null || _b === void 0 ? void 0 : _b.randomNumber) || 0;
+        const six = ((_c = (yield ctx.parentOutput(rightBranch))) === null || _c === void 0 ? void 0 : _c.randomNumber) || 0;
+        return {
+            sum: one + two + three + four + five + six,
+        };
+    }),
+});
+// !!

package/v1/examples/{rate_limit/run.js → durable-event/event.js}

@@ -9,21 +9,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
-const workflow_1 = require("./workflow");
+const hatchet_client_1 = require("../hatchet-client");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const res = yield workflow_1.rateLimitWorkflow.run({ userId: 'abc' });
-            console.log(res);
-        }
-        catch (e) {
-            console.log('error', e);
-        }
+        const event = yield hatchet_client_1.hatchet.events.push('user:update', {
+            userId: '1234',
+        });
     });
 }
 if (require.main === module) {
     main()
-        .catch(console.error)
-        .finally(() => process.exit(0));
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
 }

package/v1/examples/durable-event/run.js

@@ -0,0 +1,30 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeStart = Date.now();
+        const res = yield workflow_1.durableEvent.run({});
+        const timeEnd = Date.now();
+        // eslint-disable-next-line no-console
+        console.log(`Time taken: ${timeEnd - timeStart}ms`);
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

package/v1/examples/durable-event/worker.d.ts

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

package/v1/examples/{rate_limit → durable-event}/worker.js

@@ -13,8 +13,8 @@ const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield hatchet_client_1.hatchet.worker('rate-limit-worker', {
-            workflows: [workflow_1.rateLimitWorkflow],
+        const worker = yield hatchet_client_1.hatchet.worker('durable-event-worker', {
+            workflows: [workflow_1.durableEvent],
         });
         yield worker.start();
     });

package/v1/examples/durable-event/workflow.d.ts

@@ -0,0 +1,6 @@
+export declare const durableEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    Value: string;
+}>;
+export declare const durableEventWithFilter: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    Value: string;
+}>;

package/v1/examples/durable-event/workflow.js

@@ -0,0 +1,46 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.durableEventWithFilter = exports.durableEvent = void 0;
+// import sleep from '../../../util/sleep.js';
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Durable Event
+exports.durableEvent = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-event',
+    executionTimeout: '10m',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = ctx.waitFor({
+            eventKey: 'user:update',
+        });
+        console.log('res', res);
+        return {
+            Value: 'done',
+        };
+    }),
+});
+// !!
+exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-event-with-filter',
+    executionTimeout: '10m',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // ❓ Durable Event With Filter
+        const res = ctx.waitFor({
+            eventKey: 'user:update',
+            expression: "input.userId == '1234'",
+        });
+        // !!
+        console.log('res', res);
+        return {
+            Value: 'done',
+        };
+    }),
+});
+// !!

package/v1/examples/durable-sleep/workflow.js

@@ -11,11 +11,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.durableSleep = void 0;
 // import sleep from '../../../util/sleep.js';
-const conditions_1 = require("../../conditions");
 const hatchet_client_1 = require("../hatchet-client");
 exports.durableSleep = hatchet_client_1.hatchet.workflow({
     name: 'durable-sleep',
 });
+// ❓ Durable Sleep
 exports.durableSleep.durableTask({
     name: 'durable-sleep',
     executionTimeout: '10m',
@@ -23,15 +23,9 @@ exports.durableSleep.durableTask({
         console.log('sleeping for 5s');
         const sleepRes = yield ctx.sleepFor('5s');
         console.log('done sleeping for 5s', sleepRes);
-        // wait for either an event or a sleep
-        const res = yield ctx.waitFor((0, conditions_1.Or)({
-            eventKey: 'user:event',
-        }, {
-            sleepFor: '1m',
-        }));
-        console.log('res', res);
         return {
             Value: 'done',
         };
     }),
 });
+// !!

package/v1/examples/on_event/event.js

@@ -10,10 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const hatchet_client_1 = require("../hatchet-client");
-const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const res = yield hatchet_client_1.hatchet.events.push(workflow_1.SIMPLE_EVENT, {
+        // ❓ Pushing an Event
+        const res = yield hatchet_client_1.hatchet.events.push('simple-event:create', {
             Message: 'hello',
         });
         // !!

package/v1/examples/on_event/workflow.js

@@ -6,10 +6,8 @@ exports.SIMPLE_EVENT = 'simple-event:create';
 // ❓ Run workflow on event
 exports.lower = hatchet_client_1.hatchet.workflow({
     name: 'lower',
-    on: {
-        // 👀 Declare the event that will trigger the workflow
-        event: exports.SIMPLE_EVENT,
-    },
+    // 👀 Declare the event that will trigger the workflow
+    onEvents: ['simple-event:create'],
 });
 // !!
 exports.lower.task({

package/v1/examples/rate_limit/workflow.d.ts

@@ -1,5 +1 @@
-type RateLimitInput = {
-    userId: string;
-};
-export declare const rateLimitWorkflow: import("../..").WorkflowDeclaration<RateLimitInput, {}>;
 export {};

package/v1/examples/rate_limit/workflow.js

@@ -1,29 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateLimitWorkflow = void 0;
 const workflows_1 = require("../../../protoc/v1/workflows");
 const hatchet_client_1 = require("../hatchet-client");
-exports.rateLimitWorkflow = hatchet_client_1.hatchet.workflow({
-    name: 'RateLimitWorkflow',
+// ❓ Upsert Rate Limit
+hatchet_client_1.hatchet.ratelimits.upsert({
+    key: 'api-service-rate-limit',
+    limit: 10,
+    duration: workflows_1.RateLimitDuration.SECOND,
 });
 // !!
 // ❓ Static
-const RATE_LIMIT_KEY = 'test-limit';
-const task1 = exports.rateLimitWorkflow.task({
+const RATE_LIMIT_KEY = 'api-service-rate-limit';
+const task1 = hatchet_client_1.hatchet.task({
     name: 'task1',
-    fn: (input) => {
-        console.log('executed task1');
-    },
     rateLimits: [
         {
             staticKey: RATE_LIMIT_KEY,
             units: 1,
         },
     ],
+    fn: (input) => {
+        console.log('executed task1');
+    },
 });
 // !!
 // ❓ Dynamic
-const task2 = exports.rateLimitWorkflow.task({
+const task2 = hatchet_client_1.hatchet.task({
     name: 'task2',
     fn: (input) => {
         console.log('executed task2 for user: ', input.userId);

package/v1/examples/simple/cron.js

@@ -22,7 +22,16 @@ function main() {
         // !!
         // eslint-disable-next-line no-console
         console.log(cron.metadata.id);
-        yield hatchet_client_1.hatchet.crons.delete(cron);
+        // ❓ Delete
+        yield hatchet_client_1.hatchet.crons.delete(cronId);
+        // !!
+        // ❓ List
+        const crons = yield hatchet_client_1.hatchet.crons.list({
+            workflowId: workflow_1.simple.id,
+        });
+        // !!
+        // eslint-disable-next-line no-console
+        console.log(crons);
     });
 }
 if (require.main === module) {

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.1.1";
+export declare const HATCHET_VERSION = "1.1.3";

package/version.js

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