@hatchet-dev/typescript-sdk 0.9.0 → 0.10.1

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

@@ -6,6 +6,26 @@ export interface APIMeta {
      */
     pylonAppId?: string;
     posthog?: APIMetaPosthog;
+    /**
+     * whether or not users can sign up for this instance
+     * @example true
+     */
+    allowSignup?: boolean;
+    /**
+     * whether or not users can invite other users to this instance
+     * @example true
+     */
+    allowInvites?: boolean;
+    /**
+     * whether or not users can create new tenants
+     * @example true
+     */
+    allowCreateTenant?: boolean;
+    /**
+     * whether or not users can change their password
+     * @example true
+     */
+    allowChangePassword?: boolean;
 }
 export interface APIMetaAuth {
     /**
@@ -283,6 +303,19 @@ export interface TenantInviteList {
     pagination?: PaginationResponse;
     rows?: TenantInvite[];
 }
+export interface QueueMetrics {
+    /** The number of items in the queue. */
+    numQueued: number;
+    /** The number of items running. */
+    numRunning: number;
+    /** The number of items pending. */
+    numPending: number;
+}
+export interface TenantQueueMetrics {
+    /** The total queue metrics. */
+    total?: QueueMetrics;
+    workflow?: Record<string, QueueMetrics>;
+}
 export interface AcceptInviteRequest {
     /**
      * @minLength 36
@@ -342,6 +375,14 @@ export interface EventData {
     /** The data for the event (JSON bytes). */
     data: string;
 }
+export interface CreateEventRequest {
+    /** The key for the event. */
+    key: string;
+    /** The data for the event. */
+    data: object;
+    /** Additional metadata for the event. */
+    additionalMetadata?: object;
+}
 export interface EventWorkflowRunSummary {
     /**
      * The number of pending runs.
@@ -404,7 +445,6 @@ export interface Workflow {
     lastRun?: WorkflowRun;
     /** The jobs of the workflow. */
     jobs?: Job[];
-    deployment?: WorkflowDeploymentConfig;
 }
 export interface WorkflowConcurrency {
     /**
@@ -417,22 +457,6 @@ export interface WorkflowConcurrency {
     /** An action which gets the concurrency group for the WorkflowRun. */
     getConcurrencyGroup: string;
 }
