@hatchet-dev/typescript-sdk 0.5.1 → 0.5.3

package/clients/dispatcher/action-listener.d.ts

@@ -2,6 +2,7 @@ import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../pr
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { DispatcherClient } from './dispatcher-client';
+import { Heartbeat } from './heartbeat/heartbeat-controller';
 declare enum ListenStrategy {
     LISTEN_STRATEGY_V1 = 1,
     LISTEN_STRATEGY_V2 = 2
@@ -31,14 +32,12 @@ export declare class ActionListener {
     retryCount: number;
     done: boolean;
     listenStrategy: ListenStrategy;
-    heartbeatInterval: any;
+    heartbeat: Heartbeat;
     constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
     actions: () => AsyncGenerator<Action, void, unknown>;
     setListenStrategy(strategy: ListenStrategy): Promise<void>;
     getListenStrategy(): Promise<ListenStrategy>;
     incrementRetries(): Promise<void>;
-    heartbeat(): Promise<void>;
-    closeHeartbeat(): void;
     getListenClient(): Promise<AsyncIterable<AssignedAction>>;
     unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }

package/clients/dispatcher/action-listener.js

@@ -37,6 +37,7 @@ const nice_grpc_1 = require("nice-grpc");
 const sleep_1 = __importDefault(require("../../util/sleep"));
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const logger_1 = require("../../util/logger");
+const heartbeat_controller_1 = require("./heartbeat/heartbeat-controller");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 20;
 // eslint-disable-next-line no-shadow
@@ -91,8 +92,13 @@ class ActionListener {
                         }
                         client.incrementRetries();
                         client.logger.error(`Listener encountered an error: ${e.message}`);
-                        client.logger.info(`Retrying in ${client.retryInterval}ms...`);
-                        yield __await((0, sleep_1.default)(client.retryInterval));
+                        if (client.retries > 1) {
+                            client.logger.info(`Retrying in ${client.retryInterval}ms...`);
+                            yield __await((0, sleep_1.default)(client.retryInterval));
+                        }
+                        else {
+                            client.logger.info(`Retrying`);
+                        }
                     }
                 }
             });
@@ -103,6 +109,7 @@ class ActionListener {
         this.logger = new logger_1.Logger(`ActionListener`, this.config.log_level);
         this.retryInterval = retryInterval;
         this.retryCount = retryCount;
+        this.heartbeat = new heartbeat_controller_1.Heartbeat(client, workerId);
     }
     setListenStrategy(strategy) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -119,39 +126,6 @@ class ActionListener {
             this.retries += 1;
         });
     }
