@hatchet-dev/typescript-sdk 1.0.0 → 1.0.1

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

@@ -4,6 +4,7 @@ import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
+import { RunsClient } from '../../v1';
 import { Api } from '../rest';
 import { WebhookWorkerCreateRequest, WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
 import { RunListenerClient } from '../listeners/run-listener/child-listener-client';
@@ -32,7 +33,8 @@ export declare class AdminClient {
     tenantId: string;
     logger: Logger;
     listenerClient: RunListenerClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string, listenerClient: RunListenerClient);
+    workflows: RunsClient | undefined;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string, listenerClient: RunListenerClient, workflows: RunsClient | undefined);
     /**
      * @deprecated use putWorkflow instead
      */

package/clients/admin/admin-client.js

@@ -19,7 +19,7 @@ const retrier_1 = require("../../util/retrier");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
 const workflows_2 = require("../../protoc/v1/workflows");
 class AdminClient {
-    constructor(config, channel, factory, api, tenantId, listenerClient) {
+    constructor(config, channel, factory, api, tenantId, listenerClient, workflows) {
         this.config = config;
         this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
         this.v1Client = factory.create(workflows_2.AdminServiceDefinition, channel);
@@ -27,6 +27,7 @@ class AdminClient {
         this.tenantId = tenantId;
         this.logger = config.logger(`Admin`, config.log_level);
         this.listenerClient = listenerClient;
+        this.workflows = workflows;
     }
     /**
      * @deprecated use putWorkflow instead
@@ -124,7 +125,7 @@ class AdminClient {
             const resp = this.client.triggerWorkflow(Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
                     ? JSON.stringify(options === null || options === void 0 ? void 0 : options.additionalMetadata)
                     : undefined }));
-            return new workflow_run_ref_1.default(resp, this.listenerClient, options === null || options === void 0 ? void 0 : options.parentId);
+            return new workflow_run_ref_1.default(resp, this.listenerClient, this.workflows, options === null || options === void 0 ? void 0 : options.parentId);
         }
         catch (e) {
             throw new hatchet_error_1.default(e.message);
@@ -156,7 +157,7 @@ class AdminClient {
             return bulkTriggerWorkflowResponse.then((res) => {
                 return res.workflowRunIds.map((resp, index) => {
                     const { options } = workflowRuns[index];
-                    return new workflow_run_ref_1.default(resp, this.listenerClient, options === null || options === void 0 ? void 0 : options.parentId);
+                    return new workflow_run_ref_1.default(resp, this.listenerClient, this.workflows, options === null || options === void 0 ? void 0 : options.parentId);
                 });
             });
         }
@@ -238,7 +239,7 @@ class AdminClient {
      */
     getWorkflowRun(workflowRunId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new workflow_run_ref_1.default(workflowRunId, this.listenerClient);
+            return new workflow_run_ref_1.default(workflowRunId, this.listenerClient, this.workflows);
         });
     }
     /**

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

@@ -6,6 +6,7 @@ import { Workflow as V0Workflow } from '../../workflow';
 import { V0Worker, WorkerOpts } from '../worker';
 import { AxiosRequestConfig } from 'axios';
 import { Logger } from '../../util/logger';
+import { RunsClient } from '../../v1';
 import { ClientConfig } from './client-config';
 import { RunListenerClient } from '../listeners/run-listener/child-listener-client';
 import { Api } from '../rest/generated/Api';
@@ -25,13 +26,14 @@ export declare class InternalHatchetClient {
     dispatcher: DispatcherClient;
     admin: AdminClient;
     api: Api;
+    runs: RunsClient | undefined;
     listener: RunListenerClient;
     tenantId: string;
     durableListener: DurableListenerClient;
     logger: Logger;
     cron: CronClient;
     schedule: ScheduleClient;
-    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
+    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig, runs?: RunsClient);
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): InternalHatchetClient;
     run(workflow: string | V0Workflow): Promise<V0Worker>;
     worker(workflow: string | V0Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<V0Worker>;

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

@@ -90,10 +90,11 @@ const addTokenMiddleware = (token) => function _(call, options) {
 };
 exports.addTokenMiddleware = addTokenMiddleware;
 class InternalHatchetClient {
-    constructor(config, options, axiosOpts) {
+    constructor(config, options, axiosOpts, runs) {
         // Initializes a new Client instance.
         // Loads config in the following order: config param > yaml file > env vars
         var _a;
+        this.runs = runs;
         const loaded = config_loader_1.ConfigLoader.loadClientConfig(config, {
             path: options === null || options === void 0 ? void 0 : options.config_path,
         });
@@ -119,7 +120,7 @@ class InternalHatchetClient {
         this.event = new event_client_1.EventClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
         this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
         this.listener = new child_listener_client_1.RunListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
-        this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId, this.listener);
+        this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId, this.listener, this.runs);
         this.durableListener = new durable_listener_client_1.DurableListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.logger = this.config.logger('HatchetClient', this.config.log_level);
         this.logger.debug(`Initialized HatchetClient`);

package/package.json

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

package/step.d.ts

@@ -207,6 +207,8 @@ export declare class Context<T, K = {}> {
     logger: Logger;
     spawnIndex: number;
     constructor(action: Action, client: InternalHatchetClient, worker: V0Worker);
+    get abortController(): AbortController;
+    get cancelled(): boolean;
     /**
      * Retrieves the output of a parent task.
      * @param task - The name of the task or a CreateTaskOpts object.

package/step.js

@@ -130,6 +130,7 @@ class ContextWorker {
 exports.ContextWorker = ContextWorker;
 class Context {
     constructor(action, client, worker) {
+        // @deprecated use ctx.abortController instead
         this.controller = new AbortController();
         this.overridesData = {};
         this.spawnIndex = 0;
@@ -153,6 +154,12 @@ class Context {
             throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
         }
     }
+    get abortController() {
+        return this.controller;
+    }
+    get cancelled() {
+        return this.controller.signal.aborted;
+    }
     /**
      * Retrieves the output of a parent task.
      * @param task - The name of the task or a CreateTaskOpts object.

package/util/sleep.d.ts

@@ -1,5 +1,6 @@
 /**
  * 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

package/util/sleep.js

@@ -2,6 +2,7 @@
 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

package/util/workflow-run-ref.d.ts

@@ -1,4 +1,5 @@
 import { RunListenerClient, StepRunEvent } from '../clients/listeners/run-listener/child-listener-client';
+import { RunsClient } from '../v1';
 type EventualWorkflowRunId = string | Promise<string> | Promise<{
     workflowRunId: string;
 }>;
@@ -9,9 +10,10 @@ export default class WorkflowRunRef<T> {
     workflowRunId: EventualWorkflowRunId;
     parentWorkflowRunId?: string;
     private client;
+    private runs;
     constructor(workflowRunId: string | Promise<string> | Promise<{
         workflowRunId: string;
-    }>, client: RunListenerClient, parentWorkflowRunId?: string);
+    }>, client: RunListenerClient, runsClient?: RunsClient, parentWorkflowRunId?: string);
     get runId(): Promise<string>;
     getWorkflowRunId(): Promise<string>;
     stream(): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
@@ -22,5 +24,7 @@ export default class WorkflowRunRef<T> {
      */
     result(): Promise<T>;
     toJSON(): Promise<string>;
+    cancel(): Promise<void>;
+    replay(): Promise<void>;
 }
 export {};

