@hatchet-dev/typescript-sdk 1.19.2-alpha.3 → 1.20.1

package/v1/conditions/user-event-condition.d.ts

@@ -20,6 +20,14 @@ export interface UserEvent {
      * If not specified, the eventKey will be used as the default identifier.
      */
     readableDataKey?: string;
+    /**
+     An optional scope to filter events. If provided, only events with a matching scope will be considered when looking for matches. This is required if `lookback_window` is provided (if you wish to consider events that were pushed before the wait was established as valid).
+    */
+    scope?: string;
+    /**
+    An optional ISO-formatted date string indicating how far back to look for matching events when the condition is first evaluated.
+     */
+    considerEventsSince?: string;
 }
 /**
  * Represents a condition that is triggered based on a specific user event.
@@ -46,5 +54,7 @@ export interface UserEvent {
 export declare class UserEventCondition extends Condition {
     eventKey: string;
     expression: string;
-    constructor(eventKey: string, expression: string, readableDataKey?: string, action?: Action);
+    scope?: string;
+    considerEventsSince?: string;
+    constructor(eventKey: string, expression: string, readableDataKey?: string, action?: Action, scope?: string, considerEventsSince?: string);
 }

package/v1/conditions/user-event-condition.js

@@ -25,7 +25,7 @@ const base_1 = require("./base");
  * );
  */
 class UserEventCondition extends base_1.Condition {
-    constructor(eventKey, expression, readableDataKey, action) {
+    constructor(eventKey, expression, readableDataKey, action, scope, considerEventsSince) {
         super({
             readableDataKey: readableDataKey || eventKey,
             action,
@@ -34,6 +34,8 @@ class UserEventCondition extends base_1.Condition {
         });
         this.eventKey = eventKey;
         this.expression = expression;
+        this.scope = scope;
+        this.considerEventsSince = considerEventsSince;
     }
 }
 exports.UserEventCondition = UserEventCondition;

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

@@ -52,6 +52,25 @@ export declare const durableReplayReset: import("../..").TaskWorkflowDeclaration
     sleep_2_duration: number;
     sleep_3_duration: number;
 }, {}, {}, {}, {}>;
+export declare const LOOKBACK_WINDOW: "1m";
+export declare const waitForEventLookback: import("../..").TaskWorkflowDeclaration<{
+    scope: string;
+}, {
+    elapsed: number;
+    event: any;
+}, {}, {}, {}, {}>;
+export declare const waitForOrEventLookback: import("../..").TaskWorkflowDeclaration<{
+    scope: string;
+}, {
+    elapsed: number;
+}, {}, {}, {}, {}>;
+export declare const waitForTwoEventsSecondPushedFirst: import("../..").TaskWorkflowDeclaration<{
+    scope: string;
+}, {
+    elapsed: number;
+    event1: any;
+    event2: any;
+}, {}, {}, {}, {}>;
 export declare const memoNowCaching: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
     start_time: string;
 }, {}, {}, {}, {}>;

package/v1/examples/durable/workflow.js

@@ -12,10 +12,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.durableSpawnDag = exports.dagChildWorkflow = exports.memoNowCaching = exports.durableReplayReset = exports.REPLAY_RESET_MEMOIZED_MAX_SECONDS = exports.REPLAY_RESET_SLEEP_SECONDS = exports.durableNonDeterminism = exports.durableWithExplicitSpawn = exports.durableSleepEventSpawn = exports.durableWithBulkSpawn = exports.durableWithSpawn = exports.spawnChildTask = exports.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
+exports.durableSpawnDag = exports.dagChildWorkflow = exports.memoNowCaching = exports.waitForTwoEventsSecondPushedFirst = exports.waitForOrEventLookback = exports.waitForEventLookback = exports.LOOKBACK_WINDOW = exports.durableReplayReset = exports.REPLAY_RESET_MEMOIZED_MAX_SECONDS = exports.REPLAY_RESET_SLEEP_SECONDS = exports.durableNonDeterminism = exports.durableWithExplicitSpawn = exports.durableSleepEventSpawn = exports.durableWithBulkSpawn = exports.durableWithSpawn = exports.spawnChildTask = exports.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
 const conditions_1 = require("../../conditions");
 const non_determinism_error_1 = require("../../../util/errors/non-determinism-error");
 const sleep_1 = __importDefault(require("../../../util/sleep"));
+const duration_1 = require("../../client/duration");
 const hatchet_client_1 = require("../hatchet-client");
 exports.EVENT_KEY = 'durable-example:event';
 exports.SLEEP_TIME_SECONDS = 2;
@@ -223,6 +224,46 @@ exports.durableReplayReset = hatchet_client_1.hatchet.durableTask({
         };
     }),
 });
+exports.LOOKBACK_WINDOW = '1m';
+exports.waitForEventLookback = hatchet_client_1.hatchet.durableTask({
+    name: 'wait-for-event-lookback',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        const event = yield ctx.waitForEvent(exports.EVENT_KEY, undefined, undefined, input.scope, exports.LOOKBACK_WINDOW);
+        return {
+            elapsed: (Date.now() - start) / 1000,
+            event,
+        };
+    }),
+});
+exports.waitForOrEventLookback = hatchet_client_1.hatchet.durableTask({
+    name: 'wait-for-or-event-lookback',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        const now = yield ctx.now();
+        const considerEventsSince = new Date(now.getTime() - (0, duration_1.durationToMs)(exports.LOOKBACK_WINDOW)).toISOString();
+        yield ctx.waitFor((0, conditions_1.Or)(new conditions_1.SleepCondition(exports.SLEEP_TIME), new conditions_1.UserEventCondition(exports.EVENT_KEY, '', undefined, undefined, input.scope, considerEventsSince)));
+        return {
+            elapsed: (Date.now() - start) / 1000,
+        };
+    }),
+});
+exports.waitForTwoEventsSecondPushedFirst = hatchet_client_1.hatchet.durableTask({
+    name: 'wait-for-two-events-second-pushed-first',
+    executionTimeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        const event1 = yield ctx.waitForEvent('key1', undefined, undefined, input.scope, exports.LOOKBACK_WINDOW);
+        const event2 = yield ctx.waitForEvent('key2', undefined, undefined, input.scope, exports.LOOKBACK_WINDOW);
+        return {
+            elapsed: (Date.now() - start) / 1000,
+            event1,
+            event2,
+        };
+    }),
+});
 exports.memoNowCaching = hatchet_client_1.hatchet.durableTask({
     name: 'memo-now-caching',
     executionTimeout: '10m',

package/v1/examples/e2e-worker.js

@@ -64,6 +64,9 @@ const workflows = [
     workflow_8.durableReplayReset,
     workflow_8.dagChildWorkflow,
     workflow_8.durableSpawnDag,
+    workflow_8.waitForEventLookback,
+    workflow_8.waitForOrEventLookback,
+    workflow_8.waitForTwoEventsSecondPushedFirst,
     workflow_9.durableEvent,
     workflow_9.durableEventWithFilter,
     workflow_11.durableSleep,

package/v1/parent-run-context-vars.d.ts

@@ -22,8 +22,6 @@ export declare class ParentRunContextManager {
     private storage;
     constructor();
     runWithContext<T>(opts: ParentRunContext, fn: () => T): T;
-    setContext(opts: ParentRunContext): void;
-    setParentRunIdAndIncrementChildIndex(opts: ParentRunContext): void;
     incrementChildIndex(n: number): void;
     getContext(): ParentRunContext | undefined;
 }

package/v1/parent-run-context-vars.js

@@ -9,28 +9,15 @@ class ParentRunContextManager {
     runWithContext(opts, fn) {
         return this.storage.run(Object.assign({}, opts), fn);
     }
-    setContext(opts) {
-        this.storage.enterWith(Object.assign({}, opts));
-    }
-    setParentRunIdAndIncrementChildIndex(opts) {
-        var _a;
-        const parentRunContext = this.getContext();
-        if (parentRunContext) {
-            parentRunContext.parentId = opts.parentId;
-            parentRunContext.parentTaskRunExternalId = opts.parentTaskRunExternalId;
-            parentRunContext.childIndex = ((_a = parentRunContext.childIndex) !== null && _a !== void 0 ? _a : 0) + 1;
-            this.setContext(parentRunContext);
-        }
-    }
     incrementChildIndex(n) {
         var _a;
         const parentRunContext = this.getContext();
         if (parentRunContext) {
-            // Mutate in place — do NOT use enterWith/setContext here.
+            // Mutate in place — do NOT use enterWith here.
             // storage.run() gives every async descendant the same object reference,
             // so direct mutation is visible across all await boundaries within the
-            // same task execution.  enterWith would create a new object whose
-            // updates are invisible to parent async contexts after an await.
+            // same task execution.  enterWith would replace the object, and the new
+            // object's updates would be invisible to parent async contexts after an await.
             parentRunContext.childIndex = ((_a = parentRunContext.childIndex) !== null && _a !== void 0 ? _a : 0) + n;
         }
     }

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.19.2-alpha.3";
+export declare const HATCHET_VERSION = "1.20.1";

package/version.js

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