-    heartbeat() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.heartbeatInterval) {
-                return;
-            }
-            const beat = () => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield this.client.heartbeat({
-                        workerId: this.workerId,
-                        heartbeatAt: new Date(),
-                    });
-                }
-                catch (e) {
-                    if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
-                        // break out of interval
-                        this.logger.error('Heartbeat not implemented, closing heartbeat');
-                        this.closeHeartbeat();
-                        return;
-                    }
-                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
-                }
-            });
-            // start with a heartbeat
-            yield beat();
-            this.heartbeatInterval = setInterval(beat, 4000);
-        });
-    }
-    closeHeartbeat() {
-        if (this.heartbeatInterval) {
-            clearInterval(this.heartbeatInterval);
-            this.heartbeatInterval = null;
-        }
-    }
     getListenClient() {
         return __awaiter(this, void 0, void 0, function* () {
             const currentTime = Math.floor(Date.now());
@@ -172,14 +146,14 @@ class ActionListener {
                     const result = this.client.listen({
                         workerId: this.workerId,
                     });
-                    this.logger.info('Connection established using LISTEN_STRATEGY_V1');
+                    this.logger.green('Connection established using LISTEN_STRATEGY_V1');
                     return result;
                 }
                 const res = this.client.listenV2({
                     workerId: this.workerId,
                 });
-                yield this.heartbeat();
-                this.logger.info('Connection established using LISTEN_STRATEGY_V2');
+                yield this.heartbeat.start();
+                this.logger.green('Connection established using LISTEN_STRATEGY_V2');
                 return res;
             }
             catch (e) {
@@ -187,7 +161,7 @@ class ActionListener {
                 this.logger.error(`Attempt ${this.retries}: Failed to connect, retrying...`);
                 if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
                     // Connection lost, reset heartbeat interval and retry connection
-                    this.closeHeartbeat();
+                    this.heartbeat.stop();
                     return this.getListenClient();
                 }
                 throw e;
@@ -197,7 +171,7 @@ class ActionListener {
     unregister() {
         return __awaiter(this, void 0, void 0, function* () {
             this.done = true;
-            this.closeHeartbeat();
+            this.heartbeat.stop();
             try {
                 return yield this.client.unsubscribe({
                     workerId: this.workerId,

package/clients/dispatcher/heartbeat/heartbeat-controller.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { Logger } from '../../../util/logger';
+import { DispatcherClient as PbDispatcherClient } from '../../../protoc/dispatcher';
+import { Worker } from 'worker_threads';
+import { ClientConfig } from '../../hatchet-client';
+import { DispatcherClient } from '../dispatcher-client';
+export declare class Heartbeat {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    workerId: string;
+    logger: Logger;
+    heartbeatWorker: Worker | undefined;
+    constructor(client: DispatcherClient, workerId: string);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/clients/dispatcher/heartbeat/heartbeat-controller.js

@@ -0,0 +1,47 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Heartbeat = void 0;
+const logger_1 = require("../../../util/logger");
+const path_1 = __importDefault(require("path"));
+const thread_helper_1 = require("../../../util/thread-helper");
+class Heartbeat {
+    constructor(client, workerId) {
+        this.config = client.config;
+        this.client = client.client;
+        this.workerId = workerId;
+        this.logger = new logger_1.Logger(`HeartbeatController`, this.config.log_level);
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.heartbeatWorker) {
+                this.heartbeatWorker = (0, thread_helper_1.runThreaded)(path_1.default.join(__dirname, './heartbeat-worker'), {
+                    workerData: {
+                        config: this.config,
+                        workerId: this.workerId,
+                    },
+                });
+            }
+        });
+    }
+    stop() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_a = this.heartbeatWorker) === null || _a === void 0 ? void 0 : _a.postMessage('stop');
+            (_b = this.heartbeatWorker) === null || _b === void 0 ? void 0 : _b.terminate();
+            this.heartbeatWorker = undefined;
+        });
+    }
+}
+exports.Heartbeat = Heartbeat;

package/clients/dispatcher/heartbeat/heartbeat-worker.d.ts

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

package/clients/dispatcher/heartbeat/heartbeat-worker.js

@@ -0,0 +1,75 @@
+"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 worker_threads_1 = require("worker_threads");
+const logger_1 = require("../../../util/logger");
+const hatchet_client_1 = require("../../hatchet-client");
+const config_loader_1 = require("../../../util/config-loader");
+const nice_grpc_1 = require("nice-grpc");
+const dispatcher_client_1 = require("../dispatcher-client");
+const HEARTBEAT_INTERVAL = 4000;
+class HeartbeatWorker {
+    constructor(config, workerId) {
+        this.timeLastHeartbeat = new Date().getTime();
+        this.workerId = workerId;
+        this.logger = new logger_1.Logger(`Heartbeat`, config.log_level);
+        const credentials = config_loader_1.ConfigLoader.createCredentials(config.tls_config);
+        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, hatchet_client_1.addTokenMiddleware)(config.token));
+        const dispatcher = new dispatcher_client_1.DispatcherClient(config, (0, hatchet_client_1.channelFactory)(config, credentials), clientFactory);
+        this.client = dispatcher.client;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.heartbeatInterval) {
+                return;
+            }
+            const beat = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.logger.debug('Heartbeat sending...');
+                    yield this.client.heartbeat({
+                        workerId: this.workerId,
+                        heartbeatAt: new Date(),
+                    });
+                    const now = new Date().getTime();
+                    const actualInterval = now - this.timeLastHeartbeat;
+                    if (actualInterval > HEARTBEAT_INTERVAL * 1.2) {
+                        this.logger.warn(`Heartbeat interval delay (${actualInterval}ms >> ${HEARTBEAT_INTERVAL}ms)`);
+                    }
+                    this.logger.debug(`Heartbeat sent ${actualInterval}ms ago`);
+                    this.timeLastHeartbeat = now;
+                }
+                catch (e) {
+                    if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                        // break out of interval
+                        this.logger.error('Heartbeat not implemented, closing heartbeat');
+                        this.stop();
+                        return;
+                    }
+                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                }
+            });
+            // start with a heartbeat
+            yield beat();
+            this.heartbeatInterval = setInterval(beat, HEARTBEAT_INTERVAL);
+        });
+    }
+    stop() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+}
+const heartbeat = new HeartbeatWorker(worker_threads_1.workerData.config, worker_threads_1.workerData.workerId);
+heartbeat.start();
+worker_threads_1.parentPort === null || worker_threads_1.parentPort === void 0 ? void 0 : worker_threads_1.parentPort.on('stop', () => {
+    heartbeat.stop();
+});

package/clients/hatchet-client/hatchet-client.d.ts

@@ -1,7 +1,7 @@
 import { EventClient } from '../event/event-client';
 import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
-import { ChannelCredentials } from 'nice-grpc';
+import { CallOptions, ChannelCredentials, ClientMiddlewareCall } from 'nice-grpc';
 import { Workflow } from '../../workflow';
 import { Worker } from '../worker';
 import Logger from '../../util/logger/logger';
@@ -13,6 +13,8 @@ export interface HatchetClientOptions {
     config_path?: string;
     credentials?: ChannelCredentials;
 }
+export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;
+export declare const addTokenMiddleware: (token: string) => <Request_1, Response_1>(call: ClientMiddlewareCall<Request_1, Response_1>, options: CallOptions) => AsyncGenerator<Awaited<Response_1>, Awaited<Response_1> | undefined, undefined>;
 export declare class HatchetClient {
     config: ClientConfig;
     credentials: ChannelCredentials;

package/clients/hatchet-client/hatchet-client.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HatchetClient = void 0;
+exports.HatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
 const zod_1 = require("zod");
 const config_loader_1 = require("../../util/config-loader");
 const event_client_1 = require("../event/event-client");
@@ -49,6 +49,16 @@ const logger_1 = __importDefault(require("../../util/logger/logger"));
 const client_config_1 = require("./client-config");
 const listener_client_1 = require("../listener/listener-client");
 const rest_1 = __importDefault(require("../rest"));
+const channelFactory = (config, credentials) => (0, nice_grpc_1.createChannel)(config.host_port, credentials, {
+    'grpc.ssl_target_name_override': config.tls_config.server_name,
+    'grpc.keepalive_timeout_ms': 60 * 1000,
+    'grpc.client_idle_timeout_ms': 60 * 1000,
+    // Send keepalive pings every 10 seconds, default is 2 hours.
+    'grpc.keepalive_time_ms': 10 * 1000,
+    // Allow keepalive pings when there are no gRPC calls.
+    'grpc.keepalive_permit_without_calls': 1,
+});
+exports.channelFactory = channelFactory;
 const addTokenMiddleware = (token) => function _(call, options) {
     return __asyncGenerator(this, arguments, function* _1() {
         var _a, e_1, _b, _c;
@@ -75,6 +85,7 @@ const addTokenMiddleware = (token) => function _(call, options) {
         return yield __await(undefined);
     });
 };
+exports.addTokenMiddleware = addTokenMiddleware;
 class HatchetClient {
     constructor(config, options, axiosOpts) {
         // Initializes a new Client instance.
@@ -95,22 +106,13 @@ class HatchetClient {
         }
         this.credentials =
             (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
-        const channelFactory = () => (0, nice_grpc_1.createChannel)(this.config.host_port, this.credentials, {
-            'grpc.ssl_target_name_override': this.config.tls_config.server_name,
-            'grpc.keepalive_timeout_ms': 60 * 1000,
-            'grpc.client_idle_timeout_ms': 60 * 1000,
-            // Send keepalive pings every 10 seconds, default is 2 hours.
-            'grpc.keepalive_time_ms': 10 * 1000,
-            // Allow keepalive pings when there are no gRPC calls.
-            'grpc.keepalive_permit_without_calls': 1,
-        });
-        const clientFactory = (0, nice_grpc_1.createClientFactory)().use(addTokenMiddleware(this.config.token));
+        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, exports.addTokenMiddleware)(this.config.token));
         this.tenantId = this.config.tenant_id;
         this.api = (0, rest_1.default)(this.config.api_url, this.config.token, axiosOpts);
-        this.event = new event_client_1.EventClient(this.config, channelFactory(), clientFactory);
-        this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, channelFactory(), clientFactory);
-        this.admin = new admin_client_1.AdminClient(this.config, channelFactory(), clientFactory, this.api, this.tenantId);
-        this.listener = new listener_client_1.ListenerClient(this.config, channelFactory(), clientFactory, this.api);
+        this.event = new event_client_1.EventClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
+        this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
+        this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId);
+        this.listener = new listener_client_1.ListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.logger = new logger_1.default('HatchetClient', this.config.log_level);
         this.logger.info(`Initialized HatchetClient`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/step.js

@@ -90,7 +90,8 @@ class ChildWorkflowRef {
                                     reject(event.results);
                                     return;
                                 }
-                                resolve(event.results);
+                                const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
+                                resolve(result);
                                 return;
                             }
                         }

package/util/logger/logger.d.ts

@@ -6,6 +6,7 @@ export declare class Logger {
     private log;
     debug(message: string): void;
     info(message: string): void;
+    green(message: string): void;
     warn(message: string): void;
     error(message: string): void;
 }

package/util/logger/logger.js

@@ -15,22 +15,34 @@ class Logger {
         this.logLevel = logLevel;
         this.context = context;
     }
-    log(level, message) {
+    log(level, message, color = '33') {
         if (LogLevelEnum[level] >= LogLevelEnum[this.logLevel]) {
-            console.log(`🪓 [${level}/${this.context}] ${message}`);
+            const time = new Date().toLocaleString('en-US', {
+                month: '2-digit',
+                day: '2-digit',
+                year: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+            });
+            // eslint-disable-next-line no-console
+            console.log(`🪓 ${process.pid} | ${time} \x1b[${color}m [${level}/${this.context}] ${message}\x1b[0m`);
         }
     }
     debug(message) {
-        this.log('DEBUG', message);
+        this.log('DEBUG', message, '35');
     }
     info(message) {
-        this.log('INFO', message);
+        this.log('INFO', message, '30');
+    }
+    green(message) {
+        this.log('INFO', message, '32');
     }
     warn(message) {
-        this.log('WARN', message);
+        this.log('WARN', message, '93');
     }
     error(message) {
-        this.log('ERROR', message);
+        this.log('ERROR', message, '91');
     }
 }
 exports.Logger = Logger;

package/util/thread-helper.d.ts

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

package/util/thread-helper.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runThreaded = void 0;
+const worker_threads_1 = require("worker_threads");
+const path_1 = __importDefault(require("path"));
+function runThreaded(scriptPath, options) {
+    const resolvedPath = require.resolve(scriptPath);
+    const isTs = /\.ts$/.test(resolvedPath);
+    // NOTE: if the file is typescript, we are in the SDK dev environment and need to so some funky work.
+    // otherwise, we pass the file directly to the worker.
+    const ex = isTs
+        ? `
+    const wk = require('worker_threads');
+    require('tsconfig-paths/register');
+    require('ts-node').register({
+      "include": ["src/**/*.ts"],
+      "exclude": ["./dist"],
+      "compilerOptions": {
+        "types": ["node"],
+        "target": "es2016",
+        "esModuleInterop": true,
+        "module": "commonjs",
+        "rootDir": "${path_1.default.join(__dirname, '../../../')}",
+      }
+    });
+    let file = '${resolvedPath}';
+    require(file);
+    `
+        : resolvedPath;
+    return new worker_threads_1.Worker(ex, Object.assign(Object.assign({}, options), { eval: isTs }));
+}
+exports.runThreaded = runThreaded;
+// execArgv:  ? ['--require', 'ts-node/register'] : undefined,