@hatchet-dev/typescript-sdk 1.11.0 → 1.12.1

package/examples/webhooks.js

@@ -0,0 +1,45 @@
+"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 });
+const sdk_1 = __importDefault(require("../sdk"));
+const data_contracts_1 = require("../clients/rest/generated/data-contracts");
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const webhookName = `example-webhook-${Date.now()}`;
+        const namespace = (_b = (_a = hatchet.config) === null || _a === void 0 ? void 0 : _a.namespace) !== null && _b !== void 0 ? _b : 'default';
+        const webhook = yield hatchet.webhooks.create({
+            sourceName: data_contracts_1.V1WebhookSourceName.GENERIC,
+            name: webhookName,
+            eventKeyExpression: `'${namespace}/webhook:' + input.type`,
+            scopeExpression: 'input.customer_id',
+            staticPayload: { customer_id: 'cust-123', environment: 'production' },
+            auth: { username: 'test_user', password: 'test_password' },
+        });
+        console.log('Created webhook:', webhook.name, webhook.scopeExpression, webhook.staticPayload);
+        const one = yield hatchet.webhooks.get(webhook.name);
+        console.log('Get webhook:', one.name);
+        yield hatchet.webhooks.update(webhook.name, {
+            scopeExpression: 'input.environment',
+        });
+        const updated = yield hatchet.webhooks.get(webhook.name);
+        console.log('Updated scope expression:', updated.scopeExpression);
+        const list = yield hatchet.webhooks.list({ limit: 10, offset: 0 });
+        console.log('List webhooks:', (_d = (_c = list.rows) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0);
+        yield hatchet.webhooks.delete(webhook.name);
+        console.log('Deleted example webhook');
+    });
+}
+main();

package/package.json

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

package/protoc/dispatcher/dispatcher.d.ts

@@ -6,6 +6,7 @@ export declare enum SDKS {
     GO = 1,
     PYTHON = 2,
     TYPESCRIPT = 3,
+    RUBY = 4,
     UNRECOGNIZED = -1
 }
 export declare function sDKSFromJSON(object: any): SDKS;
