@hatchet-dev/typescript-sdk 0.2.0 → 0.2.1

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

@@ -2,6 +2,10 @@ import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../pr
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { DispatcherClient } from './dispatcher-client';
+declare enum ListenStrategy {
+    LISTEN_STRATEGY_V1 = 1,
+    LISTEN_STRATEGY_V2 = 2
+}
 export interface Action {
     tenantId: string;
     jobId: string;
@@ -26,9 +30,16 @@ export declare class ActionListener {
     retryInterval: number;
     retryCount: number;
     done: boolean;
+    listenStrategy: ListenStrategy;
+    heartbeatInterval: any;
     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>;
 }
+export {};

package/clients/dispatcher/action-listener.js

@@ -39,6 +39,12 @@ const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error
 const logger_1 = require("../../util/logger");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+// eslint-disable-next-line no-shadow
+var ListenStrategy;
+(function (ListenStrategy) {
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
+})(ListenStrategy || (ListenStrategy = {}));
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;
@@ -46,6 +52,7 @@ class ActionListener {
         this.retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL;
         this.retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT;
         this.done = false;
+        this.listenStrategy = ListenStrategy.LISTEN_STRATEGY_V2;
         this.actions = () => (function gen(client) {
             return __asyncGenerator(this, arguments, function* gen_1() {
                 var _a, e_1, _b, _c;
@@ -79,6 +86,10 @@ class ActionListener {
                         if (e.code === nice_grpc_1.Status.CANCELLED) {
                             break;
                         }
+                        if ((yield __await(client.getListenStrategy())) === ListenStrategy.LISTEN_STRATEGY_V2 &&
+                            e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                            client.setListenStrategy(ListenStrategy.LISTEN_STRATEGY_V1);
+                        }
                         client.incrementRetries();
                     }
                 }
@@ -91,11 +102,62 @@ class ActionListener {
         this.retryInterval = retryInterval;
         this.retryCount = retryCount;
     }
+    setListenStrategy(strategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.listenStrategy = strategy;
+        });
+    }
+    getListenStrategy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listenStrategy;
+        });
+    }
     incrementRetries() {
         return __awaiter(this, void 0, void 0, function* () {
             this.retries += 1;
         });
     }