package/util/workflow-run-ref.js

@@ -50,10 +50,11 @@ function getWorkflowRunId(workflowRunId) {
     });
 }
 class WorkflowRunRef {
-    constructor(workflowRunId, client, parentWorkflowRunId) {
+    constructor(workflowRunId, client, runsClient, parentWorkflowRunId) {
         this.workflowRunId = workflowRunId;
         this.parentWorkflowRunId = parentWorkflowRunId;
         this.client = client;
+        this.runs = runsClient;
     }
     // TODO docstrings
     get runId() {
@@ -73,6 +74,7 @@ class WorkflowRunRef {
     }
     // TODO not sure if i want this to be a get since it might be blocking for a long time..
     get output() {
+        // TODO output for single task workflows
         return this.result();
     }
     /**
@@ -143,5 +145,27 @@ class WorkflowRunRef {
             });
         });
     }
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.runs) {
+                throw new Error('cancel is a v1 only feature, please upgrade your sdk');
+            }
+            const workflowRunId = yield getWorkflowRunId(this.workflowRunId);
+            yield this.runs.cancel({
+                ids: [workflowRunId],
+            });
+        });
+    }
+    replay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.runs) {
+                throw new Error('replay is a v1 only feature, please upgrade your sdk');
+            }
+            const workflowRunId = yield getWorkflowRunId(this.workflowRunId);
+            yield this.runs.replay({
+                ids: [workflowRunId],
+            });
+        });
+    }
 }
 exports.default = WorkflowRunRef;

package/v1/client/client.d.ts

@@ -3,6 +3,7 @@ import { AxiosRequestConfig } from 'axios';
 import WorkflowRunRef from '../../util/workflow-run-ref';
 import { Workflow as V0Workflow } from '../../workflow';
 import { JsonObject, DurableContext } from '../../step';
+import { Api } from '../../clients/rest';
 import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclaration, WorkflowDeclaration, TaskWorkflowDeclaration } from '../declaration';
 import { IHatchetClient } from './client.interface';
 import { CreateWorkerOpts, Worker } from './worker';
@@ -18,12 +19,13 @@ import { CreateStandaloneDurableTaskOpts } from '../task';
 export declare class HatchetClient implements IHatchetClient {
     /** The underlying v0 client instance */
     _v0: InternalHatchetClient;
+    _api: Api;
     /**
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
     get v0(): InternalHatchetClient;
     /** The tenant ID for the Hatchet client */
-    get tenantId(): string;
+    tenantId: string;
     _isV1: boolean | undefined;
     get isV1(): boolean;
     /**
@@ -179,7 +181,7 @@ export declare class HatchetClient implements IHatchetClient {
      * Note: This is not recommended for general use, but is available for advanced scenarios
      * @returns A API client instance
      */
-    get api(): import("../..").Api<unknown>;
+    get api(): Api<unknown>;
     /**
      * @deprecated use workflow.run, client.run, or client.* feature methods instead
      */

package/v1/client/client.js

@@ -17,6 +17,10 @@ exports.HatchetClient = void 0;
 /* eslint-disable no-underscore-dangle */
 const hatchet_client_1 = require("../../clients/hatchet-client");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
+const rest_1 = __importDefault(require("../../clients/rest"));
+const config_loader_1 = require("../../util/config-loader");
+const hatchet_logger_1 = require("../../clients/hatchet-client/hatchet-logger");
+const zod_1 = require("zod");
 const declaration_1 = require("../declaration");
 const worker_1 = require("./worker");
 const metrics_1 = require("./features/metrics");
@@ -34,10 +38,6 @@ class HatchetClient {
     get v0() {
         return this._v0;
     }
-    /** The tenant ID for the Hatchet client */
-    get tenantId() {
-        return this._v0.tenantId;
-    }
     get isV1() {
         return true;
     }
@@ -49,7 +49,26 @@ class HatchetClient {
      */
     constructor(config, options, axiosConfig) {
         this._isV1 = true;
-        this._v0 = new hatchet_client_1.InternalHatchetClient(config, options, axiosConfig);
+        try {
+            const loaded = config_loader_1.ConfigLoader.loadClientConfig(config, {
+                path: options === null || options === void 0 ? void 0 : options.config_path,
+            });
+            const valid = hatchet_client_1.ClientConfigSchema.parse(loaded);
+            let logConstructor = config === null || config === void 0 ? void 0 : config.logger;
+            if (logConstructor == null) {
+                logConstructor = hatchet_logger_1.DEFAULT_LOGGER;
+            }
+            const clientConfig = Object.assign(Object.assign({}, valid), { logger: logConstructor });
+            this.tenantId = clientConfig.tenant_id;
+            this._api = (0, rest_1.default)(clientConfig.api_url, clientConfig.token, axiosConfig);
+            this._v0 = new hatchet_client_1.InternalHatchetClient(clientConfig, options, axiosConfig, this.runs);
+        }
+        catch (e) {
+            if (e instanceof zod_1.z.ZodError) {
+                throw new Error(`Invalid client config: ${e.message}`);
+            }
+            throw e;
+        }
     }
     /**
      * Static factory method to create a new Hatchet client instance.
@@ -227,7 +246,7 @@ class HatchetClient {
      * @returns A API client instance
      */
     get api() {
-        return this._v0.api;
+        return this._api;
     }
     /**
      * @deprecated use workflow.run, client.run, or client.* feature methods instead
@@ -259,7 +278,7 @@ class HatchetClient {
         return this._v0.webhooks(workflows);
     }
     runRef(id) {
-        return new workflow_run_ref_1.default(id, this.v0.listener);
+        return new workflow_run_ref_1.default(id, this.v0.listener, this.runs);
     }
 }
 exports.HatchetClient = HatchetClient;

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

@@ -1,15 +1,34 @@
 import WorkflowRunRef from '../../../util/workflow-run-ref';
+import { V1TaskStatus } from '../../../clients/rest/generated/data-contracts';
 import { HatchetClient } from '../client';
+import { WorkflowsClient } from './workflows';
+export type RunFilter = {
+    since: Date;
+    until?: Date;
+    statuses?: V1TaskStatus[];
+    workflowNames?: string[];
+    additionalMetadata?: Record<string, string>;
+};
+export type CancelRunOpts = {
+    ids?: string[];
+    filters?: RunFilter;
+};
+export type ReplayRunOpts = {
+    ids?: string[];
+    filters?: RunFilter;
+};
 /**
  * RunsClient is used to list and manage runs
  */
 export declare class RunsClient {
     api: HatchetClient['api'];
     tenantId: string;
+    workflows: WorkflowsClient;
     constructor(client: HatchetClient);
     get<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRun>;
     getDetails<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunShape>;
     list(opts?: Parameters<typeof this.api.workflowRunList>[1]): Promise<import("../../../clients/rest/generated/data-contracts").WorkflowRunList>;
-    replay(opts: Parameters<typeof this.api.v1TaskReplay>[1]): Promise<void>;
-    cancel(opts: Parameters<typeof this.api.v1TaskCancel>[1]): Promise<void>;
+    cancel(opts: CancelRunOpts): Promise<import("axios").AxiosResponse<void, any>>;
+    replay(opts: ReplayRunOpts): Promise<import("axios").AxiosResponse<void, any>>;
+    private prepareFilter;
 }

package/v1/client/features/runs.js

@@ -17,6 +17,7 @@ class RunsClient {
     constructor(client) {
         this.api = client.api;
         this.tenantId = client.tenantId;
+        this.workflows = client.workflows;
     }
     // TODO expose streaming methods?
     get(run) {
@@ -40,20 +41,33 @@ class RunsClient {
             return data;
         });
     }
-    replay(opts) {
+    cancel(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO is v1 check
-            // TODO   workflowIds?: string[]; on opts.filters
-            const { data } = yield this.api.v1TaskReplay(this.tenantId, opts);
-            return data;
+            const filter = opts.filters && (yield this.prepareFilter(opts.filters));
+            return this.api.v1TaskCancel(this.tenantId, {
+                externalIds: opts.ids,
+                filter,
+            });
         });
     }
-    cancel(opts) {
+    replay(opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            // TODO is v1 check
-            // TODO   workflowIds?: string[]; on opts.filters
-            const { data } = yield this.api.v1TaskCancel(this.tenantId, opts);
-            return data;
+            const filter = opts.filters && (yield this.prepareFilter(opts.filters));
+            return this.api.v1TaskReplay(this.tenantId, {
+                externalIds: opts.ids,
+                filter,
+            });
+        });
+    }
+    prepareFilter(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ since, until, statuses, workflowNames, additionalMetadata, }) {
+            return {
+                since: since.toISOString(),
+                until: until === null || until === void 0 ? void 0 : until.toISOString(),
+                statuses,
+                workflowIds: yield Promise.all((workflowNames === null || workflowNames === void 0 ? void 0 : workflowNames.map((name) => __awaiter(this, void 0, void 0, function* () { return (yield this.workflows.get(name)).metadata.id; }))) || []),
+                additionalMetadata: Object.entries(additionalMetadata || {}).map(([key, value]) => `${key}:${value}`),
+            };
         });
     }
 }