@@ -82,8 +83,11 @@ export interface WorkerRegisterRequest {
     actions: string[];
     /** (optional) the services for this worker */
     services: string[];
-    /** (optional) the max number of runs this worker can handle */
-    maxRuns?: number | undefined;
+    /**
+     * (optional) the number of default slots this worker can handle
+     * deprecated: use slot_config instead
+     */
+    slots?: number | undefined;
     /** (optional) worker labels (i.e. state or other metadata) */
     labels: {
         [key: string]: WorkerLabels;
@@ -92,11 +96,19 @@ export interface WorkerRegisterRequest {
     webhookId?: string | undefined;
     /** (optional) information regarding the runtime environment of the worker */
     runtimeInfo?: RuntimeInfo | undefined;
+    /** (optional) slot config for this worker (slot_type -> units) */
+    slotConfig: {
+        [key: string]: number;
+    };
 }
 export interface WorkerRegisterRequest_LabelsEntry {
     key: string;
     value: WorkerLabels | undefined;
 }
+export interface WorkerRegisterRequest_SlotConfigEntry {
+    key: string;
+    value: number;
+}
 export interface WorkerRegisterResponse {
     /** the tenant id */
     tenantId: string;
@@ -136,18 +148,18 @@ export interface AssignedAction {
     jobName: string;
     /** the job run id */
     jobRunId: string;
-    /** the step id */
-    stepId: string;
-    /** the step run id */
-    stepRunId: string;
+    /** the task id */
+    taskId: string;
+    /** the task external run id */
+    taskRunExternalId: string;
     /** the action id */
     actionId: string;
     /** the action type */
     actionType: ActionType;
     /** the action payload */
     actionPayload: string;
-    /** the step name */
-    stepName: string;
+    /** the task name */
+    taskName: string;
     /** the count number of the retry attempt */
     retryCount: number;
     /** (optional) additional metadata set on the workflow */
@@ -188,7 +200,7 @@ export interface GroupKeyActionEvent {
     /** the action id */
     actionId: string;
     eventTimestamp: Date | undefined;
-    /** the step event type */
+    /** the task event type */
     eventType: GroupKeyActionEventType;
     /** the event payload */
     eventPayload: string;
@@ -200,14 +212,14 @@ export interface StepActionEvent {
     jobId: string;
     /** the job run id */
     jobRunId: string;
-    /** the id of the step */
-    stepId: string;
-    /** the step run id */
-    stepRunId: string;
+    /** the id of the task */
+    taskId: string;
+    /** the task external run id */
+    taskRunExternalId: string;
     /** the action id */
     actionId: string;
     eventTimestamp: Date | undefined;
-    /** the step event type */
+    /** the task event type */
     eventType: StepActionEventType;
     /** the event payload */
     eventPayload: string;
@@ -248,9 +260,9 @@ export interface WorkflowEvent {
      * will hang up the connection but clients might want to case
      */
     hangup: boolean;
-    /** (optional) the max number of retries this step can handle */
-    stepRetries?: number | undefined;
-    /** (optional) the retry count of this step */
+    /** (optional) the max number of retries this task can handle */
+    taskRetries?: number | undefined;
+    /** (optional) the retry count of this task */
     retryCount?: number | undefined;
     eventIndex?: number | undefined;
 }
@@ -262,15 +274,15 @@ export interface WorkflowRunEvent {
     results: StepRunResult[];
 }
 export interface StepRunResult {
-    stepRunId: string;
-    stepReadableId: string;
+    taskRunExternalId: string;
+    taskName: string;
     jobRunId: string;
     error?: string | undefined;
     output?: string | undefined;
 }
 export interface OverridesData {
-    /** the step run id */
-    stepRunId: string;
+    /** the task run id */
+    taskRunExternalId: string;
     /** the path of the data to set */
     path: string;
     /** the value to set */
@@ -289,23 +301,29 @@ export interface HeartbeatRequest {
 export interface HeartbeatResponse {
 }
 export interface RefreshTimeoutRequest {
-    /** the id of the step run to release */
-    stepRunId: string;
+    /** the id of the task run to release */
+    taskRunExternalId: string;
     incrementTimeoutBy: string;
 }
 export interface RefreshTimeoutResponse {
     timeoutAt: Date | undefined;
 }
 export interface ReleaseSlotRequest {
-    /** the id of the step run to release */
-    stepRunId: string;
+    /** the id of the task run to release */
+    taskRunExternalId: string;
 }
 export interface ReleaseSlotResponse {
 }
+export interface GetVersionRequest {
+}
+export interface GetVersionResponse {
+    version: string;
+}
 export declare const WorkerLabels: MessageFns<WorkerLabels>;
 export declare const RuntimeInfo: MessageFns<RuntimeInfo>;
 export declare const WorkerRegisterRequest: MessageFns<WorkerRegisterRequest>;
 export declare const WorkerRegisterRequest_LabelsEntry: MessageFns<WorkerRegisterRequest_LabelsEntry>;
+export declare const WorkerRegisterRequest_SlotConfigEntry: MessageFns<WorkerRegisterRequest_SlotConfigEntry>;
 export declare const WorkerRegisterResponse: MessageFns<WorkerRegisterResponse>;
 export declare const UpsertWorkerLabelsRequest: MessageFns<UpsertWorkerLabelsRequest>;
 export declare const UpsertWorkerLabelsRequest_LabelsEntry: MessageFns<UpsertWorkerLabelsRequest_LabelsEntry>;
@@ -330,6 +348,8 @@ export declare const RefreshTimeoutRequest: MessageFns<RefreshTimeoutRequest>;
 export declare const RefreshTimeoutResponse: MessageFns<RefreshTimeoutResponse>;
 export declare const ReleaseSlotRequest: MessageFns<ReleaseSlotRequest>;
 export declare const ReleaseSlotResponse: MessageFns<ReleaseSlotResponse>;
+export declare const GetVersionRequest: MessageFns<GetVersionRequest>;
+export declare const GetVersionResponse: MessageFns<GetVersionResponse>;
 export type DispatcherDefinition = typeof DispatcherDefinition;
 export declare const DispatcherDefinition: {
     readonly name: "Dispatcher";
@@ -444,6 +464,19 @@ export declare const DispatcherDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /**
+         * GetVersion returns the dispatcher protocol version as a simple integer.
+         * SDKs use this to determine feature support (e.g. slot_config registration).
+         * Old engines that do not implement this RPC will return UNIMPLEMENTED.
+         */
+        readonly getVersion: {
+            readonly name: "GetVersion";
+            readonly requestType: MessageFns<GetVersionRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<GetVersionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 export interface DispatcherServiceImplementation<CallContextExt = {}> {
@@ -465,6 +498,12 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
     refreshTimeout(request: RefreshTimeoutRequest, context: CallContext & CallContextExt): Promise<DeepPartial<RefreshTimeoutResponse>>;
     releaseSlot(request: ReleaseSlotRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ReleaseSlotResponse>>;
     upsertWorkerLabels(request: UpsertWorkerLabelsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<UpsertWorkerLabelsResponse>>;
+    /**
+     * GetVersion returns the dispatcher protocol version as a simple integer.
+     * SDKs use this to determine feature support (e.g. slot_config registration).
+     * Old engines that do not implement this RPC will return UNIMPLEMENTED.
+     */
+    getVersion(request: GetVersionRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetVersionResponse>>;
 }
 export interface DispatcherClient<CallOptionsExt = {}> {
     register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
@@ -485,6 +524,12 @@ export interface DispatcherClient<CallOptionsExt = {}> {
     refreshTimeout(request: DeepPartial<RefreshTimeoutRequest>, options?: CallOptions & CallOptionsExt): Promise<RefreshTimeoutResponse>;
     releaseSlot(request: DeepPartial<ReleaseSlotRequest>, options?: CallOptions & CallOptionsExt): Promise<ReleaseSlotResponse>;
     upsertWorkerLabels(request: DeepPartial<UpsertWorkerLabelsRequest>, options?: CallOptions & CallOptionsExt): Promise<UpsertWorkerLabelsResponse>;
+    /**
+     * GetVersion returns the dispatcher protocol version as a simple integer.
+     * SDKs use this to determine feature support (e.g. slot_config registration).
+     * Old engines that do not implement this RPC will return UNIMPLEMENTED.
+     */
+    getVersion(request: DeepPartial<GetVersionRequest>, options?: CallOptions & CallOptionsExt): Promise<GetVersionResponse>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {