@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/clients/worker/worker.js

@@ -1,568 +0,0 @@
-"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 __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.V0Worker = void 0;
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const action_listener_1 = require("../dispatcher/action-listener");
-const dispatcher_1 = require("../../protoc/dispatcher");
-const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
-const workflows_1 = require("../../protoc/workflows");
-const handler_1 = require("./handler");
-const task_1 = require("../../v1/task");
-const apply_namespace_1 = require("../../util/apply-namespace");
-const step_1 = require("../../step");
-class V0Worker {
-    constructor(client, options) {
-        this.workflow_registry = [];
-        this.futures = {};
-        this.contexts = {};
-        this.registeredWorkflowPromises = [];
-        this.labels = {};
-        this.client = client;
-        this.name = (0, apply_namespace_1.applyNamespace)(options.name, this.client.config.namespace);
-        this.action_registry = {};
-        this.maxRuns = options.maxRuns;
-        this.labels = options.labels || {};
-        process.on('SIGTERM', () => this.exitGracefully(true));
-        process.on('SIGINT', () => this.exitGracefully(true));
-        this.killing = false;
-        this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
-        this.logger = client.config.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.toLowerCase()}`] = 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) && workflow.concurrency.key
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name.toLowerCase()}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
-    }
-    getHandler(workflows) {
-        // TODO v1
-        for (const workflow of workflows) {
-            const wf = Object.assign(Object.assign({}, workflow), { id: (0, apply_namespace_1.applyNamespace)(workflow.id, this.client.config.namespace) });
-            this.registerActions(wf);
-        }
-        return new handler_1.WebhookHandler(this, workflows);
-    }
-    registerWebhook(webhook) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.client.admin.registerWebhook(Object.assign({}, webhook));
-        });
-    }
-    /**
-     * @deprecated use registerWorkflow instead
-     */
-    register_workflow(initWorkflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.registerWorkflow(initWorkflow);
-        });
-    }
-    registerWorkflow(initWorkflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const workflow = Object.assign(Object.assign({}, initWorkflow), { id: (0, apply_namespace_1.applyNamespace)(initWorkflow.id, this.client.config.namespace).toLowerCase() });
-            try {
-                if (((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.key) && workflow.concurrency.expression) {
-                    throw new hatchet_error_1.default('Cannot have both key function and expression in workflow concurrency configuration');
-                }
-                const concurrency = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name) || ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.expression)
-                    ? {
-                        action: !workflow.concurrency.expression
-                            ? `${workflow.id}:${workflow.concurrency.name}`
-                            : undefined,
-                        maxRuns: workflow.concurrency.maxRuns || 1,
-                        expression: workflow.concurrency.expression,
-                        limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
-                    }
-                    : undefined;
-                const onFailureJob = workflow.onFailure
-                    ? {
-                        name: `${workflow.id}-on-failure`,
-                        description: workflow.description,
-                        steps: [
-                            {
-                                readableId: workflow.onFailure.name,
-                                action: `${workflow.id}-on-failure:${workflow.onFailure.name}`,
-                                timeout: workflow.onFailure.timeout || '60s',
-                                inputs: '{}',
-                                parents: [],
-                                userData: '{}',
-                                retries: workflow.onFailure.retries || 0,
-                                rateLimits: (0, step_1.mapRateLimit)(workflow.onFailure.rate_limits),
-                                workerLabels: {}, // no worker labels for on failure steps
-                            },
-                        ],
-                    }
-                    : undefined;
-                const registeredWorkflow = this.client.admin.putWorkflow({
-                    name: workflow.id,
-                    description: workflow.description,
-                    version: workflow.version || '',
-                    eventTriggers: workflow.on && workflow.on.event
-                        ? [(0, apply_namespace_1.applyNamespace)(workflow.on.event, this.client.config.namespace)]
-                        : [],
-                    cronTriggers: workflow.on && workflow.on.cron ? [workflow.on.cron] : [],
-                    scheduledTriggers: [],
-                    concurrency,
-                    scheduleTimeout: workflow.scheduleTimeout,
-                    onFailureJob,
-                    sticky: workflow.sticky,
-                    jobs: [
-                        {
-                            name: workflow.id,
-                            description: workflow.description,
-                            steps: workflow.steps.map((step) => {
-                                var _a, _b, _c;
-                                return ({
-                                    readableId: step.name,
-                                    action: `${workflow.id}:${step.name}`,
-                                    timeout: step.timeout || '60s',
-                                    inputs: '{}',
-                                    parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
-                                    userData: '{}',
-                                    retries: step.retries || 0,
-                                    rateLimits: (0, step_1.mapRateLimit)(step.rate_limits),
-                                    workerLabels: toPbWorkerLabel(step.worker_labels),
-                                    backoffFactor: (_b = step.backoff) === null || _b === void 0 ? void 0 : _b.factor,
-                                    backoffMaxSeconds: (_c = step.backoff) === null || _c === void 0 ? void 0 : _c.maxSeconds,
-                                });
-                            }),
-                        },
-                    ],
-                });
-                this.registeredWorkflowPromises.push(registeredWorkflow);
-                yield registeredWorkflow;
-                this.workflow_registry.push(workflow);
-            }
-            catch (e) {
-                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
-            }
-            this.registerActions(workflow);
-        });
-    }
-    registerAction(actionId, action) {
-        this.action_registry[actionId.toLowerCase()] = action;
-    }
-    handleStartStepRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
-            try {
-                // Note: we always use a DurableContext since its a superset of the Context class
-                const context = new step_1.V0DurableContext(action, this.client, this);
-                this.contexts[(0, action_listener_1.createActionKey)(action)] = context;
-                const step = this.action_registry[actionId];
-                if (!step) {
-                    this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
-                    this.logger.error(`Could not find step '${actionId}'`);
-                    return;
-                }
-                const run = () => __awaiter(this, void 0, void 0, function* () {
-                    const { middleware } = this.client.config;
-                    if (middleware === null || middleware === void 0 ? void 0 : middleware.before) {
-                        const hooks = Array.isArray(middleware.before) ? middleware.before : [middleware.before];
-                        for (const hook of hooks) {
-                            const extra = yield hook(context.input, context);
-                            if (extra !== undefined) {
-                                const merged = Object.assign(Object.assign({}, context.input), extra);
-                                context.input = merged;
-                                if (context.data && typeof context.data === 'object') {
-                                    context.data.input = merged;
-                                }
-                            }
-                        }
-                    }
-                    let result = yield step(context);
-                    if (middleware === null || middleware === void 0 ? void 0 : middleware.after) {
-                        const hooks = Array.isArray(middleware.after) ? middleware.after : [middleware.after];
-                        for (const hook of hooks) {
-                            const extra = yield hook(result, context, context.input);
-                            if (extra !== undefined) {
-                                result = Object.assign(Object.assign({}, result), extra);
-                            }
-                        }
-                    }
-                    return result;
-                });
-                const success = (result) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.info(`Task run ${action.taskRunExternalId} succeeded`);
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
-                        yield this.client.dispatcher.sendStepActionEvent(event);
-                    }
-                    catch (actionEventError) {
-                        this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
-                        // send a failure event
-                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, false, actionEventError.message, action.retryCount);
-                        try {
-                            yield this.client.dispatcher.sendStepActionEvent(failureEvent);
-                        }
-                        catch (failureEventError) {
-                            this.logger.error(`Could not send failed action event: ${failureEventError.message || failureEventError}`);
-                        }
-                        this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
-                    }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
-                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
-                    }
-                });
-                const failure = (error) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.error(`Task run ${action.taskRunExternalId} failed: ${error.message}`);
-                    if (error.stack) {
-                        this.logger.error(error.stack);
-                    }
-                    const shouldNotRetry = error instanceof task_1.NonRetryableError;
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, shouldNotRetry, {
-                            message: error === null || error === void 0 ? void 0 : error.message,
-                            stack: error === null || error === void 0 ? void 0 : error.stack,
-                        }, action.retryCount);
-                        yield this.client.dispatcher.sendStepActionEvent(event);
-                    }
-                    catch (e) {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
-                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
-                    }
-                });
-                const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
-                    let result;
-                    try {
-                        result = yield run();
-                    }
-                    catch (e) {
-                        yield failure(e);
-                        return;
-                    }
-                    yield success(result);
-                }))());
-                this.futures[(0, action_listener_1.createActionKey)(action)] = future;
-                // Send the action event to the dispatcher
-                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
-                this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
-                    this.logger.error(`Could not send action event: ${e.message}`);
-                });
-                try {
-                    yield future.promise;
-                }
-                catch (e) {
-                    const message = (e === null || e === void 0 ? void 0 : e.message) || String(e);
-                    if (message.includes('Cancelled')) {
-                        this.logger.debug(`Task run ${action.taskRunExternalId} was cancelled`);
-                    }
-                    else {
-                        this.logger.error(`Could not wait for task run ${action.taskRunExternalId} to finish. ` +
-                            `See https://docs.hatchet.run/home/cancellation for best practices on handling cancellation: `, e);
-                    }
-                }
-            }
-            catch (e) {
-                this.logger.error('Could not send action event (outer): ', e);
-            }
-        });
-    }
-    handleStartGroupKeyRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
-            try {
-                const context = new step_1.V0Context(action, this.client, this);
-                const key = (0, action_listener_1.createActionKey)(action);
-                if (!key) {
-                    this.logger.error(`No group key run id provided for action ${actionId}`);
-                    return;
-                }
-                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(`Task run ${action.taskRunExternalId} 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}`);
-                        });
-                    }
-                    catch (e) {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[key];
-                        delete this.contexts[key];
-                    }
-                };
-                const failure = (error) => {
-                    this.logger.error(`Task 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}`);
-                        });
-                    }
-                    catch (e) {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[key];
-                        delete this.contexts[key];
-                    }
-                };
-                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}`);
-                });
-                yield future.promise;
-            }
-            catch (e) {
-                this.logger.error(`Could not send action event: ${e.message}`);
-            }
-        });
-    }
-    getStepActionEvent(action, eventType, shouldNotRetry, payload = '', retryCount = 0) {
-        return {
-            workerId: this.name,
-            jobId: action.jobId,
-            jobRunId: action.jobRunId,
-            taskId: action.taskId,
-            taskRunExternalId: action.taskRunExternalId,
-            actionId: action.actionId,
-            eventTimestamp: new Date(),
-            eventType,
-            eventPayload: JSON.stringify(payload),
-            shouldNotRetry,
-            retryCount,
-        };
-    }
-    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,
-            getGroupKeyRunId: action.getGroupKeyRunId,
-            actionId: action.actionId,
-            eventTimestamp: new Date(),
-            eventType,
-            eventPayload: JSON.stringify(payload),
-        };
-    }
-    handleCancelStepRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { taskRunExternalId } = action;
-            try {
-                this.logger.info(`Cancelling task run ${action.taskRunExternalId}`);
-                const future = this.futures[(0, action_listener_1.createActionKey)(action)];
-                const context = this.contexts[(0, action_listener_1.createActionKey)(action)];
-                if (context && context.controller) {
-                    context.controller.abort('Cancelled by worker');
-                }
-                if (future) {
-                    future.promise.catch(() => {
-                        this.logger.info(`Cancelled task run ${action.taskRunExternalId}`);
-                    });
-                    future.cancel('Cancelled by worker');
-                    yield future.promise;
-                }
-            }
-            catch (e) {
-                // Expected: the promise rejects when cancelled
-                this.logger.debug(`Task run ${taskRunExternalId} cancellation completed`);
-            }
-            finally {
-                delete this.futures[(0, action_listener_1.createActionKey)(action)];
-                delete this.contexts[(0, action_listener_1.createActionKey)(action)];
-            }
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.exitGracefully(false);
-        });
-    }
-    exitGracefully(handleKill) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            this.killing = true;
-            this.logger.info('Starting to exit...');
-            try {
-                yield ((_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister());
-            }
-            catch (e) {
-                this.logger.error(`Could not unregister listener: ${e.message}`);
-            }
-            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
-            // attempt to wait for futures to finish
-            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
-            this.logger.info('Successfully finished pending tasks.');
-            if (handleKill) {
-                this.logger.info('Exiting hatchet worker...');
-                process.exit(0);
-            }
-        });
-    }
-    start() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            // ensure all workflows are registered
-            yield Promise.all(this.registeredWorkflowPromises);
-            if (Object.keys(this.action_registry).length === 0) {
-                return;
-            }
-            try {
-                this.listener = yield this.client.dispatcher.getActionListener({
-                    workerName: this.name,
-                    services: ['default'],
-                    actions: Object.keys(this.action_registry),
-                    maxRuns: this.maxRuns,
-                    labels: this.labels,
-                });
-                this.workerId = this.listener.workerId;
-                const generator = this.listener.actions();
-                this.logger.info(`Worker ${this.name} listening for actions`);
-                try {
-                    for (var _d = true, generator_1 = __asyncValues(generator), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
-                        _c = generator_1_1.value;
-                        _d = false;
-                        const action = _c;
-                        this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
-                        void this.handleAction(action);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            catch (e) {
-                if (this.killing) {
-                    this.logger.info(`Exiting worker, ignoring error: ${e.message}`);
-                    return;
-                }
-                this.logger.error(`Could not run worker: ${e.message}`);
-                throw new hatchet_error_1.default(`Could not run worker: ${e.message}`);
-            }
-        });
-    }
-    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}`);
-            }
-        });
-    }
-    upsertLabels(labels) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.labels = labels;
-            if (!this.workerId) {
-                this.logger.warn('Worker not registered.');
-                return this.labels;
-            }
-            this.client.dispatcher.upsertWorkerLabels(this.workerId, labels);
-            return this.labels;
-        });
-    }
-}
-exports.V0Worker = V0Worker;
-function toPbWorkerLabel(in_) {
-    if (!in_) {
-        return {};
-    }
-    return Object.entries(in_).reduce((acc, [key, value]) => {
-        if (!value) {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof value === 'string') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: value,
-                    intValue: undefined,
-                } });
-        }
-        if (typeof value === 'number') {
-            return Object.assign(Object.assign({}, acc), { [key]: {
-                    strValue: undefined,
-                    intValue: value,
-                } });
-        }
-        return Object.assign(Object.assign({}, acc), { [key]: {
-                strValue: typeof value.value === 'string' ? value.value : undefined,
-                intValue: typeof value.value === 'number' ? value.value : undefined,
-                required: value.required,
-                weight: value.weight,
-                comparator: value.comparator,
-            } });
-    }, {});
-}
-function onFailureTaskName(workflow) {
-    return `${workflow.name}:on-failure-task`;
-}
-function getLeaves(tasks) {
-    return tasks.filter((task) => isLeafTask(task, tasks));
-}
-function isLeafTask(task, allTasks) {
-    return !allTasks.some((t) => { var _a; return (_a = t.parents) === null || _a === void 0 ? void 0 : _a.some((p) => p.name === task.name); });
-}

