@hatchet-dev/typescript-sdk 1.0.0-alpha1 → 1.0.0

package/v1/conditions/index.js

@@ -0,0 +1,91 @@
+"use strict";
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-shadow */
+/* eslint-disable max-classes-per-file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrCondition = exports.UserEventCondition = exports.SleepCondition = void 0;
+exports.Render = Render;
+exports.Or = Or;
+exports.generateGroupId = generateGroupId;
+const base_1 = require("./base");
+const parent_condition_1 = require("./parent-condition");
+const sleep_condition_1 = require("./sleep-condition");
+Object.defineProperty(exports, "SleepCondition", { enumerable: true, get: function () { return sleep_condition_1.SleepCondition; } });
+const user_event_condition_1 = require("./user-event-condition");
+Object.defineProperty(exports, "UserEventCondition", { enumerable: true, get: function () { return user_event_condition_1.UserEventCondition; } });
+class OrCondition {
+    constructor(conditions) {
+        this.conditions = conditions;
+    }
+}
+exports.OrCondition = OrCondition;
+/**
+ * Creates a condition that waits for all provided conditions to be met (AND logic)
+ * use Or() to create a condition that waits for any of the provided conditions to be met (OR logic)
+ * @param conditions - Conditions or OrConditions to be rendered
+ * @returns A flattened array of Conditions
+ *
+ * @example
+ * const conditions = Render(
+ *   Or({ sleepFor: 5 }, { eventKey: 'user:update' }),
+ *   { eventKey: 'user:create' },
+ *   Or({ eventKey: 'user:update' }, { eventKey: 'user:delete' })
+ * );
+ */
+function Render(action, conditions) {
+    if (!conditions)
+        return [];
+    if (!Array.isArray(conditions)) {
+        return Render(action, [conditions]);
+    }
+    const renderedConditions = conditions.reduce((acc, conditionOrObj) => {
+        if (conditionOrObj instanceof base_1.Condition) {
+            return [...acc, conditionOrObj];
+        }
+        if (conditionOrObj instanceof OrCondition) {
+            return [...acc, ...Render(action, conditionOrObj.conditions)];
+        }
+        // Handle object syntax
+        if ('sleepFor' in conditionOrObj) {
+            return [...acc, new sleep_condition_1.SleepCondition(conditionOrObj.sleepFor, undefined, action)];
+        }
+        if ('eventKey' in conditionOrObj) {
+            return [
+                ...acc,
+                new user_event_condition_1.UserEventCondition(conditionOrObj.eventKey, conditionOrObj.expression || '', undefined, action),
+            ];
+        }
+        if ('parent' in conditionOrObj) {
+            return [
+                ...acc,
+                new parent_condition_1.ParentCondition(conditionOrObj.parent, conditionOrObj.expression || '', undefined, action),
+            ];
+        }
+        throw new Error(`Unknown condition object: ${JSON.stringify(conditionOrObj)}`);
+    }, []);
+    // set the action for each condition
+    return renderedConditions.filter((condition) => {
+        if (condition instanceof base_1.Condition) {
+            condition.base.action = action;
+        }
+        return condition;
+    });
+}
+/**
+ * Creates a condition group with OR logic
+ * Flattens nested Or conditions to ensure proper grouping
+ */
+function Or(...conditionsOrObjs) {
+    // must be Condition[] because OrCondition is not a Condition
+    const conditions = Render(undefined, conditionsOrObjs);
+    const orGroupId = generateGroupId();
+    conditions.forEach((condition) => {
+        if (condition instanceof base_1.Condition) {
+            condition.base.orGroupId = orGroupId;
+        }
+    });
+    return new OrCondition(conditions);
+}
+function generateGroupId() {
+    return crypto.randomUUID ? crypto.randomUUID() : `or-${Date.now()}-${Math.random()}`;
+}

package/v1/conditions/parent-condition.d.ts

