@hatchet-dev/typescript-sdk 0.1.31 → 0.2.1

package/step.d.ts

@@ -1,8 +1,9 @@
 import * as z from 'zod';
 import { Action } from './clients/dispatcher/action-listener';
-import { DispatcherClient } from './clients/dispatcher/dispatcher-client';
-import { EventClient, LogLevel } from './clients/event/event-client';
+import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
+import { HatchetClient } from './clients/hatchet-client';
+import { RunEventType } from './clients/listener/listener-client';
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -29,16 +30,27 @@ interface ContextData<T, K> {
     triggered_by: string;
     user_data: K;
 }
+declare class ChildWorkflowRef<T> {
+    workflowRunId: Promise<string>;
+    client: HatchetClient;
+    constructor(workflowRunId: Promise<string>, client: HatchetClient);
+    stream(): Promise<AsyncGenerator<{
+        type: RunEventType;
+        payload: string;
+    }, void, unknown>>;
+    result(): Promise<T>;
+    toJSON(): Promise<string>;
+}
 export declare class Context<T, K> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;
     action: Action;
-    client: DispatcherClient;
-    eventClient: EventClient;
+    client: HatchetClient;
     overridesData: Record<string, any>;
     logger: Logger;
-    constructor(action: Action, client: DispatcherClient, eventClient: EventClient);
+    spawnIndex: number;
+    constructor(action: Action, client: HatchetClient);
     stepOutput(step: string): NextStep;
     triggeredByEvent(): boolean;
     workflowInput(): T;
@@ -47,6 +59,7 @@ export declare class Context<T, K> {
     workflowRunId(): string;
     playground(name: string, defaultValue?: string): string;
     log(message: string, level?: LogLevel): void;
+    spawnWorkflow<P = unknown>(workflowName: string, input: T, key?: string): ChildWorkflowRef<P>;
 }
 export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep> | NextStep | void;
 export interface CreateStep<T, K> extends z.infer<typeof CreateStepSchema> {

package/step.js

@@ -22,32 +22,106 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.CreateStepSchema = void 0;
+/* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
 const workflow_1 = require("./workflow");
 const logger_1 = require("./util/logger");
 const parse_1 = require("./util/parse");
+const listener_client_1 = require("./clients/listener/listener-client");
 exports.CreateStepSchema = z.object({
     name: z.string(),
     parents: z.array(z.string()).optional(),
     timeout: workflow_1.HatchetTimeoutSchema.optional(),
     retries: z.number().optional(),
 });
+class ChildWorkflowRef {
+    constructor(workflowRunId, client) {
+        this.workflowRunId = workflowRunId;
+        this.client = client;
+    }
+    stream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workflowRunId = yield this.workflowRunId;
+            return this.client.listener.stream(workflowRunId);
+        });
+    }
+    result() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workflowRunId = yield this.workflowRunId;
+            const listener = yield this.client.listener.get(workflowRunId);
+            return new Promise((resolve, reject) => {
+                (() => __awaiter(this, void 0, void 0, function* () {
+                    var _a, e_1, _b, _c;
+                    try {
+                        for (var _d = true, _e = __asyncValues(yield listener.stream()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const event = _c;
+                            if (event.type === listener_client_1.RunEventType.WORKFLOW_RUN_EVENT_TYPE_FAILED ||
+                                event.type === listener_client_1.RunEventType.WORKFLOW_RUN_EVENT_TYPE_CANCELLED ||
+                                event.type === listener_client_1.RunEventType.WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT) {
+                                reject(new hatchet_error_1.default(event.type));
+                                listener.close();
+                                return;
+                            }
+                            if (event.type === listener_client_1.RunEventType.WORKFLOW_RUN_EVENT_TYPE_COMPLETED) {
+                                resolve(JSON.parse(event.payload));
+                                listener.close();
+                                return;
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }))();
+            });
+        });
+    }
+    toJSON() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify({
+                workflowRunId: yield this.workflowRunId,
+            });
+        });
+    }
+}
 class Context {
-    constructor(action, client, eventClient) {
+    constructor(action, client) {
         this.controller = new AbortController();
         this.overridesData = {};
+        this.spawnIndex = 0;
         try {
             const data = (0, parse_1.parseJSON)(action.actionPayload);
             this.data = data;
             this.action = action;
             this.client = client;
-            this.eventClient = eventClient;
             this.logger = new logger_1.Logger(`Context Logger`, client.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
@@ -92,7 +166,7 @@ class Context {
         if (name in this.overridesData) {
             return this.overridesData[name];
         }
-        this.client.putOverridesData({
+        this.client.dispatcher.putOverridesData({
             stepRunId: this.action.stepRunId,
             path: name,
             value: JSON.stringify(defaultValue),
@@ -106,7 +180,18 @@ class Context {
             this.logger.warn('cannot log from context without stepRunId');
             return;
         }
-        this.eventClient.putLog(stepRunId, message, level);
+        this.client.event.putLog(stepRunId, message, level);
+    }
+    spawnWorkflow(workflowName, input, key) {
+        const { workflowRunId, stepRunId } = this.action;
+        const childWorkflowRunIdPromise = this.client.admin.run_workflow(workflowName, input, {
+            parentId: workflowRunId,
+            parentStepRunId: stepRunId,
+            childKey: key,
+            childIndex: this.spawnIndex,
+        });
+        this.spawnIndex += 1;
+        return new ChildWorkflowRef(childWorkflowRunIdPromise, this.client);
     }
 }
 exports.Context = Context;