@hatchet-dev/typescript-sdk 1.1.2 → 1.1.5

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "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

@@ -178,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

@@ -241,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,37 +35,56 @@ 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,
+                filter: !opts.ids ? filter : undefined,
             });
         });
     }
     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,
+                filter: !opts.ids ? filter : undefined,
             });
         });
     }
     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/run.js

@@ -21,15 +21,18 @@ const hatchet_client_1 = require("../hatchet-client");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const run = workflow_1.cancellation.runNoWait({});
+        const run1 = workflow_1.cancellation.runNoWait({});
         yield (0, sleep_1.default)(1000);
         yield run.cancel();
         const res = yield run.output;
-        console.log(res);
+        const res1 = yield run1.output;
+        console.log('canceled', res);
+        console.log('completed', res1);
         yield (0, sleep_1.default)(1000);
         yield run.replay();
         const resReplay = yield run.output;
         console.log(resReplay);
-        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
         const run4 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
         yield (0, sleep_1.default)(1000);
         yield hatchet_client_1.hatchet.runs.cancel({

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/durable-event/event.d.ts

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

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

@@ -0,0 +1,28 @@
+"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 hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const event = yield hatchet_client_1.hatchet.events.push('user:update', {
+            userId: '1234',
+        });
+    });
+}
+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/run.d.ts

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

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/durable-event/worker.js

@@ -0,0 +1,24 @@
+"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 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('durable-event-worker', {
+            workflows: [workflow_1.durableEvent],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.1.2";
+export declare const HATCHET_VERSION = "1.1.5";

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.2';
+exports.HATCHET_VERSION = '1.1.5';