@@ -0,0 +1,40 @@
+import { Condition, Action } from './base';
+import { CreateWorkflowTaskOpts } from '../task';
+export interface Parent {
+    /**
+     * The parent workflow task this condition is associated with.
+     * This establishes a relationship between this condition and a specific workflow task.
+     */
+    parent: CreateWorkflowTaskOpts<any, any>;
+    /**
+     * Optional CEL expression to evaluate against the parent task's data.
+     * When provided, the condition will only trigger if this expression evaluates to true.
+     * @example "input.status == 'completed'", "input.result > 0"
+     */
+    expression?: string;
+}
+/**
+ * Represents a condition that is triggered based on a parent workflow task.
+ * This condition monitors the specified parent task and evaluates
+ * any provided expression against the task's data.
+ *
+ * @example
+ * // Create a condition that triggers when a parent task completes successfully
+ * const parentCondition = new ParentCondition(
+ *   parentTaskOpts,
+ *   "input.status == 'success'",
+ *   () => console.log("Parent task completed successfully!")
+ * );
+ */
+export declare class ParentCondition extends Condition {
+    /** The parent workflow task this condition is associated with */
+    parent: CreateWorkflowTaskOpts<any, any>;
+    /**
+     * Creates a new condition that is triggered based on a parent workflow task.
+     *
+     * @param parent The parent workflow task this condition is associated with
+     * @param expression Optional CEL expression to evaluate against the parent task's data
+     * @param action Optional action to execute when the condition is met
+     */
+    constructor(parent: CreateWorkflowTaskOpts<any, any>, expression?: string, readableDataKey?: string, action?: Action);
+}

package/v1/conditions/parent-condition.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParentCondition = void 0;
+const base_1 = require("./base");
+/**
+ * Represents a condition that is triggered based on a parent workflow task.
+ * This condition monitors the specified parent task and evaluates
+ * any provided expression against the task's data.
+ *
+ * @example
+ * // Create a condition that triggers when a parent task completes successfully
+ * const parentCondition = new ParentCondition(
+ *   parentTaskOpts,
+ *   "input.status == 'success'",
+ *   () => console.log("Parent task completed successfully!")
+ * );
+ */
+class ParentCondition extends base_1.Condition {
+    /**
+     * Creates a new condition that is triggered based on a parent workflow task.
+     *
+     * @param parent The parent workflow task this condition is associated with
+     * @param expression Optional CEL expression to evaluate against the parent task's data
+     * @param action Optional action to execute when the condition is met
+     */
+    constructor(parent, expression, readableDataKey, action) {
+        super({
+            readableDataKey: readableDataKey || `parent-${parent.name || Date.now().toString()}`,
+            action,
+            orGroupId: '',
+            expression: expression || '',
+        });
+        this.parent = parent;
+    }
+}
+exports.ParentCondition = ParentCondition;

package/v1/conditions/sleep-condition.d.ts

@@ -0,0 +1,47 @@
+import { Duration } from '../client/duration';
+import { Condition, Action } from './base';
+export interface Sleep {
+    /**
+     * Amount of time to sleep for.
+     * Specifies how long this condition should wait before proceeding.
+     * Uses Go duration string format.
+     *
+     * @example "10s", "1m", "1m5s", "24h"
+     */
+    sleepFor: Duration;
+    /**
+     * Optional unique identifier for the sleep condition in the readable stream.
+     * When multiple conditions have the same sleep duration,
+     * using a custom readableDataKey prevents duplicate data processing
+     * by differentiating between the conditions in the data store.
+     * If not specified, a default identifier based on the sleep duration will be used.
+     */
+    readableDataKey?: string;
+}
+/**
+ * Represents a condition that waits for a specified duration before proceeding.
+ * This condition is useful for implementing time delays in workflows.
+ *
+ * @example
+ * // Create a condition that waits for 5 minutes
+ * const waitCondition = new SleepCondition(
+ *   "5m",
+ *   "reminder_delay",
+ *   () => console.log("Wait period completed!")
+ * );
+ */
+export declare class SleepCondition extends Condition {
+    /** The duration to sleep for in Go duration string format */
+    sleepFor: Duration;
+    /**
+     * Creates a new sleep condition that waits for the specified duration.
+     *
+     * @param sleepFor Duration to wait in Go duration string format (e.g., "30s", "5m")
+     * @param readableDataKey Optional unique identifier for the condition data.
+     *                        When multiple sleep conditions have the same duration, using a custom
+     *                        readableDataKey prevents duplicate data by differentiating between them.
+     *                        If not provided, defaults to `sleep-${sleepFor}`.
+     * @param action Optional action to execute when the sleep duration completes
+     */
+    constructor(sleepFor: Duration, readableDataKey?: string, action?: Action);
+}