package/v1/examples/cancellations/run.d.ts

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

package/v1/examples/cancellations/run.js

@@ -0,0 +1,50 @@
+"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 });
+/* eslint-disable no-console */
+// ❓ Running a Task with Results
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const workflow_1 = require("./workflow");
+const hatchet_client_1 = require("../hatchet-client");
+// ...
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const run = workflow_1.cancellation.runNoWait({});
+        yield (0, sleep_1.default)(1000);
+        yield run.cancel();
+        const res = yield run.output;
+        console.log(res);
+        yield (0, sleep_1.default)(1000);
+        yield run.replay();
+        const resReplay = yield run.output;
+        console.log(resReplay);
+        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        const run4 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        yield (0, sleep_1.default)(1000);
+        yield hatchet_client_1.hatchet.runs.cancel({
+            filters: {
+                since: new Date(Date.now() - 60 * 60),
+                additionalMetadata: { test: 'test' },
+            },
+        });
+        const res3 = yield Promise.all([run2.output, run4.output]);
+        console.log(res3);
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/cancellations/worker.d.ts

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

package/v1/examples/cancellations/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_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('cancellation-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [workflow_1.cancellation],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/cancellations/workflow.d.ts

@@ -0,0 +1,3 @@
+export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, {
+    Completed: true;
+}>;

package/v1/examples/cancellations/workflow.js

@@ -0,0 +1,33 @@
+"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.cancellation = void 0;
+// ❓ Declaring a Task
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// (optional) Define the input type for the workflow
+exports.cancellation = hatchet_client_1.hatchet.task({
+    name: 'cancellation',
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { cancelled }) {
+        yield (0, sleep_1.default)(10 * 1000);
+        if (cancelled) {
+            throw new Error('Task was cancelled');
+        }
+        return {
+            Completed: true,
+        };
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/v1/examples/child_workflows/run.js

@@ -16,7 +16,7 @@ function main() {
             N: 10,
         });
         // eslint-disable-next-line no-console
-        console.log(res.sum.Result);
+        console.log(res.Result);
     });
 }
 if (require.main === module) {

package/v1/examples/child_workflows/workflow.d.ts

@@ -1,19 +1,13 @@
 type ChildInput = {
     N: number;
 };
-type ChildOutput = {
-    value: {
-        Value: number;
-    };
-};
-export declare const child: import("../..").WorkflowDeclaration<ChildInput, ChildOutput>;
+export declare const child: import("../..").TaskWorkflowDeclaration<ChildInput, {
+    Value: number;
+}>;
 type ParentInput = {
     N: number;
 };
-type ParentOutput = {
-    sum: {
-        Result: number;
-    };
-};
-export declare const parent: import("../..").WorkflowDeclaration<ParentInput, ParentOutput>;
+export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
+    Result: number;
+}>;
 export {};

package/v1/examples/child_workflows/workflow.js

@@ -1,5 +1,4 @@
 "use strict";
-// ❓ Declaring a Child
 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) {
@@ -11,32 +10,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parent = exports.child = void 0;
+/* eslint-disable no-plusplus */
+// ❓ Declaring a Child
 const hatchet_client_1 = require("../hatchet-client");
-exports.child = hatchet_client_1.hatchet.workflow({
+exports.child = hatchet_client_1.hatchet.task({
     name: 'child',
-});
-exports.child.task({
-    name: 'value',
     fn: (input) => {
         return {
             Value: input.N,
         };
     },
 });
-exports.parent = hatchet_client_1.hatchet.workflow({
+exports.parent = hatchet_client_1.hatchet.task({
     name: 'parent',
-});
-exports.parent.task({
-    name: 'sum',
     fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         const n = input.N;
         const promises = [];
-        // eslint-disable-next-line no-plusplus
         for (let i = 0; i < n; i++) {
             promises.push(ctx.runChild(exports.child, { N: i }));
         }
         const childRes = yield Promise.all(promises);
-        const sum = childRes.reduce((acc, curr) => acc + curr.value.Value, 0);
+        const sum = childRes.reduce((acc, curr) => acc + curr.Value, 0);
         return {
             Result: sum,
         };

package/v1/examples/dag/workflow.js

@@ -11,9 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dag = void 0;
 const hatchet_client_1 = require("../hatchet-client");
+// ❓ Declaring a DAG Workflow
+// First, we declare the workflow
 exports.dag = hatchet_client_1.hatchet.workflow({
     name: 'simple',
 });
+// Next, we declare the tasks bound to the workflow
 const toLower = exports.dag.task({
     name: 'to-lower',
     fn: (input) => {
@@ -22,6 +25,7 @@ const toLower = exports.dag.task({
         };
     },
 });
+// Next, we declare the tasks bound to the workflow
 exports.dag.task({
     name: 'reverse',
     parents: [toLower],
@@ -33,3 +37,4 @@ exports.dag.task({
         };
     }),
 });
+// !!

package/v1/examples/simple/run.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-console */
-// ❓ Running a Workflow with Results
+// ❓ Running a Task with Results
 const workflow_1 = require("./workflow");
 // ...
 function main() {

package/v1/examples/sticky/workflow.d.ts

@@ -1,7 +1,5 @@
 export declare const sticky: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, {
     result: {
-        value: {
-            Value: number;
-        };
+        Value: number;
     };
 }>;

package/v1/examples/timeouts/run.d.ts

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

package/v1/examples/timeouts/run.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 });
+/* eslint-disable no-console */
+// ❓ Running a Task with Results
+const workflow_1 = require("./workflow");
+// ...
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 👀 Run the workflow with results
+        const res = yield workflow_1.cancellation.run({});
+        // 👀 Access the results of the workflow
+        console.log(res.Completed);
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/timeouts/worker.d.ts

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

package/v1/examples/timeouts/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_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('cancellation-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [workflow_1.cancellation],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/timeouts/workflow.d.ts

@@ -0,0 +1,3 @@
+export declare const cancellation: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, {
+    Completed: true;
+}>;

package/v1/examples/timeouts/workflow.js

@@ -0,0 +1,34 @@
+"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.cancellation = void 0;
+// ❓ Declaring a Task
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// (optional) Define the input type for the workflow
+exports.cancellation = hatchet_client_1.hatchet.task({
+    name: 'cancellation',
+    executionTimeout: '3s',
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { cancelled }) {
+        yield (0, sleep_1.default)(10 * 1000);
+        if (cancelled) {
+            throw new Error('Task was cancelled');
+        }
+        return {
+            Completed: true,
+        };
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.0.0";
+export declare const HATCHET_VERSION = "1.0.1";

package/version.js

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