@hatchet-dev/typescript-sdk 1.3.2 → 1.4.0-alpha.2

package/v1/client/{worker.d.ts → worker/worker.d.ts}

@@ -1,10 +1,10 @@
-import { WorkerLabels } from '../../clients/dispatcher/dispatcher-client';
-import { InternalHatchetClient } from '../../clients/hatchet-client';
-import { V0Worker } from '../../clients/worker';
-import { Workflow as V0Workflow } from '../../workflow';
-import { WebhookWorkerCreateRequest } from '../../clients/rest/generated/data-contracts';
-import { BaseWorkflowDeclaration } from '../declaration';
-import { HatchetClient } from '..';
+import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
+import { LegacyHatchetClient } from '../../../clients/hatchet-client';
+import { Workflow as V0Workflow } from '../../../workflow';
+import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data-contracts';
+import { BaseWorkflowDeclaration } from '../../declaration';
+import { HatchetClient } from '../..';
+import { V1Worker } from './worker-internal';
 /**
  * Options for creating a new hatchet worker
  * @interface CreateWorkerOpts
@@ -30,35 +30,35 @@ export declare class Worker {
     config: CreateWorkerOpts;
     name: string;
     _v1: HatchetClient;
-    _v0: InternalHatchetClient;
+    _v0: LegacyHatchetClient;
     /** Internal reference to the underlying V0 worker implementation */
-    nonDurable: V0Worker;
-    durable?: V0Worker;
+    nonDurable: V1Worker;
+    durable?: V1Worker;
     /**
      * Creates a new HatchetWorker instance
      * @param nonDurable - The V0 worker implementation
      */
-    constructor(v1: HatchetClient, v0: InternalHatchetClient, nonDurable: V0Worker, config: CreateWorkerOpts, name: string);
+    constructor(v1: HatchetClient, v0: LegacyHatchetClient, nonDurable: V1Worker, config: CreateWorkerOpts, name: string);
     /**
      * Creates and initializes a new HatchetWorker
      * @param v0 - The HatchetClient instance
      * @param options - Worker creation options
      * @returns A new HatchetWorker instance
      */
-    static create(v1: HatchetClient, v0: InternalHatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
+    static create(v1: HatchetClient, v0: LegacyHatchetClient, name: string, options: CreateWorkerOpts): Promise<Worker>;
     /**
      * Registers workflows with the worker
      * @param workflows - Array of workflows to register
      * @returns Array of registered workflow promises
      */
-    registerWorkflows(workflows?: Array<BaseWorkflowDeclaration<any, any> | V0Workflow>): Promise<void>;
+    registerWorkflows(workflows?: Array<BaseWorkflowDeclaration<any, any> | V0Workflow>): Promise<void[]>;
     /**
      * Registers a single workflow with the worker
      * @param workflow - The workflow to register
      * @returns A promise that resolves when the workflow is registered
      * @deprecated use registerWorkflows instead
      */
-    registerWorkflow(workflow: BaseWorkflowDeclaration<any, any> | V0Workflow): Promise<void>;
+    registerWorkflow(workflow: BaseWorkflowDeclaration<any, any> | V0Workflow): Promise<void[]>;
     /**
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed
@@ -85,7 +85,7 @@ export declare class Worker {
      * @param webhook - The webhook to register
      * @returns A promise that resolves when the webhook is registered
      */
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
     isPaused(): Promise<boolean>;
     pause(): Promise<any[]>;
     unpause(): Promise<any[]>;

package/v1/client/{worker.js → worker/worker.js}

@@ -10,7 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Worker = void 0;
-const declaration_1 = require("../declaration");
+const declaration_1 = require("../../declaration");
+const worker_internal_1 = require("./worker-internal");
 const DEFAULT_DURABLE_SLOTS = 1000;
 /**
  * HatchetWorker class for workflow execution runtime
@@ -35,8 +36,9 @@ class Worker {
      */
     static create(v1, v0, name, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const v0worker = yield v0.worker(name, Object.assign(Object.assign({}, options), { maxRuns: options.slots || options.maxRuns }));
-            const worker = new Worker(v1, v0, v0worker, options, name);
+            const opts = Object.assign(Object.assign({ name }, options), { maxRuns: options.slots || options.maxRuns });
+            const internalWorker = new worker_internal_1.V1Worker(v1, opts);
+            const worker = new Worker(v1, v0, internalWorker, options, name);
             yield worker.registerWorkflows(options.workflows);
             return worker;
         });
