@hatchet-dev/typescript-sdk 0.7.4 → 0.8.0-alpha.1

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

@@ -3,7 +3,7 @@ import { CreateWorkflowVersionOpts, RateLimitDuration, WorkflowServiceClient } f
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { Api } from '../rest';
-import { WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
+import { WebhookWorkerCreateRequest, WorkflowRunStatus } from '../rest/generated/data-contracts';
 type WorkflowMetricsQuery = {
     workflowId?: string;
     workflowName?: string;
@@ -40,6 +40,7 @@ export declare class AdminClient {
      */
     put_workflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
     put_rate_limit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
+    webhook_create(data: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.
@@ -88,10 +89,6 @@ export declare class AdminClient {
         limit?: number | undefined;
         eventId?: string | undefined;
         workflowId?: string | undefined;
-        parentWorkflowRunId?: string | undefined;
-        parentStepRunId?: string | undefined;
-        statuses?: WorkflowRunStatusList | undefined;
-        additionalMetadata?: string[] | undefined;
     }): Promise<import("../rest/generated/data-contracts").WorkflowRunList>;
     /**
      * Schedule a workflow to run at a specific time or times.

package/clients/admin/admin-client.js

@@ -72,6 +72,11 @@ class AdminClient {
             }
         });
     }
+    webhook_create(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.api.webhookCreate(this.tenantId, data);
+        });
+    }
     /**
      * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
      * new run.

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

@@ -1,14 +1,57 @@
 import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
+import { z } from 'zod';
 import { DispatcherClient } from './dispatcher-client';
 import { Heartbeat } from './heartbeat/heartbeat-controller';
 declare enum ListenStrategy {
     LISTEN_STRATEGY_V1 = 1,
     LISTEN_STRATEGY_V2 = 2
 }
-export interface Action extends AssignedAction {
-}
+export declare const ActionObject: z.ZodObject<{
+    tenantId: z.ZodString;
+    jobId: z.ZodString;
+    jobName: z.ZodString;
+    jobRunId: z.ZodString;
+    stepId: z.ZodString;
+    stepRunId: z.ZodString;
+    actionId: z.ZodString;
+    actionType: z.ZodEffects<z.ZodOptional<z.ZodNumber>, number | undefined, unknown>;
+    actionPayload: z.ZodString;
+    workflowRunId: z.ZodString;
+    getGroupKeyRunId: z.ZodOptional<z.ZodString>;
+    stepName: z.ZodString;
+    retryCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    tenantId: string;
+    stepRunId: string;
+    workflowRunId: string;
+    jobId: string;
+    jobName: string;
+    jobRunId: string;
+    stepId: string;
+    actionId: string;
+    actionPayload: string;
+    stepName: string;
+    retryCount: number;
+    getGroupKeyRunId?: string | undefined;
+    actionType?: number | undefined;
+}, {
+    tenantId: string;
+    stepRunId: string;
+    workflowRunId: string;
+    jobId: string;
+    jobName: string;
+    jobRunId: string;
+    stepId: string;
+    actionId: string;
+    actionPayload: string;
+    stepName: string;
+    retryCount: number;
+    getGroupKeyRunId?: string | undefined;
+    actionType?: unknown;
+}>;
+export type Action = z.infer<typeof ActionObject>;
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;
@@ -22,7 +65,21 @@ export declare class ActionListener {
     listenStrategy: ListenStrategy;
     heartbeat: Heartbeat;
     constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
-    actions: () => AsyncGenerator<Action, void, unknown>;
+    actions: () => AsyncGenerator<{
+        tenantId: string;
+        stepRunId: string;
+        workflowRunId: string;
+        jobId: string;
+        jobName: string;
+        jobRunId: string;
+        stepId: string;
+        actionId: string;
+        actionPayload: string;
+        stepName: string;
+        retryCount: number;
+        getGroupKeyRunId?: string | undefined;
+        actionType?: number | undefined;
+    }, void, unknown>;
     setListenStrategy(strategy: ListenStrategy): Promise<void>;
     getListenStrategy(): Promise<ListenStrategy>;
     incrementRetries(): Promise<void>;

package/clients/dispatcher/action-listener.js

@@ -32,11 +32,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionListener = void 0;
+exports.ActionListener = exports.ActionObject = void 0;
+const dispatcher_1 = require("../../protoc/dispatcher");
 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 zod_1 = require("zod");
 const heartbeat_controller_1 = require("./heartbeat/heartbeat-controller");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 20;
@@ -46,6 +48,21 @@ var ListenStrategy;
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
 })(ListenStrategy || (ListenStrategy = {}));
+exports.ActionObject = zod_1.z.object({
+    tenantId: zod_1.z.string(),
+    jobId: zod_1.z.string(),
+    jobName: zod_1.z.string(),
+    jobRunId: zod_1.z.string(),
+    stepId: zod_1.z.string(),
+    stepRunId: zod_1.z.string(),
+    actionId: zod_1.z.string(),
+    actionType: zod_1.z.preprocess((s) => (0, dispatcher_1.actionTypeFromJSON)(s), zod_1.z.number().optional()),
+    actionPayload: zod_1.z.string(),
+    workflowRunId: zod_1.z.string(),
+    getGroupKeyRunId: zod_1.z.string().optional(),
+    stepName: zod_1.z.string(),
+    retryCount: zod_1.z.number(),
+});
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;

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

@@ -29,4 +29,5 @@ export declare class HatchetClient {
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     run(workflow: string | Workflow): Promise<Worker>;
     worker(workflow: string | Workflow, maxRuns?: number): Promise<Worker>;
+    webhooks(workflow: Workflow): import("../worker/handler").WebhookHandler;
 }

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

@@ -142,5 +142,11 @@ class HatchetClient {
             return worker;
         });
     }
+    webhooks(workflow) {
+        const worker = new worker_1.Worker(this, {
+            name: workflow.id,
+        });
+        return worker.getHandler(workflow);
+    }
 }
 exports.HatchetClient = HatchetClient;

package/clients/rest/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { APIMeta, AcceptInviteRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreatePullRequestFromStepRun, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, GetStepRunDiffResponse, LinkGithubRepositoryRequest, ListAPIMetaIntegration, ListAPITokensResponse, ListGithubAppInstallationsResponse, ListGithubBranchesResponse, ListGithubReposResponse, ListPullRequestsResponse, ListSNSIntegrations, ListSlackWebhooks, LogLineLevelField, LogLineList, LogLineOrderByDirection, LogLineOrderByField, LogLineSearch, PullRequestState, RejectInviteRequest, ReplayEventRequest, RerunStepRunRequest, SNSIntegration, StepRun, StepRunEventList, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantResourcePolicy, TriggerWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, Worker, WorkerList, Workflow, WorkflowID, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunStatus, WorkflowRunStatusList, WorkflowRunsCancelRequest, WorkflowRunsMetrics, WorkflowVersion, WorkflowVersionDefinition } from './data-contracts';
+import { APIMeta, AcceptInviteRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreatePullRequestFromStepRun, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, GetStepRunDiffResponse, LinkGithubRepositoryRequest, ListAPIMetaIntegration, ListAPITokensResponse, ListGithubAppInstallationsResponse, ListGithubBranchesResponse, ListGithubReposResponse, ListPullRequestsResponse, ListSNSIntegrations, ListSlackWebhooks, LogLineLevelField, LogLineList, LogLineOrderByDirection, LogLineOrderByField, LogLineSearch, PullRequestState, RejectInviteRequest, ReplayEventRequest, RerunStepRunRequest, SNSIntegration, StepRun, StepRunEventList, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantResourcePolicy, TriggerWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, WebhookWorker, WebhookWorkerCreateRequest, WebhookWorkerListResponse, Worker, WorkerList, Workflow, WorkflowID, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunStatus, WorkflowRunStatusList, WorkflowRunsCancelRequest, WorkflowRunsMetrics, WorkflowVersion, WorkflowVersionDefinition } from './data-contracts';
 import { HttpClient, RequestParams } from './http-client';
 export declare class Api<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
     /**
@@ -919,4 +919,21 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
      * @secure
      */
     githubAppListBranches: (ghInstallation: string, ghRepoOwner: string, ghRepoName: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<ListGithubBranchesResponse, any>>;
+    /**
+     * @description Lists all webhooks
+     *
+     * @name WebhookList
+     * @summary List webhooks
+     * @request GET:/api/v1/webhook-workers/{tenant}
+     * @secure
+     */
+    webhookList: (tenant: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<WebhookWorkerListResponse, any>>;
+    /**
+     * @description Creates a webhook
+     *
+     * @name WebhookCreate
+     * @summary Create a webhook
+     * @request POST:/api/v1/webhook-workers/{tenant}/create
+     */
+    webhookCreate: (tenant: string, data: WebhookWorkerCreateRequest, params?: RequestParams) => Promise<import("axios").AxiosResponse<WebhookWorker, any>>;
 }

package/clients/rest/generated/Api.js

@@ -761,6 +761,23 @@ class Api extends http_client_1.HttpClient {
          * @secure
          */
         this.githubAppListBranches = (ghInstallation, ghRepoOwner, ghRepoName, params = {}) => this.request(Object.assign({ path: `/api/v1/github-app/installations/${ghInstallation}/repos/${ghRepoOwner}/${ghRepoName}/branches`, method: 'GET', secure: true, format: 'json' }, params));
+        /**
+         * @description Lists all webhooks
+         *
+         * @name WebhookList
+         * @summary List webhooks
+         * @request GET:/api/v1/webhook-workers/{tenant}
+         * @secure
+         */
+        this.webhookList = (tenant, params = {}) => this.request(Object.assign({ path: `/api/v1/webhook-workers/${tenant}`, method: 'GET', secure: true, format: 'json' }, params));
+        /**
+         * @description Creates a webhook
+         *
+         * @name WebhookCreate
+         * @summary Create a webhook
+         * @request POST:/api/v1/webhook-workers/{tenant}/create
+         */
+        this.webhookCreate = (tenant, data, params = {}) => this.request(Object.assign({ path: `/api/v1/webhook-workers/${tenant}/create`, method: 'POST', body: data, type: http_client_1.ContentType.Json, format: 'json' }, params));
     }
 }
 exports.Api = Api;

package/clients/rest/generated/data-contracts.d.ts

@@ -894,3 +894,28 @@ export interface WorkflowMetrics {
     /** The total number of concurrency group keys. */
     groupKeyCount?: number;
 }
+export interface WebhookWorker {
+    metadata: APIResourceMeta;
+    /** The webhook url. */
+    url: string;
+    /** The secret key for validation. */
+    secret: string;
+}
+export interface WebhookWorkerCreateRequest {
+    /** The webhook url. */
+    url: string;
+    /** The workflow IDs or names to register for this webhook worker. If not provided, workflows will be automatically detected. */
+    workflows?: string[];
+    /**
+     * The secret key for validation. If not provided, a random secret will be generated.
+     * @minLength 32
+     */
+    secret?: string;
+}
+export interface WebhookWorkerCreateResponse {
+    worker?: WebhookWorker;
+}
+export interface WebhookWorkerListResponse {
+    pagination?: PaginationResponse;
+    rows?: WebhookWorker[];
+}

package/clients/worker/handler.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { Worker } from './worker';
+export interface HandlerOpts {
+    secret: string;
+}
+export declare class WebhookHandler {
+    private worker;
+    constructor(worker: Worker);
+    /**
+     * Handles a request with a provided body, secret, and signature.
+     *
+     * @param {string | undefined} body - The body of the request.
+     * @param {string | undefined} secret - The secret used for signature verification.
+     * @param {string | string[] | undefined | null} signature - The signature of the request.
+     *
+     * @throws {HatchetError} - If no signature is provided or the signature is not a string.
+     * @throws {HatchetError} - If no secret is provided.
+     * @throws {HatchetError} - If no body is provided.
+     */
+    handle(body: string | undefined, secret: string | undefined, signature: string | string[] | undefined | null): Promise<void>;
+    private getHealthcheckResponse;
+    /**
+     * Express Handler
+     *
+     * This method is an asynchronous function that returns an Express middleware handler.
+     * The handler function is responsible for handling incoming requests and invoking the
+     * corresponding logic based on the provided secret.
+     *
+     * @param {string} secret - The secret key used to authenticate and authorize the incoming requests.
+     *
+     * @return {Function} - An Express middleware handler function that receives the request and response objects.
+     */
+    expressHandler({ secret }: HandlerOpts): (req: any, res: any) => void;
+    /**
+     * A method that returns an HTTP request handler.
+     *
+     * @param {string} secret - The secret key used for verification.
+     *
+     * @returns {function} - An HTTP request handler function.
+     */
+    httpHandler({ secret }: HandlerOpts): (req: IncomingMessage, res: ServerResponse) => void;
+    /**
+     * A method that returns a Next.js request handler.
+     *
+     * @param {any} req - The request object received from Next.js.
+     * @param {string} secret - The secret key used to verify the request.
+     * @return {Promise<Response>} - A Promise that resolves with a Response object.
+     */
+    nextJSHandler({ secret }: HandlerOpts): {
+        GET: () => Promise<Response>;
+        POST: (req: Request) => Promise<Response>;
+        PUT: (req: Request) => Promise<Response>;
+    };
+    private getBody;
+}

package/clients/worker/handler.js

@@ -0,0 +1,160 @@
+"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.WebhookHandler = void 0;
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const crypto_1 = require("crypto");
+const action_listener_1 = require("../dispatcher/action-listener");
+class WebhookHandler {
+    // eslint-disable-next-line no-useless-constructor,no-empty-function
+    constructor(worker) {
+        this.worker = worker;
+    }
+    /**
+     * Handles a request with a provided body, secret, and signature.
+     *
+     * @param {string | undefined} body - The body of the request.
+     * @param {string | undefined} secret - The secret used for signature verification.
+     * @param {string | string[] | undefined | null} signature - The signature of the request.
+     *
+     * @throws {HatchetError} - If no signature is provided or the signature is not a string.
+     * @throws {HatchetError} - If no secret is provided.
+     * @throws {HatchetError} - If no body is provided.
+     */
+    handle(body, secret, signature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!signature || typeof signature !== 'string') {
+                throw new hatchet_error_1.default('No signature provided');
+            }
+            if (!secret) {
+                throw new hatchet_error_1.default('No secret provided');
+            }
+            if (!body) {
+                throw new hatchet_error_1.default('No body provided');
+            }
+            // verify hmac signature
+            const actualSignature = (0, crypto_1.createHmac)('sha256', secret).update(body).digest('hex');
+            if (actualSignature !== signature) {
+                throw new hatchet_error_1.default(`Invalid signature, expected ${actualSignature}, got ${signature}`);
+            }
+            const action = action_listener_1.ActionObject.parse(JSON.parse(body));
+            yield this.worker.handleAction(action);
+        });
+    }
+    getHealthcheckResponse() {
+        return {
+            actions: Object.keys(this.worker.action_registry),
+        };
+    }
+    /**
+     * Express Handler
+     *
+     * This method is an asynchronous function that returns an Express middleware handler.
+     * The handler function is responsible for handling incoming requests and invoking the
+     * corresponding logic based on the provided secret.
+     *
+     * @param {string} secret - The secret key used to authenticate and authorize the incoming requests.
+     *
+     * @return {Function} - An Express middleware handler function that receives the request and response objects.
+     */
+    expressHandler({ secret }) {
+        return (req, res) => {
+            if (req.method === 'GET') {
+                res.sendStatus(200);
+                res.json(this.getHealthcheckResponse());
+                return;
+            }
+            if (req.method !== 'POST') {
+                res.sendStatus(405);
+                res.json({ error: 'Method not allowed' });
+                return;
+            }
+            this.handle(req.body, req.headers['x-hatchet-signature'], secret)
+                .then(() => {
+                res.sendStatus(200);
+            })
+                .catch((e) => {
+                res.sendStatus(500);
+                this.worker.logger.error(`Error handling request: ${e.message}`);
+            });
+        };
+    }
+    /**
+     * A method that returns an HTTP request handler.
+     *
+     * @param {string} secret - The secret key used for verification.
+     *
+     * @returns {function} - An HTTP request handler function.
+     */
+    httpHandler({ secret }) {
+        return (req, res) => {
+            const handle = () => __awaiter(this, void 0, void 0, function* () {
+                if (req.method === 'GET') {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.write(JSON.stringify(this.getHealthcheckResponse()));
+                    res.end();
+                    return;
+                }
+                if (req.method !== 'POST') {
+                    res.writeHead(405, { 'Content-Type': 'application/json' });
+                    res.write(JSON.stringify({ error: 'Method not allowed' }));
+                    res.end();
+                    return;
+                }
+                const body = yield this.getBody(req);
+                yield this.handle(body, secret, req.headers['x-hatchet-signature']);
+                res.writeHead(200, 'OK');
+                res.end();
+            });
+            handle().catch((e) => {
+                this.worker.logger.error(`Error handling request: ${e.message}`);
+                res.writeHead(500, 'Internal server error');
+                res.end();
+            });
+        };
+    }
+    /**
+     * A method that returns a Next.js request handler.
+     *
+     * @param {any} req - The request object received from Next.js.
+     * @param {string} secret - The secret key used to verify the request.
+     * @return {Promise<Response>} - A Promise that resolves with a Response object.
+     */
+    nextJSHandler({ secret }) {
+        const healthcheck = () => __awaiter(this, void 0, void 0, function* () {
+            return new Response(JSON.stringify(this.getHealthcheckResponse()), { status: 200 });
+        });
+        const f = (req) => __awaiter(this, void 0, void 0, function* () {
+            yield this.handle(yield req.text(), secret, req.headers.get('x-hatchet-signature'));
+            return new Response('ok', { status: 200 });
+        });
+        return {
+            GET: healthcheck,
+            POST: f,
+            PUT: f,
+        };
+    }
+    getBody(req) {
+        return new Promise((resolve) => {
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                resolve(body);
+            });
+        });
+    }
+}
+exports.WebhookHandler = WebhookHandler;

package/clients/worker/worker.d.ts

@@ -4,6 +4,8 @@ import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActi
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
 import { Workflow } from '../../workflow';
 import { Logger } from '../../util/logger';
+import { WebhookHandler } from './handler';
+import { WebhookWorkerCreateRequest } from '../rest/generated/data-contracts';
 import { Context, StepRunFunction } from '../../step';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export declare class Worker {
@@ -18,20 +20,25 @@ export declare class Worker {
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
+    registeredWorkflowIds: string[];
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;
     });
+    private registerActions;
+    getHandler(workflow: Workflow): WebhookHandler;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
     registerWorkflow(initWorkflow: Workflow): Promise<void>;
     register_workflow(initWorkflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
-    handleStartStepRun(action: Action): void;
-    handleStartGroupKeyRun(action: Action): void;
+    handleStartStepRun(action: Action): Promise<void>;
+    handleStartGroupKeyRun(action: Action): Promise<void>;
     getStepActionEvent(action: Action, eventType: StepActionEventType, payload?: any): StepActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
-    handleCancelStepRun(action: Action): void;
+    handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
     start(): Promise<void>;
+    handleAction(action: Action): Promise<void>;
 }

package/clients/worker/worker.js

@@ -25,13 +25,14 @@ const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const logger_1 = require("../../util/logger");
-// import sleep from '../../util/sleep.js';
+const handler_1 = require("./handler");
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {
         this.futures = {};
         this.contexts = {};
         this.registeredWorkflowPromises = [];
+        this.registeredWorkflowIds = [];
         this.client = client;
         this.name = this.client.config.namespace + options.name;
         this.action_registry = {};
@@ -42,6 +43,31 @@ class Worker {
         this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
         this.logger = new logger_1.Logger(`Worker/${this.name}`, this.client.config.log_level);
     }
+    registerActions(workflow) {
+        var _a;
+        const newActions = workflow.steps.reduce((acc, step) => {
+            acc[`${workflow.id}:${step.name}`] = step.run;
+            return acc;
+        }, {});
+        const onFailureAction = workflow.onFailure
+            ? {
+                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
+            }
+            : {};
+        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+        this.action_registry = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
+            ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+    }
+    getHandler(workflow) {
+        const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
+        this.registerActions(wf);
+        return new handler_1.WebhookHandler(this);
+    }
+    registerWebhook(webhook) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.admin.webhook_create(Object.assign(Object.assign({}, webhook), { workflows: this.registeredWorkflowIds }));
+        });
+    }
     // @deprecated
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -50,7 +76,7 @@ class Worker {
     }
     register_workflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b;
             const workflow = Object.assign(Object.assign({}, initWorkflow), { id: this.client.config.namespace + initWorkflow.id });
             try {
                 const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
@@ -78,6 +104,7 @@ class Worker {
                         ],
                     }
                     : undefined;