package/v1/conditions/sleep-condition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SleepCondition = void 0;
+const base_1 = require("./base");
+/**
+ * Represents a condition that waits for a specified duration before proceeding.
+ * This condition is useful for implementing time delays in workflows.
+ *
+ * @example
+ * // Create a condition that waits for 5 minutes
+ * const waitCondition = new SleepCondition(
+ *   "5m",
+ *   "reminder_delay",
+ *   () => console.log("Wait period completed!")
+ * );
+ */
+class SleepCondition extends base_1.Condition {
+    /**
+     * Creates a new sleep condition that waits for the specified duration.
+     *
+     * @param sleepFor Duration to wait in Go duration string format (e.g., "30s", "5m")
+     * @param readableDataKey Optional unique identifier for the condition data.
+     *                        When multiple sleep conditions have the same duration, using a custom
+     *                        readableDataKey prevents duplicate data by differentiating between them.
+     *                        If not provided, defaults to `sleep-${sleepFor}`.
+     * @param action Optional action to execute when the sleep duration completes
+     */
+    constructor(sleepFor, readableDataKey, action) {
+        super({
+            readableDataKey: readableDataKey || `sleep-${sleepFor}`,
+            action,
+            orGroupId: '',
+            expression: '',
+        });
+        this.sleepFor = sleepFor;
+    }
+}
+exports.SleepCondition = SleepCondition;

package/v1/conditions/transformer.d.ts

@@ -0,0 +1,5 @@
+import { TaskConditions } from '../../protoc/v1/shared/condition';
+import { CreateWorkflowTaskOpts } from '../task';
+import { Condition } from './base';
+export declare function taskConditionsToPb(task: Omit<CreateWorkflowTaskOpts<any, any>, 'fn'>): TaskConditions;
+export declare function conditionsToPb(conditions: Condition[]): TaskConditions;

package/v1/conditions/transformer.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskConditionsToPb = taskConditionsToPb;
+exports.conditionsToPb = conditionsToPb;
+const _1 = require(".");
+const base_1 = require("./base");
+const parent_condition_1 = require("./parent-condition");
+function taskConditionsToPb(task) {
+    const waitForConditions = (0, _1.Render)(base_1.Action.QUEUE, task.waitFor);
+    const cancelIfConditions = (0, _1.Render)(base_1.Action.CANCEL, task.cancelIf);
+    const skipIfConditions = (0, _1.Render)(base_1.Action.SKIP, task.skipIf);
+    const mergedConditions = [...waitForConditions, ...cancelIfConditions, ...skipIfConditions];
+    return conditionsToPb(mergedConditions);
+}
+function conditionsToPb(conditions) {
+    const parentOverrideConditions = [];
+    const sleepConditions = [];
+    const userEventConditions = [];
+    conditions.forEach((condition) => {
+        if (condition instanceof _1.SleepCondition) {
+            sleepConditions.push({
+                base: baseToPb(condition.base),
+                sleepFor: condition.sleepFor,
+            });
+        }
+        else if (condition instanceof _1.UserEventCondition) {
+            userEventConditions.push({
+                base: Object.assign(Object.assign({}, baseToPb(condition.base)), { expression: condition.expression || '' }),
+                userEventKey: condition.eventKey,
+            });
+        }
+        else if (condition instanceof parent_condition_1.ParentCondition) {
+            parentOverrideConditions.push({
+                base: baseToPb(condition.base),
+                parentReadableId: condition.parent.name,
+            });
+        }
+    });
+    return {
+        parentOverrideConditions,
+        sleepConditions,
+        userEventConditions,
+    };
+}
+function baseToPb(base) {
+    return {
+        readableDataKey: base.readableDataKey || '',
+        action: base.action,
+        orGroupId: base.orGroupId || (0, _1.generateGroupId)(),
+        expression: base.expression || '',
+    };
+}

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

@@ -0,0 +1,50 @@
+import { Condition, Action } from './base';
+export interface UserEvent {
+    /**
+     * The unique key identifying the specific user event to monitor.
+     * This should match the event key that will be emitted from your application.
+     * @example "button:clicked", "page:viewed", "form:submitted"
+     */
+    eventKey: string;
+    /**
+     * Optional CEL expression to evaluate against the event data.
+     * When provided, the condition will only trigger if this expression evaluates to true.
+     * @example "input.quantity > 5", "input.status == 'completed'"
+     */
+    expression?: string;
+    /**
+     * Optional unique identifier for the event data in the readable stream.
+     * When multiple conditions are listening to the same event type,
+     * using a custom readableDataKey prevents duplicate data processing
+     * by differentiating between the conditions in the data store.
+     * If not specified, the eventKey will be used as the default identifier.
+     */
+    readableDataKey?: string;
+}
+/**
+ * Represents a condition that is triggered based on a specific user event.
+ * This condition monitors for events with the specified key and evaluates
+ * any provided expression against the event data.
+ *
+ * @param eventKey The key identifying the specific user event to monitor
+ * @param expression The CEL expression to evaluate against the event data
+ * @param readableDataKey Optional parameter that provides a unique identifier for the data.
+ *                        When multiple conditions are listening to the same event, using a custom
+ *                        readableDataKey prevents duplicate data by differentiating between the conditions.
+ *                        If not provided, defaults to the eventKey.
+ * @param action Optional action to execute when the condition is met
+ *
+ * @example
+ * // Create a condition that triggers when a "purchase" event occurs with amount > 100
+ * const purchaseCondition = new UserEventCondition(
+ *   "purchase",
+ *   "data.amount > 100",
+ *   "high_value_purchase",
+ *   () => console.log("High value purchase detected!")
+ * );
+ */
+export declare class UserEventCondition extends Condition {
+    eventKey: string;
+    expression: string;
+    constructor(eventKey: string, expression: string, readableDataKey?: string, action?: Action);
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserEventCondition = void 0;
+const base_1 = require("./base");
+/**
+ * Represents a condition that is triggered based on a specific user event.
+ * This condition monitors for events with the specified key and evaluates
+ * any provided expression against the event data.
+ *
+ * @param eventKey The key identifying the specific user event to monitor
+ * @param expression The CEL expression to evaluate against the event data
+ * @param readableDataKey Optional parameter that provides a unique identifier for the data.
+ *                        When multiple conditions are listening to the same event, using a custom
+ *                        readableDataKey prevents duplicate data by differentiating between the conditions.
+ *                        If not provided, defaults to the eventKey.
+ * @param action Optional action to execute when the condition is met
+ *
+ * @example
+ * // Create a condition that triggers when a "purchase" event occurs with amount > 100
+ * const purchaseCondition = new UserEventCondition(
+ *   "purchase",
+ *   "data.amount > 100",
+ *   "high_value_purchase",
+ *   () => console.log("High value purchase detected!")
+ * );
+ */
+class UserEventCondition extends base_1.Condition {
+    constructor(eventKey, expression, readableDataKey, action) {
+        super({
+            readableDataKey: readableDataKey || eventKey,
+            action,
+            orGroupId: '',
+            expression: '',
+        });
+        this.eventKey = eventKey;
+        this.expression = expression;
+    }
+}
+exports.UserEventCondition = UserEventCondition;