package/examples/webhooks.js

@@ -1,45 +0,0 @@
-"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/sdk.d.ts

@@ -1,2 +0,0 @@
-import { HatchetClient as Hatchet } from './v1/client/client';
-export default Hatchet;

package/util/hatchet-promise/hatchet-promise.d.ts

@@ -1,6 +0,0 @@
-declare class HatchetPromise<T> {
-    cancel: Function;
-    promise: Promise<T>;
-    constructor(promise: Promise<T>);
-}
-export default HatchetPromise;

package/util/logger/index.d.ts

@@ -1 +0,0 @@
-export * from './logger';

package/util/sleep.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Sleeps for a given number of milliseconds without blocking the event loop
- *
- * WARNING: This is not a durable sleep. It will not be honored if the worker is
- * restarted or crashes.
- * @param ms - The number of milliseconds to sleep
- * @returns A promise that resolves after the given number of milliseconds
- */
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
-exports.default = sleep;

package/v1/client/features/ratelimits.d.ts

@@ -1,20 +0,0 @@
-import { RateLimitDuration } from '../../../protoc/workflows';
-import { RateLimitOrderByField, RateLimitOrderByDirection } from '../../../clients/rest/generated/data-contracts';
-import { HatchetClient } from '../client';
-export { RateLimitDuration, RateLimitOrderByField, RateLimitOrderByDirection };
-export type CreateRateLimitOpts = {
-    key: string;
-    limit: number;
-    duration?: RateLimitDuration;
-};
-/**
- * RatelimitsClient is used to manage rate limits for the Hatchet
- */
-export declare class RatelimitsClient {
-    api: HatchetClient['api'];
-    admin: HatchetClient['admin'];
-    tenantId: string;
-    constructor(client: HatchetClient);
-    upsert(opts: CreateRateLimitOpts): Promise<string>;
-    list(opts: Parameters<typeof this.api.rateLimitList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").RateLimitList>;
-}