+                this.registeredWorkflowIds.push(workflow.id);
                 const registeredWorkflow = this.client.admin.put_workflow({
                     name: workflow.id,
                     description: workflow.description,
@@ -114,145 +141,153 @@ class Worker {
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
             }
-            const newActions = workflow.steps.reduce((acc, step) => {
-                acc[`${workflow.id}:${step.name}`] = step.run;
-                return acc;
-            }, {});
-            const onFailureAction = workflow.onFailure
-                ? {
-                    [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
-                }
-                : {};
-            this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
-            this.action_registry = ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.name)
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+            this.registerActions(workflow);
         });
     }
     registerAction(actionId, action) {
         this.action_registry[actionId] = action;
     }
     handleStartStepRun(action) {
-        const { actionId } = action;
-        try {
-            const context = new step_1.Context(action, this.client);
-            this.contexts[action.stepRunId] = context;
-            const step = this.action_registry[actionId];
-            if (!step) {
-                this.logger.error(`Could not find step '${actionId}'`);
-                return;
-            }
-            const run = () => __awaiter(this, void 0, void 0, function* () {
-                return step(context);
-            });
-            const success = (result) => {
-                this.logger.info(`Step run ${action.stepRunId} succeeded`);
-                try {
-                    // Send the action event to the dispatcher
-                    const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
-                    this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
-                        this.logger.error(`Could not send completed action event: ${e.message}`);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { actionId } = action;
+            try {
+                const context = new step_1.Context(action, this.client);
+                this.contexts[action.stepRunId] = context;
+                const step = this.action_registry[actionId];
+                if (!step) {
+                    this.logger.error(`Could not find step '${actionId}'`);
+                    return;
+                }
+                const run = () => __awaiter(this, void 0, void 0, function* () {
+                    return step(context);
+                });
+                const success = (result) => __awaiter(this, void 0, void 0, function* () {
+                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
+                        yield this.client.dispatcher.sendStepActionEvent(event);
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                    }
+                    catch (actionEventError) {
+                        this.logger.error(`Could not send completed action event: ${actionEventError.message}`);
                         // send a failure event
-                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, e.message);
-                        this.client.dispatcher.sendStepActionEvent(failureEvent).catch((err2) => {
-                            this.logger.error(`Could not send failed action event: ${err2.message}`);
+                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, actionEventError.message);
+                        try {
+                            yield this.client.dispatcher.sendStepActionEvent(failureEvent);
+                        }
+                        catch (failureEventError) {
+                            this.logger.error(`Could not send failed action event: ${failureEventError.message}`);
+                        }
+                        this.logger.error(`Could not send action event: ${actionEventError.message}`);
+                    }
+                });
+                const failure = (error) => __awaiter(this, void 0, void 0, function* () {
+                    this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
+                    if (error.stack) {
+                        this.logger.error(error.stack);
+                    }
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, {
+                            message: error === null || error === void 0 ? void 0 : error.message,
+                            stack: error === null || error === void 0 ? void 0 : error.stack,
                         });
-                    });
-                    // delete the run from the futures
-                    delete this.futures[action.stepRunId];
-                }
-                catch (e) {
-                    this.logger.error(`Could not send action event: ${e.message}`);
-                }
-            };
-            const failure = (error) => {
-                this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
-                if (error.stack) {
-                    this.logger.error(error.stack);
-                }
-                try {
-                    // Send the action event to the dispatcher
-                    const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, {
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                        stack: error === null || error === void 0 ? void 0 : error.stack,
-                    });
-                    this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
+                        yield this.client.dispatcher.sendStepActionEvent(event);
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                    }
+                    catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
-                    });
-                    // delete the run from the futures
-                    delete this.futures[action.stepRunId];
-                }
-                catch (e) {
+                    }
+                });
+                const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield run();
+                    }
+                    catch (e) {
+                        yield failure(e);
+                        return;
+                    }
+                    yield success(null);
+                }))());
+                this.futures[action.stepRunId] = future;
+                // Send the action event to the dispatcher
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
+                this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
-                }
-            };
-            const future = new hatchet_promise_1.default(run().then(success).catch(failure));
-            this.futures[action.stepRunId] = future;
-            // Send the action event to the dispatcher
-            const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
-            this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
+                });
+                yield future.promise;
+            }
+            catch (e) {
                 this.logger.error(`Could not send action event: ${e.message}`);
-            });
-        }
-        catch (e) {
-            this.logger.error(`Could not send action event: ${e.message}`);
-        }
+            }
+        });
     }
     handleStartGroupKeyRun(action) {
-        const { actionId } = action;
-        try {
-            const context = new step_1.Context(action, this.client);
-            const key = action.getGroupKeyRunId;
-            this.contexts[key] = context;
-            this.logger.debug(`Starting group key run ${key}`);
-            const step = this.action_registry[actionId];
-            if (!step) {
-                this.logger.error(`Could not find step '${actionId}'`);
-                return;
-            }
-            const run = () => __awaiter(this, void 0, void 0, function* () {
-                return step(context);
-            });
-            const success = (result) => {
-                this.logger.info(`Step run ${action.stepRunId} succeeded`);
-                try {
-                    // Send the action event to the dispatcher
-                    const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
-                    this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    });
-                    // delete the run from the futures
-                    delete this.futures[key];
+        return __awaiter(this, void 0, void 0, function* () {
+            const { actionId } = action;
+            try {
+                const context = new step_1.Context(action, this.client);
+                const key = action.getGroupKeyRunId;
+                if (!key) {
+                    this.logger.error(`No group key run id provided for action ${actionId}`);
+                    return;
                 }
-                catch (e) {
-                    this.logger.error(`Could not send action event: ${e.message}`);
+                this.contexts[key] = context;
+                this.logger.debug(`Starting group key run ${key}`);
+                const step = this.action_registry[actionId];
+                if (!step) {
+                    this.logger.error(`Could not find step '${actionId}'`);
+                    return;
                 }
-            };
-            const failure = (error) => {
-                this.logger.error(`Step run ${key} failed: ${error.message}`);
-                try {
-                    // Send the action event to the dispatcher
-                    const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
-                    this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                const run = () => __awaiter(this, void 0, void 0, function* () {
+                    return step(context);
+                });
+                const success = (result) => {
+                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
+                        this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                            this.logger.error(`Could not send action event: ${e.message}`);
+                        });
+                        // delete the run from the futures
+                        delete this.futures[key];
+                    }
+                    catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
-                    });
-                    // delete the run from the futures
-                    delete this.futures[key];
-                }
-                catch (e) {
+                    }
+                };
+                const failure = (error) => {
+                    this.logger.error(`Step run ${key} failed: ${error.message}`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
+                        this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                            this.logger.error(`Could not send action event: ${e.message}`);
+                        });
+                        // delete the run from the futures
+                        delete this.futures[key];
+                    }
+                    catch (e) {
+                        this.logger.error(`Could not send action event: ${e.message}`);
+                    }
+                };
+                const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+                this.futures[key] = future;
+                // Send the action event to the dispatcher
+                const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_STARTED);
+                this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
-                }
-            };
-            const future = new hatchet_promise_1.default(run().then(success).catch(failure));
-            this.futures[action.getGroupKeyRunId] = future;
-            // Send the action event to the dispatcher
-            const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_STARTED);
-            this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                });
+                yield future.promise;
+            }
+            catch (e) {
                 this.logger.error(`Could not send action event: ${e.message}`);
-            });
-        }
-        catch (e) {
-            this.logger.error(`Could not send action event: ${e.message}`);
-        }
+            }
+        });
     }
     getStepActionEvent(action, eventType, payload = '') {
         return {
@@ -268,6 +303,9 @@ class Worker {
         };
     }
     getGroupKeyActionEvent(action, eventType, payload = '') {
+        if (!action.getGroupKeyRunId) {
+            throw new hatchet_error_1.default('No group key run id provided');
+        }
         return {
             workerId: this.name,
             workflowRunId: action.workflowRunId,
@@ -279,26 +317,29 @@ class Worker {
         };
     }
     handleCancelStepRun(action) {
-        try {
-            this.logger.info(`Cancelling step run ${action.stepRunId}`);
-            const { stepRunId } = action;
-            const future = this.futures[stepRunId];
-            const context = this.contexts[stepRunId];
-            if (context && context.controller) {
-                context.controller.abort('Cancelled by worker');
-                delete this.contexts[stepRunId];
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.info(`Cancelling step run ${action.stepRunId}`);
+                const { stepRunId } = action;
+                const future = this.futures[stepRunId];
+                const context = this.contexts[stepRunId];
+                if (context && context.controller) {
+                    context.controller.abort('Cancelled by worker');
+                    delete this.contexts[stepRunId];
+                }
+                if (future) {
+                    future.promise.catch(() => {
+                        this.logger.info(`Cancelled step run ${action.stepRunId}`);
+                    });
+                    future.cancel('Cancelled by worker');
+                    yield future.promise;
+                    delete this.futures[stepRunId];
+                }
             }
-            if (future) {
-                future.promise.catch(() => {
-                    this.logger.info(`Cancelled step run ${action.stepRunId}`);
-                });
-                future.cancel('Cancelled by worker');
-                delete this.futures[stepRunId];
+            catch (e) {
+                this.logger.error(`Could not cancel step run: ${e.message}`);
             }
-        }
-        catch (e) {
-            this.logger.error(`Could not cancel step run: ${e.message}`);
-        }
+        });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -346,18 +387,7 @@ class Worker {
                         _d = false;
                         const action = _c;
                         this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
-                        if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
-                            this.handleStartStepRun(action);
-                        }
-                        else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
-                            this.handleCancelStepRun(action);
-                        }
-                        else if (action.actionType === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
-                            this.handleStartGroupKeyRun(action);
-                        }
-                        else {
-                            this.logger.error(`Worker ${this.name} received unknown action type ${action.actionType}`);
-                        }
+                        void this.handleAction(action);
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -379,5 +409,24 @@ class Worker {
             }
         });
     }