+    heartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.heartbeatInterval) {
+                return;
+            }
+            // start with a heartbeat
+            try {
+                yield this.client.heartbeat({
+                    workerId: this.workerId,
+                    heartbeatAt: new Date(),
+                });
+            }
+            catch (e) {
+                this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                    return;
+                }
+            }
+            this.heartbeatInterval = setInterval(() => __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.closeHeartbeat();
+                        return;
+                    }
+                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                }
+            }), 4000);
+        });
+    }
+    closeHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+    }
     getListenClient() {
         return __awaiter(this, void 0, void 0, function* () {
             const currentTime = Math.floor(Date.now());
@@ -112,9 +174,16 @@ class ActionListener {
                 yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
             }
             try {
-                return this.client.listen({
+                if (this.listenStrategy === ListenStrategy.LISTEN_STRATEGY_V1) {
+                    return this.client.listen({
+                        workerId: this.workerId,
+                    });
+                }
+                const res = this.client.listenV2({
                     workerId: this.workerId,
                 });
+                this.heartbeat();
+                return res;
             }
             catch (e) {
                 this.retries += 1;
@@ -126,6 +195,7 @@ class ActionListener {
     unregister() {
         return __awaiter(this, void 0, void 0, function* () {
             this.done = true;
+            this.closeHeartbeat();
             try {
                 return this.client.unsubscribe({
                     workerId: this.workerId,

package/package.json

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

package/protoc/dispatcher/dispatcher.d.ts

@@ -178,6 +178,14 @@ export interface OverridesData {
 }
 export interface OverridesDataResponse {
 }
+export interface HeartbeatRequest {
+    /** the id of the worker */
+    workerId: string;
+    /** heartbeatAt is the time the worker sent the heartbeat */
+    heartbeatAt: Date | undefined;
+}
+export interface HeartbeatResponse {
+}
 export declare const WorkerRegisterRequest: {
     encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
@@ -282,6 +290,22 @@ export declare const OverridesDataResponse: {
     create(base?: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
     fromPartial(_: DeepPartial<OverridesDataResponse>): OverridesDataResponse;
 };
+export declare const HeartbeatRequest: {
+    encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+    fromJSON(object: any): HeartbeatRequest;
+    toJSON(message: HeartbeatRequest): unknown;
+    create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+    fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+};
+export declare const HeartbeatResponse: {
+    encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+    fromJSON(_: any): HeartbeatResponse;
+    toJSON(_: HeartbeatResponse): unknown;
+    create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+    fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+};
 export type DispatcherDefinition = typeof DispatcherDefinition;
 export declare const DispatcherDefinition: {
     readonly name: "Dispatcher";
@@ -331,6 +355,55 @@ export declare const DispatcherDefinition: {
             readonly responseStream: true;
             readonly options: {};
         };
+        /**
+         * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+         * against engine version v0.18.1+
+         */
+        readonly listenV2: {
+            readonly name: "ListenV2";
+            readonly requestType: {
+                encode(message: WorkerListenRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkerListenRequest;
+                fromJSON(object: any): WorkerListenRequest;
+                toJSON(message: WorkerListenRequest): unknown;
+                create(base?: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+                fromPartial(object: DeepPartial<WorkerListenRequest>): WorkerListenRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: AssignedAction, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): AssignedAction;
+                fromJSON(object: any): AssignedAction;
+                toJSON(message: AssignedAction): unknown;
+                create(base?: DeepPartial<AssignedAction>): AssignedAction;
+                fromPartial(object: DeepPartial<AssignedAction>): AssignedAction;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+        readonly heartbeat: {
+            readonly name: "Heartbeat";
+            readonly requestType: {
+                encode(message: HeartbeatRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatRequest;
+                fromJSON(object: any): HeartbeatRequest;
+                toJSON(message: HeartbeatRequest): unknown;
+                create(base?: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+                fromPartial(object: DeepPartial<HeartbeatRequest>): HeartbeatRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(_: HeartbeatResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): HeartbeatResponse;
+                fromJSON(_: any): HeartbeatResponse;
+                toJSON(_: HeartbeatResponse): unknown;
+                create(base?: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+                fromPartial(_: DeepPartial<HeartbeatResponse>): HeartbeatResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly subscribeToWorkflowEvents: {
             readonly name: "SubscribeToWorkflowEvents";
             readonly requestType: {
@@ -446,6 +519,13 @@ export declare const DispatcherDefinition: {
 export interface DispatcherServiceImplementation<CallContextExt = {}> {
     register(request: WorkerRegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerRegisterResponse>>;
     listen(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: HeartbeatRequest, context: CallContext & CallContextExt): Promise<DeepPartial<HeartbeatResponse>>;
     subscribeToWorkflowEvents(request: SubscribeToWorkflowEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowEvent>>;
     sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
@@ -455,6 +535,13 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
 export interface DispatcherClient<CallOptionsExt = {}> {
     register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
     listen(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /**
+     * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+     * against engine version v0.18.1+
+     */
+    listenV2(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+    heartbeat(request: DeepPartial<HeartbeatRequest>, options?: CallOptions & CallOptionsExt): Promise<HeartbeatResponse>;
     subscribeToWorkflowEvents(request: DeepPartial<SubscribeToWorkflowEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowEvent>;
     sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;

package/protoc/dispatcher/dispatcher.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DispatcherDefinition = exports.OverridesDataResponse = exports.OverridesData = exports.WorkflowEvent = exports.SubscribeToWorkflowEventsRequest = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.resourceEventTypeToJSON = exports.resourceEventTypeFromJSON = exports.ResourceEventType = exports.resourceTypeToJSON = exports.resourceTypeFromJSON = exports.ResourceType = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
+exports.DispatcherDefinition = exports.HeartbeatResponse = exports.HeartbeatRequest = exports.OverridesDataResponse = exports.OverridesData = exports.WorkflowEvent = exports.SubscribeToWorkflowEventsRequest = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.resourceEventTypeToJSON = exports.resourceEventTypeFromJSON = exports.ResourceEventType = exports.resourceTypeToJSON = exports.resourceTypeFromJSON = exports.ResourceType = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 exports.protobufPackage = '';
@@ -1579,6 +1579,110 @@ exports.OverridesDataResponse = {
         return message;
     },
 };
+function createBaseHeartbeatRequest() {
+    return { workerId: '', heartbeatAt: undefined };
+}
+exports.HeartbeatRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.workerId !== '') {
+            writer.uint32(10).string(message.workerId);
+        }
+        if (message.heartbeatAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.heartbeatAt), writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHeartbeatRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workerId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.heartbeatAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            workerId: isSet(object.workerId) ? globalThis.String(object.workerId) : '',
+            heartbeatAt: isSet(object.heartbeatAt) ? fromJsonTimestamp(object.heartbeatAt) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.workerId !== '') {
+            obj.workerId = message.workerId;
+        }
+        if (message.heartbeatAt !== undefined) {
+            obj.heartbeatAt = message.heartbeatAt.toISOString();
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.HeartbeatRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseHeartbeatRequest();
+        message.workerId = (_a = object.workerId) !== null && _a !== void 0 ? _a : '';
+        message.heartbeatAt = (_b = object.heartbeatAt) !== null && _b !== void 0 ? _b : undefined;
+        return message;
+    },
+};
+function createBaseHeartbeatResponse() {
+    return {};
+}
+exports.HeartbeatResponse = {
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHeartbeatResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    create(base) {
+        return exports.HeartbeatResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(_) {
+        const message = createBaseHeartbeatResponse();
+        return message;
+    },
+};
 exports.DispatcherDefinition = {
     name: 'Dispatcher',
     fullName: 'Dispatcher',
@@ -1599,6 +1703,27 @@ exports.DispatcherDefinition = {
             responseStream: true,
             options: {},
         },
+        /**
+         * ListenV2 is like listen, but implementation does not include heartbeats. This should only used by SDKs
+         * against engine version v0.18.1+
+         */
+        listenV2: {
+            name: 'ListenV2',
+            requestType: exports.WorkerListenRequest,
+            requestStream: false,
+            responseType: exports.AssignedAction,
+            responseStream: true,
+            options: {},
+        },
+        /** Heartbeat is a method for workers to send heartbeats to the dispatcher */
+        heartbeat: {
+            name: 'Heartbeat',
+            requestType: exports.HeartbeatRequest,
+            requestStream: false,
+            responseType: exports.HeartbeatResponse,
+            responseStream: false,
+            options: {},
+        },
         subscribeToWorkflowEvents: {
             name: 'SubscribeToWorkflowEvents',
             requestType: exports.SubscribeToWorkflowEventsRequest,