@@ -48,22 +50,23 @@ class Worker {
      */
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const wf of workflows || []) {
+            return Promise.all((workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => __awaiter(this, void 0, void 0, function* () {
                 if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
                     // TODO check if tenant is V1
-                    yield this.nonDurable.registerWorkflowV1(wf);
+                    const register = this.nonDurable.registerWorkflowV1(wf);
                     if (wf.definition._durableTasks.length > 0) {
                         if (!this.durable) {
-                            this.durable = yield this._v0.worker(`${this.name}-durable`, Object.assign(Object.assign({}, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS }));
+                            const opts = Object.assign(Object.assign({ name: `${this.name}-durable` }, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS });
+                            this.durable = new worker_internal_1.V1Worker(this._v1, opts);
+                            yield this.durable.registerWorkflowV1(wf);
                         }
                         this.durable.registerDurableActionsV1(wf.definition);
                     }
+                    return register;
                 }
-                else {
-                    // fallback to v0 client for backwards compatibility
-                    yield this.nonDurable.registerWorkflow(wf);
-                }
-            }
+                // fallback to v0 client for backwards compatibility
+                return this.nonDurable.registerWorkflow(wf);
+            }))) || []);
         });
     }
     /**

package/v1/declaration.d.ts

@@ -1,5 +1,4 @@
 import WorkflowRunRef from '../util/workflow-run-ref';
-import { Context, DurableContext } from '../step';
 import { CronWorkflows, ScheduledWorkflows } from '../clients/rest/generated/data-contracts';
 import { Workflow as WorkflowV0 } from '../workflow';
 import { IHatchetClient } from './client/client.interface';
@@ -7,6 +6,7 @@ import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflow
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
 import { InputType, OutputType, UnknownInputType, JsonObject } from './types';
+import { Context, DurableContext } from './client/worker/context';
 export declare enum Priority {
     LOW = 1,
     MEDIUM = 2,
@@ -191,7 +191,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): WorkflowRunRef<O>;
+    runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -329,7 +329,7 @@ export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputT
      * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
-    runNoWait(input: I, options?: RunOpts): WorkflowRunRef<O>;
+    runNoWait(input: I, options?: RunOpts): Promise<WorkflowRunRef<O>>;
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**

package/v1/declaration.js

@@ -44,14 +44,16 @@ class BaseWorkflowDeclaration {
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     runNoWait(input, options, _standaloneTaskName) {
-        if (!this.client) {
-            throw UNBOUND_ERR;
-        }
-        const res = this.client._v0.admin.runWorkflow(this.name, input, options);
-        if (_standaloneTaskName) {
-            res._standalone_task_name = _standaloneTaskName;
-        }
-        return res;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const res = yield this.client.admin.runWorkflow(this.name, input, options);
+            if (_standaloneTaskName) {
+                res._standalone_task_name = _standaloneTaskName;
+            }
+            return res;
+        });
     }
     runAndWait(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -73,7 +75,7 @@ class BaseWorkflowDeclaration {
                 let resp = [];
                 for (let i = 0; i < input.length; i += 500) {
                     const batch = input.slice(i, i + 500);
-                    const batchResp = yield this.client._v0.admin.runWorkflows(batch.map((inp) => ({
+                    const batchResp = yield this.client.admin.runWorkflows(batch.map((inp) => ({
                         workflowName: this.definition.name,
                         input: inp,
                         options,
@@ -91,7 +93,7 @@ class BaseWorkflowDeclaration {
                 });
                 return Promise.all(res);
             }
-            const res = this.client._v0.admin.runWorkflow(this.definition.name, input, options);
+            const res = yield this.client.admin.runWorkflow(this.definition.name, input, options);
             if (_standaloneTaskName) {
                 res._standalone_task_name = _standaloneTaskName;
             }
@@ -322,10 +324,15 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     runNoWait(input, options) {
-        if (!this.client) {
-            throw UNBOUND_ERR;
-        }
-        return super.runNoWait(input, options, this._standalone_task_name);
+        const _super = Object.create(null, {
+            runNoWait: { get: () => super.runNoWait }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            return _super.runNoWait.call(this, input, options, this._standalone_task_name);
+        });
     }
     get taskDef() {
         return this.definition._tasks[0];

package/v1/examples/cancellations/run.js

@@ -20,8 +20,8 @@ const hatchet_client_1 = require("../hatchet-client");
 // ...
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const run = workflow_1.cancellation.runNoWait({});
-        const run1 = workflow_1.cancellation.runNoWait({});
+        const run = yield workflow_1.cancellation.runNoWait({});
+        const run1 = yield workflow_1.cancellation.runNoWait({});
         yield (0, sleep_1.default)(1000);
         yield run.cancel();
         const res = yield run.output;
@@ -32,8 +32,8 @@ function main() {
         yield run.replay();
         const resReplay = yield run.output;
         console.log(resReplay);
-        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
-        const run4 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        const run2 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
+        const run4 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
         yield (0, sleep_1.default)(1000);
         yield hatchet_client_1.hatchet.runs.cancel({
             filters: {

package/v1/examples/cancellations/workflow.js

@@ -33,10 +33,10 @@ exports.cancellation = hatchet_client_1.hatchet.task({
 // ❓ Abort Signal
 exports.abortSignal = hatchet_client_1.hatchet.task({
     name: 'abort-signal',
-    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { controller }) {
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { abortController }) {
         try {
             const response = yield axios_1.default.get('https://api.example.com/data', {
-                signal: controller.signal,
+                signal: abortController.signal,
             });
             // Handle the response
         }

package/v1/examples/high-memory/child-worker.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// ❓ Declaring a Worker
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_with_child_1 = require("./workflow-with-child");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('child-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [workflow_with_child_1.child],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 1000,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/high-memory/parent-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/high-memory/parent-worker.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// ❓ Declaring a Worker
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_with_child_1 = require("./workflow-with-child");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('parent-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [workflow_with_child_1.parent],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 20,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/high-memory/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/high-memory/run.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const workflow_with_child_1 = require("./workflow-with-child");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Running a Task
+        const res = yield workflow_with_child_1.parent.run({
+            Message: 'HeLlO WoRlD',
+        });
+        // 👀 Access the results of the Task
+        console.log(res.TransformedMessage);
+        // !!
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/high-memory/workflow-with-child.d.ts

@@ -0,0 +1,12 @@
+export type ChildInput = {
+    Message: string;
+};
+export type ParentInput = {
+    Message: string;
+};
+export declare const child: import("../..").TaskWorkflowDeclaration<ChildInput, {
+    TransformedMessage: string;
+}>;
+export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
+    TransformedMessage: string;
+}>;

package/v1/examples/high-memory/workflow-with-child.js

@@ -0,0 +1,48 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parent = exports.child = void 0;
+// ❓ Declaring a Task
+const hatchet_client_1 = require("../hatchet-client");
+exports.child = hatchet_client_1.hatchet.task({
+    name: 'child',
+    fn: (input) => {
+        const largePayload = new Array(1024 * 1024).fill('a').join('');
+        return {
+            TransformedMessage: largePayload,
+        };
+    },
+});
+exports.parent = hatchet_client_1.hatchet.task({
+    name: 'parent',
+    timeout: '10m',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // lets generate large payload 1 mb
+        const largePayload = new Array(1024 * 1024).fill('a').join('');
+        // Send the large payload 100 times
+        const num = 1000;
+        const children = [];
+        for (let i = 0; i < num; i += 1) {
+            children.push({
+                workflow: exports.child,
+                input: {
+                    Message: `Iteration ${i + 1}: ${largePayload}`,
+                },
+            });
+        }
+        yield ctx.bulkRunNoWaitChildren(children);
+        return {
+            TransformedMessage: 'done',
+        };
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/v1/examples/with_timeouts/workflow.js

@@ -27,9 +27,9 @@ exports.withTimeouts = hatchet_client_1.hatchet.task({
         // wait 15 seconds
         yield (0, sleep_1.default)(15000);
         // get the abort controller
-        const { controller } = ctx;
+        const { abortController } = ctx;
         // if the abort controller is aborted, throw an error
-        if (controller.signal.aborted) {
+        if (abortController.signal.aborted) {
             throw new Error('cancelled');
         }
         return {
@@ -48,10 +48,10 @@ exports.refreshTimeout = hatchet_client_1.hatchet.task({
         ctx.refreshTimeout('15s');
         yield (0, sleep_1.default)(15000);
         // get the abort controller
-        const { controller } = ctx;
+        const { abortController } = ctx;
         // now this condition will not be met
         // if the abort controller is aborted, throw an error
-        if (controller.signal.aborted) {
+        if (abortController.signal.aborted) {
             throw new Error('cancelled');
         }
         return {

package/v1/index.d.ts

@@ -1,6 +1,6 @@
 export * from './client/client';
 export * from './client/features';
-export * from './client/worker';
+export * from './client/worker/worker';
 export * from './declaration';
 export * from './conditions';
 export * from './client/duration';

package/v1/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./client/client"), exports);
 __exportStar(require("./client/features"), exports);
-__exportStar(require("./client/worker"), exports);
+__exportStar(require("./client/worker/worker"), exports);
 __exportStar(require("./declaration"), exports);
 __exportStar(require("./conditions"), exports);
 __exportStar(require("./client/duration"), exports);

package/v1/task.d.ts

@@ -1,8 +1,9 @@
 import { ConcurrencyLimitStrategy } from '../protoc/v1/workflows';
-import { Context, CreateStep, DurableContext } from '../step';
+import { CreateStep } from '../step';
 import { Conditions } from './conditions';
 import { Duration } from './client/duration';
 import { InputType, OutputType, UnknownInputType } from './types';
+import { Context, DurableContext } from './client/worker/context';
 /**
  * Options for configuring the concurrency for a task.
  */

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.3.2";
+export declare const HATCHET_VERSION = "1.4.0-alpha.2";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.3.2';
+exports.HATCHET_VERSION = '1.4.0-alpha.2';

package/examples/api.js

@@ -1,61 +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 __1 = __importDefault(require(".."));
-const opts = {
-    name: 'api-workflow',
-    description: 'My workflow',
-    version: '',
-    eventTriggers: [],
-    cronTriggers: [],
-    scheduledTriggers: [],
-    concurrency: undefined,
-    jobs: [
-        {
-            name: 'my-job',
-            description: 'Job description',
-            steps: [
-                {
-                    retries: 0,
-                    readableId: 'custom-step',
-                    action: `slack:example`,
-                    timeout: '60s',
-                    inputs: '{}',
-                    parents: [],
-                    workerLabels: {},
-                    userData: `{
-            "example": "value"
-          }`,
-                    rateLimits: [],
-                },
-            ],
-        },
-    ],
-};
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const hatchet = __1.default.init();
-        const { admin } = hatchet;
-        yield admin.putWorkflow(opts);
-        const worker = yield hatchet.worker('example-worker');
-        worker.nonDurable.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
-            const setData = ctx.userData();
-            console.log('executed step1!', setData);
-            return { step1: 'step1' };
-        }));
-        yield hatchet.admin.runWorkflow('api-workflow', {});
-        worker.start();
-    });
-}
-main();