+    handleAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = action.actionType
+                ? (0, dispatcher_1.actionTypeFromJSON)(action.actionType)
+                : dispatcher_1.ActionType.START_STEP_RUN;
+            if (type === dispatcher_1.ActionType.START_STEP_RUN) {
+                yield this.handleStartStepRun(action);
+            }
+            else if (type === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
+                yield this.handleCancelStepRun(action);
+            }
+            else if (type === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
+                yield this.handleStartGroupKeyRun(action);
+            }
+            else {
+                this.logger.error(`Worker ${this.name} received unknown action type ${type}`);
+            }
+        });
+    }
 }
 exports.Worker = Worker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.7.4",
+  "version": "0.8.0-alpha.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -19,7 +19,7 @@
     "prepare": "npm run build",
     "tsc:build": "tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
-    "test:e2e": "jest --testMatch='**/*.e2e.ts'",
+    "test:e2e": "jest --testMatch='**/*.e2e.ts' --runInBand --detectOpenHandles",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",
     "generate-api": "npx --yes swagger-cli bundle ./hatchet/api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
@@ -100,4 +100,4 @@
     "yaml": "^2.3.4",
     "zod": "^3.22.4"
   }
-}
+}

package/util/parse.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJSON = void 0;
 function parseJSON(json) {
+    // TODO why is this needed?
+    if (json.startsWith('ey')) {
+        const decoded = Buffer.from(json, 'base64').toString('utf8');
+        return JSON.parse(decoded);
+    }
     try {
         const firstParse = JSON.parse(json);
         // Hatchet engine versions <=0.14.0 return JSON as a quoted string which needs to be parsed again.