-export interface WorkflowDeploymentConfig {
-    metadata: APIResourceMeta;
-    /** The repository name. */
-    gitRepoName: string;
-    /** The repository owner. */
-    gitRepoOwner: string;
-    /** The repository branch. */
-    gitRepoBranch: string;
-    /** The Github App installation. */
-    githubAppInstallation?: GithubAppInstallation;
-    /**
-     * The id of the Github App installation.
-     * @format uuid
-     */
-    githubAppInstallationId: string;
-}
 export interface WorkflowVersionMeta {
     metadata: APIResourceMeta;
     /** The version of the workflow. */
@@ -682,6 +706,33 @@ export interface StepRunEventList {
     pagination?: PaginationResponse;
     rows?: StepRunEvent[];
 }
+export interface StepRunArchive {
+    stepRunId: string;
+    order: number;
+    input?: string;
+    output?: string;
+    /** @format date-time */
+    startedAt?: string;
+    error?: string;
+    /** @format date-time */
+    createdAt: string;
+    startedAtEpoch?: number;
+    /** @format date-time */
+    finishedAt?: string;
+    finishedAtEpoch?: number;
+    /** @format date-time */
+    timeoutAt?: string;
+    timeoutAtEpoch?: number;
+    /** @format date-time */
+    cancelledAt?: string;
+    cancelledAtEpoch?: number;
+    cancelledReason?: string;
+    cancelledError?: string;
+}
+export interface StepRunArchiveList {
+    pagination?: PaginationResponse;
+    rows?: StepRunArchive[];
+}
 export interface WorkerList {
     pagination?: PaginationResponse;
     rows?: Worker[];
@@ -756,40 +807,6 @@ export interface TriggerWorkflowRunRequest {
     input: object;
     additionalMetadata?: object;
 }
-export interface LinkGithubRepositoryRequest {
-    /**
-     * The repository name.
-     * @minLength 36
-     * @maxLength 36
-     */
-    installationId: string;
-    /** The repository name. */
-    gitRepoName: string;
-    /** The repository owner. */
-    gitRepoOwner: string;
-    /** The repository branch. */
-    gitRepoBranch: string;
-}
-export interface GithubBranch {
-    branch_name: string;
-    is_default: boolean;
-}
-export interface GithubRepo {
-    repo_owner: string;
-    repo_name: string;
-}
-export interface GithubAppInstallation {
-    metadata: APIResourceMeta;
-    installation_settings_url: string;
-    account_name: string;
-    account_avatar_url: string;
-}
-export interface ListGithubAppInstallationsResponse {
-    pagination: PaginationResponse;
-    rows: GithubAppInstallation[];
-}
-export type ListGithubReposResponse = GithubRepo[];
-export type ListGithubBranchesResponse = GithubBranch[];
 export interface CreatePullRequestFromStepRun {
     branchName: string;
 }
@@ -894,3 +911,37 @@ export interface WorkflowMetrics {
     /** The total number of concurrency group keys. */
     groupKeyCount?: number;
 }
+export interface WebhookWorker {
+    metadata: APIResourceMeta;
+    /** The name of the webhook worker. */
+    name: string;
+    /** The webhook url. */
+    url: string;
+}
+export interface WebhookWorkerCreated {
+    metadata: APIResourceMeta;
+    /** The name of the webhook worker. */
+    name: string;
+    /** The webhook url. */
+    url: string;
+    /** The secret key for validation. */
+    secret: string;
+}
+export interface WebhookWorkerCreateRequest {
+    /** The name of the webhook worker. */
+    name: string;
+    /** The webhook url. */
+    url: string;
+    /**
+     * The secret key for validation. If not provided, a random secret will be generated.
+     * @minLength 32
+     */
+    secret?: string;
+}
+export interface WebhookWorkerCreateResponse {
+    worker?: WebhookWorkerCreated;
+}
+export interface WebhookWorkerListResponse {
+    pagination?: PaginationResponse;
+    rows?: WebhookWorker[];
+}

package/clients/worker/handler.d.ts

@@ -0,0 +1,58 @@
+import { IncomingMessage, ServerResponse } from 'http';
+import { Workflow } from '../../workflow';
+import { Worker } from './worker';
+export interface HandlerOpts {
+    secret: string;
+}
+export declare class WebhookHandler {
+    private worker;
+    private workflows;
+    constructor(worker: Worker, workflows: Workflow[]);
+    /**
+     * 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, signature: string | string[] | undefined | null, secret: string | undefined): Promise<void>;
+    private checkSignature;
+    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,200 @@
+"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 okMessage = 'The Hatchet webhooks endpoint is up and running!';
+class WebhookHandler {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(worker, workflows
+    // eslint-disable-next-line no-empty-function
+    ) {
+        this.worker = worker;
+        this.workflows = workflows;
+    }
+    /**
+     * 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, signature, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkSignature(body, signature, secret);
+            const action = JSON.parse(body);
+            yield this.worker.handleAction(action);
+        });
+    }
+    checkSignature(body, signature, secret) {
+        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}`);
+        }
+    }
+    getHealthcheckResponse(body, signature, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkSignature(body, signature, secret);
+            for (const workflow of this.workflows) {
+                yield this.worker.registerWorkflow(workflow);
+            }
+            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.send(okMessage);
+                return;
+            }
+            if (req.method === 'PUT') {
+                this.getHealthcheckResponse(req.body, req.headers['x-hatchet-signature'], secret)
+                    .then((resp) => {
+                    res.sendStatus(200);
+                    res.json(resp);
+                })
+                    .catch((err) => {
+                    res.sendStatus(500);
+                    this.worker.logger.error(`Error handling request: ${err.message}`);
+                });
+                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((err) => {
+                res.sendStatus(500);
+                this.worker.logger.error(`Error handling request: ${err.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(okMessage);
+                    res.end();
+                    return;
+                }
+                const body = yield this.getBody(req);
+                if (req.method === 'PUT') {
+                    const resp = yield this.getHealthcheckResponse(body, req.headers['x-hatchet-signature'], secret);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.write(JSON.stringify(resp));
+                    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;
+                }
+                yield this.handle(body, req.headers['x-hatchet-signature'], secret);
+                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 ok = () => __awaiter(this, void 0, void 0, function* () {
+            return new Response(okMessage, { status: 200 });
+        });
+        const f = (req) => __awaiter(this, void 0, void 0, function* () {
+            const sig = req.headers.get('x-hatchet-signature');
+            const body = yield req.text();
+            if (req.method === 'PUT') {
+                const resp = yield this.getHealthcheckResponse(body, sig, secret);
+                return new Response(JSON.stringify(resp), { status: 200 });
+            }
+            if (req.method !== 'POST') {
+                return new Response('Method not allowed', { status: 405 });
+            }
+            yield this.handle(body, sig, secret);
+            return new Response('ok', { status: 200 });
+        });
+        return {
+            GET: ok,
+            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 {
@@ -23,18 +25,22 @@ export declare class Worker {
         handleKill?: boolean;
         maxRuns?: number;
     });
+    private registerActions;
+    getHandler(workflows: Workflow[]): WebhookHandler;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorkerCreated, any>>;
     /**
      * @deprecated use registerWorkflow instead
      */
     register_workflow(initWorkflow: Workflow): Promise<void>;
     registerWorkflow(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>;
 }