@hatchet-dev/typescript-sdk 0.8.0-alpha.2 → 0.8.0-alpha.4

package/step.d.ts

@@ -3,7 +3,7 @@ import { Action } from './clients/dispatcher/action-listener';
 import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
 import { HatchetClient } from './clients/hatchet-client';
-import { WorkflowRunEvent } from './protoc/dispatcher';
+import WorkflowRunRef from './util/workflow-run-ref';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodString;
     units: z.ZodNumber;
@@ -48,9 +48,16 @@ export declare const CreateStepSchema: z.ZodObject<{
         units: number;
     }[] | undefined;
 }>;
-type JSONPrimitive = string | number | boolean | null | Array<JSONPrimitive>;
+export type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+export type JsonArray = JsonValue[] | readonly JsonValue[];
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 export type NextStep = {
-    [key: string]: NextStep | JSONPrimitive | Array<NextStep>;
+    [key: string]: JsonValue;
 };
 interface ContextData<T, K> {
     input: T;
@@ -58,16 +65,7 @@ interface ContextData<T, K> {
     triggered_by: string;
     user_data: K;
 }
-declare class ChildWorkflowRef<T> {
-    workflowRunId: Promise<string>;
-    parentWorkflowRunId: string;
-    client: HatchetClient;
-    constructor(workflowRunId: Promise<string>, parentWorkflowRunId: string, client: HatchetClient);
-    stream(): Promise<AsyncGenerator<WorkflowRunEvent, void, unknown>>;
-    result(): Promise<T>;
-    toJSON(): Promise<string>;
-}
-export declare class Context<T, K> {
+export declare class Context<T, K = {}> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;
@@ -96,7 +94,7 @@ export declare class Context<T, K> {
     refreshTimeout(incrementBy: string): Promise<void>;
     releaseSlot(): Promise<void>;
     putStream(data: string | Uint8Array): Promise<void>;
-    spawnWorkflow<P = unknown, Q = unknown>(workflowName: string, input: Q, key?: string): ChildWorkflowRef<P>;
+    spawnWorkflow<Q = JsonValue, P = JsonValue>(workflowName: string, input: Q, key?: string): WorkflowRunRef<P>;
 }
 export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep | void> | NextStep | void;
 export interface CreateStep<T, K> extends z.infer<typeof CreateStepSchema> {

package/step.js

@@ -31,13 +31,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 };
 };
@@ -49,7 +42,6 @@ const z = __importStar(require("zod"));
 const workflow_1 = require("./workflow");
 const logger_1 = require("./util/logger");
 const parse_1 = require("./util/parse");
-const dispatcher_1 = require("./protoc/dispatcher");
 exports.CreateRateLimitSchema = z.object({
     key: z.string(),
     units: z.number().min(1),
@@ -61,60 +53,6 @@ exports.CreateStepSchema = z.object({
     retries: z.number().optional(),
     rate_limits: z.array(exports.CreateRateLimitSchema).optional(),
 });
-class ChildWorkflowRef {
-    constructor(workflowRunId, parentWorkflowRunId, client) {
-        this.workflowRunId = workflowRunId;
-        this.parentWorkflowRunId = parentWorkflowRunId;
-        this.client = client;
-    }
-    stream() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const workflowRunId = yield this.workflowRunId;
-            const listener = yield this.client.listener.getChildListener(workflowRunId, this.parentWorkflowRunId);
-            return listener.stream();
-        });
-    }
-    result() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const listener = yield this.stream();
-            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), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                            _c = _f.value;
-                            _d = false;
-                            const event = _c;
-                            if (event.eventType === dispatcher_1.WorkflowRunEventType.WORKFLOW_RUN_EVENT_TYPE_FINISHED) {
-                                if (event.results.some((r) => !!r.error)) {
-                                    reject(event.results);
-                                    return;
-                                }
-                                const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
-                                resolve(result);
-                                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) {
         this.controller = new AbortController();
@@ -229,14 +167,19 @@ class Context {
     spawnWorkflow(workflowName, input, key) {
         const { workflowRunId, stepRunId } = this.action;
         const name = this.client.config.namespace + workflowName;
-        const childWorkflowRunIdPromise = this.client.admin.run_workflow(name, input, {
-            parentId: workflowRunId,
-            parentStepRunId: stepRunId,
-            childKey: key,
-            childIndex: this.spawnIndex,
-        });
-        this.spawnIndex += 1;
-        return new ChildWorkflowRef(childWorkflowRunIdPromise, workflowRunId, this.client);
+        try {
+            const resp = this.client.admin.runWorkflow(name, input, {
+                parentId: workflowRunId,
+                parentStepRunId: stepRunId,
+                childKey: key,
+                childIndex: this.spawnIndex,
+            });
+            this.spawnIndex += 1;
+            return resp;
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
     }
 }
 exports.Context = Context;

package/util/config-loader/token.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddressesFromJWT = exports.getTenantIdFromJWT = void 0;
+exports.getTenantIdFromJWT = getTenantIdFromJWT;
+exports.getAddressesFromJWT = getAddressesFromJWT;
 function getTenantIdFromJWT(token) {
     const claims = extractClaimsFromJWT(token);
     return claims.sub;
 }
-exports.getTenantIdFromJWT = getTenantIdFromJWT;
 function getAddressesFromJWT(token) {
     const claims = extractClaimsFromJWT(token);
     return {
@@ -13,7 +13,6 @@ function getAddressesFromJWT(token) {
         grpcBroadcastAddress: claims.grpc_broadcast_address,
     };
 }
-exports.getAddressesFromJWT = getAddressesFromJWT;
 function extractClaimsFromJWT(token) {
     const parts = token.split('.');
     if (parts.length !== 3) {

package/util/parse.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseJSON = void 0;
+exports.parseJSON = parseJSON;
 function parseJSON(json) {
     // TODO why is this needed?
     if (json.startsWith('ey')) {
@@ -22,4 +22,3 @@ function parseJSON(json) {
         throw new Error(`Could not parse JSON: ${e.message}`);
     }
 }
-exports.parseJSON = parseJSON;

package/util/retrier.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrier = void 0;
+exports.retrier = retrier;
 const sleep_1 = __importDefault(require("./sleep"));
 const DEFAULT_RETRY_INTERVAL = 5; // seconds
 const DEFAULT_RETRY_COUNT = 5;
@@ -33,4 +33,3 @@ function retrier(fn_1, logger_1) {
         throw lastError;
     });
 }
-exports.retrier = retrier;

package/util/thread-helper.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 import { Worker, WorkerOptions } from 'worker_threads';
 export declare function runThreaded(scriptPath: string, options: WorkerOptions): Worker;

package/util/thread-helper.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runThreaded = void 0;
+exports.runThreaded = runThreaded;
 const worker_threads_1 = require("worker_threads");
 const path_1 = __importDefault(require("path"));
 function runThreaded(scriptPath, options) {
@@ -32,5 +32,4 @@ function runThreaded(scriptPath, options) {
         : resolvedPath;
     return new worker_threads_1.Worker(ex, Object.assign(Object.assign({}, options), { eval: isTs ? true : undefined }));
 }
-exports.runThreaded = runThreaded;
 // execArgv:  ? ['--require', 'ts-node/register'] : undefined,

package/util/workflow-run-ref.d.ts

@@ -0,0 +1,17 @@
+import { ListenerClient, StepRunEvent } from '../clients/listener/listener-client';
+type EventualWorkflowRunId = string | Promise<string> | Promise<{
+    workflowRunId: string;
+}>;
+export default class WorkflowRunRef<T> {
+    workflowRunId: EventualWorkflowRunId;
+    parentWorkflowRunId?: string;
+    private client;
+    constructor(workflowRunId: string | Promise<string> | Promise<{
+        workflowRunId: string;
+    }>, client: ListenerClient, parentWorkflowRunId?: string);
+    getWorkflowRunId(): Promise<string>;
+    stream(): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
+    result(): Promise<T>;
+    toJSON(): Promise<string>;
+}
+export {};

package/util/workflow-run-ref.js

@@ -0,0 +1,94 @@
+"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());
+    });
+};
+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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dispatcher_1 = require("../protoc/dispatcher");
+function getWorkflowRunId(workflowRunId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof workflowRunId === 'string') {
+            return workflowRunId;
+        }
+        if (workflowRunId instanceof Promise) {
+            const resolved = yield workflowRunId;
+            if (typeof resolved === 'string') {
+                return resolved;
+            }
+            return resolved.workflowRunId;
+        }
+        throw new Error('Invalid workflowRunId');
+    });
+}
+class WorkflowRunRef {
+    constructor(workflowRunId, client, parentWorkflowRunId) {
+        this.workflowRunId = workflowRunId;
+        this.parentWorkflowRunId = parentWorkflowRunId;
+        this.client = client;
+    }
+    getWorkflowRunId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return getWorkflowRunId(this.workflowRunId);
+        });
+    }
+    stream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workflowRunId = yield getWorkflowRunId(this.workflowRunId);
+            return this.client.stream(workflowRunId);
+        });
+    }
+    result() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workflowRunId = yield getWorkflowRunId(this.workflowRunId);
+            const streamable = yield this.client.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(streamable.stream()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const event = _c;
+                            if (event.eventType === dispatcher_1.WorkflowRunEventType.WORKFLOW_RUN_EVENT_TYPE_FINISHED) {
+                                if (event.results.some((r) => !!r.error)) {
+                                    reject(event.results);
+                                    return;
+                                }
+                                const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
+                                resolve(result);
+                                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,
+            });
+        });
+    }
+}
+exports.default = WorkflowRunRef;

package/workflow.d.ts

@@ -60,7 +60,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
      * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
      */
     timeout: z.ZodOptional<z.ZodString>;
-    on: z.ZodUnion<[z.ZodObject<{
+    on: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
         event: z.ZodUndefined;
     }, "strip", z.ZodTypeAny, {
@@ -78,7 +78,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     }, {
         event: string;
         cron?: undefined;
-    }>]>;
+    }>]>>;
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -160,16 +160,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;
@@ -193,16 +193,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;

package/workflow.js

@@ -35,7 +35,7 @@ const EventConfigSchema = z.object({
     cron: z.undefined(),
     event: z.string(),
 });
-const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
+const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]).optional();
 const StepsSchema = z.array(step_1.CreateStepSchema);
 exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
 exports.WorkflowConcurrency = z.object({