@hatchet-dev/typescript-sdk 1.3.1 → 1.4.0-alpha.1

package/clients/dispatcher/heartbeat/heartbeat-worker.js

@@ -13,6 +13,7 @@ const worker_threads_1 = require("worker_threads");
 const hatchet_client_1 = require("../../hatchet-client");
 const config_loader_1 = require("../../../util/config-loader");
 const nice_grpc_1 = require("nice-grpc");
+const grpc_helpers_1 = require("../../../util/grpc-helpers");
 const dispatcher_client_1 = require("../dispatcher-client");
 const heartbeat_controller_1 = require("./heartbeat-controller");
 const HEARTBEAT_INTERVAL = 4000;
@@ -26,8 +27,8 @@ class HeartbeatWorker {
         this.logger = new hatchet_client_1.HatchetLogger(`HeartbeatThread`, config.log_level);
         this.logger.debug('Heartbeat thread starting...');
         const credentials = config_loader_1.ConfigLoader.createCredentials(config.tls_config);
-        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, hatchet_client_1.addTokenMiddleware)(config.token));
-        const dispatcher = new dispatcher_client_1.DispatcherClient(Object.assign(Object.assign({}, config), { logger: (ctx, level) => new hatchet_client_1.HatchetLogger(ctx, level) }), (0, hatchet_client_1.channelFactory)(config, credentials), clientFactory);
+        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, grpc_helpers_1.addTokenMiddleware)(config.token));
+        const dispatcher = new dispatcher_client_1.DispatcherClient(Object.assign(Object.assign({}, config), { logger: (ctx, level) => new hatchet_client_1.HatchetLogger(ctx, level) }), (0, grpc_helpers_1.channelFactory)(config, credentials), clientFactory);
         this.client = dispatcher.client;
         postMessage({
             type: 'debug',

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

@@ -1,7 +1,7 @@
 import { EventClient } from '../event/event-client';
 import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
-import { CallOptions, ChannelCredentials, ClientMiddlewareCall } from 'nice-grpc';
+import { ChannelCredentials } from 'nice-grpc';
 import { Workflow as V0Workflow } from '../../workflow';
 import { V0Worker, WorkerOpts } from '../worker';
 import { AxiosRequestConfig } from 'axios';
@@ -17,9 +17,7 @@ export interface HatchetClientOptions {
     config_path?: string;
     credentials?: ChannelCredentials;
 }
-export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;
-export declare const addTokenMiddleware: (token: string) => <Request, Response>(call: ClientMiddlewareCall<Request, Response>, options: CallOptions) => AsyncGenerator<Awaited<Response>, Awaited<Response> | undefined, undefined>;
-export declare class InternalHatchetClient {
+export declare class LegacyHatchetClient {
     config: ClientConfig;
     credentials: ChannelCredentials;
     event: EventClient;
@@ -34,7 +32,7 @@ export declare class InternalHatchetClient {
     cron: CronClient;
     schedule: ScheduleClient;
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig, runs?: RunsClient);
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): InternalHatchetClient;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): LegacyHatchetClient;
     run(workflow: string | V0Workflow): Promise<V0Worker>;
     worker(workflow: string | V0Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<V0Worker>;
     webhooks(workflows: Array<V0Workflow>): import("../worker/handler").WebhookHandler;

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

@@ -8,36 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InternalHatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
+exports.LegacyHatchetClient = void 0;
 const zod_1 = require("zod");
 const config_loader_1 = require("../../util/config-loader");
 const event_client_1 = require("../event/event-client");
@@ -46,50 +21,14 @@ const admin_client_1 = require("../admin/admin-client");
 const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
 const hatchet_logger_1 = require("./hatchet-logger");
+const grpc_helpers_1 = require("../../util/grpc-helpers");
 const client_config_1 = require("./client-config");
 const child_listener_client_1 = require("../listeners/run-listener/child-listener-client");
 const rest_1 = __importDefault(require("../rest"));
 const cron_client_1 = require("./features/cron-client");
 const schedule_client_1 = require("./features/schedule-client");
 const durable_listener_client_1 = require("../listeners/durable-listener/durable-listener-client");
-const channelFactory = (config, credentials) => (0, nice_grpc_1.createChannel)(config.host_port, credentials, {
-    'grpc.ssl_target_name_override': config.tls_config.server_name,
-    'grpc.keepalive_timeout_ms': 60 * 1000,
-    'grpc.client_idle_timeout_ms': 60 * 1000,
-    // Send keepalive pings every 10 seconds, default is 2 hours.
-    'grpc.keepalive_time_ms': 10 * 1000,
-    // Allow keepalive pings when there are no gRPC calls.
-    'grpc.keepalive_permit_without_calls': 1,
-});
-exports.channelFactory = channelFactory;
-const addTokenMiddleware = (token) => function _(call, options) {
-    return __asyncGenerator(this, arguments, function* _1() {
-        var _a, e_1, _b, _c;
-        const optionsWithAuth = Object.assign(Object.assign({}, options), { metadata: new nice_grpc_1.Metadata({ authorization: `bearer ${token}` }) });
-        if (!call.responseStream) {
-            const response = yield __await(yield* __asyncDelegator(__asyncValues(call.next(call.request, optionsWithAuth))));
-            return yield __await(response);
-        }
-        try {
-            for (var _d = true, _e = __asyncValues(call.next(call.request, optionsWithAuth)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const response = _c;
-                yield yield __await(response);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return yield __await(undefined);
-    });
-};
-exports.addTokenMiddleware = addTokenMiddleware;
-class InternalHatchetClient {
+class LegacyHatchetClient {
     constructor(config, options, axiosOpts, runs) {
         // Initializes a new Client instance.
         // Loads config in the following order: config param > yaml file > env vars
@@ -114,14 +53,14 @@ class InternalHatchetClient {
         }
         this.credentials =
             (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
-        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, exports.addTokenMiddleware)(this.config.token));
+        const clientFactory = (0, nice_grpc_1.createClientFactory)().use((0, grpc_helpers_1.addTokenMiddleware)(this.config.token));
         this.tenantId = this.config.tenant_id;
         this.api = (0, rest_1.default)(this.config.api_url, this.config.token, axiosOpts);
-        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.runs);
-        this.durableListener = new durable_listener_client_1.DurableListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
+        this.event = new event_client_1.EventClient(this.config, (0, grpc_helpers_1.channelFactory)(this.config, this.credentials), clientFactory);
+        this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, (0, grpc_helpers_1.channelFactory)(this.config, this.credentials), clientFactory);
+        this.listener = new child_listener_client_1.RunListenerClient(this.config, (0, grpc_helpers_1.channelFactory)(this.config, this.credentials), clientFactory, this.api);
+        this.admin = new admin_client_1.AdminClient(this.config, (0, grpc_helpers_1.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, grpc_helpers_1.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.logger = this.config.logger('HatchetClient', this.config.log_level);
         this.logger.debug(`Initialized HatchetClient`);
         // Feature Clients
@@ -129,7 +68,7 @@ class InternalHatchetClient {
         this.schedule = new schedule_client_1.ScheduleClient(this.tenantId, this.config, this.api, this.admin);
     }
     static init(config, options, axiosConfig) {
-        return new InternalHatchetClient(config, options, axiosConfig);
+        return new LegacyHatchetClient(config, options, axiosConfig);
     }
     // @deprecated
     run(workflow) {
@@ -169,4 +108,4 @@ class InternalHatchetClient {
         return worker.getHandler(workflows);
     }
 }
-exports.InternalHatchetClient = InternalHatchetClient;
+exports.LegacyHatchetClient = LegacyHatchetClient;

package/clients/worker/worker.d.ts

@@ -1,4 +1,4 @@
-import { InternalHatchetClient } from '../hatchet-client';
+import { LegacyHatchetClient } from '../hatchet-client';
 import { Action, ActionListener } from '../dispatcher/action-listener';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
@@ -6,8 +6,8 @@ import { Workflow } from '../../workflow';
 import { Logger } from '../../util/logger';
 import { WebhookHandler } from './handler';
 import { WebhookWorkerCreateRequest } from '../rest/generated/data-contracts';
-import { BaseWorkflowDeclaration, WorkflowDefinition } from '../../v1/declaration';
-import { Context, StepRunFunction } from '../../step';
+import { WorkflowDefinition } from '../../v1/declaration';
+import { V0Context, StepRunFunction } from '../../step';
 import { WorkerLabels } from '../dispatcher/dispatcher-client';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export interface WorkerOpts {
@@ -17,7 +17,7 @@ export interface WorkerOpts {
     labels?: WorkerLabels;
 }
 export declare class V0Worker {
-    client: InternalHatchetClient;
+    client: LegacyHatchetClient;
     name: string;
     workerId: string | undefined;
     killing: boolean;
@@ -26,12 +26,12 @@ export declare class V0Worker {
     workflow_registry: Array<WorkflowDefinition | Workflow>;
     listener: ActionListener | undefined;
     futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    contexts: Record<Action['stepRunId'], Context<any, any>>;
+    contexts: Record<Action['stepRunId'], V0Context<any, any>>;
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
     labels: WorkerLabels;
-    constructor(client: InternalHatchetClient, options: {
+    constructor(client: LegacyHatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;
@@ -44,9 +44,6 @@ export declare class V0Worker {
      * @deprecated use registerWorkflow instead
      */
     register_workflow(initWorkflow: Workflow): Promise<void>;
-    registerDurableActionsV1(workflow: WorkflowDefinition): void;
-    private registerActionsV1;
-    registerWorkflowV1(initWorkflow: BaseWorkflowDeclaration<any, any>): Promise<void>;
     registerWorkflow(initWorkflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
     handleStartStepRun(action: Action): Promise<void>;

package/clients/worker/worker.js

@@ -26,7 +26,6 @@ const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/ha
 const workflows_1 = require("../../protoc/workflows");
 const handler_1 = require("./handler");
 const task_1 = require("../../v1/task");
-const transformer_1 = require("../../v1/conditions/transformer");
 const step_1 = require("../../step");
 class V0Worker {
     constructor(client, options) {
@@ -83,167 +82,6 @@ class V0Worker {
             return this.registerWorkflow(initWorkflow);
         });
     }
-    registerDurableActionsV1(workflow) {
-        const newActions = workflow._durableTasks.reduce((acc, task) => {
-            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.workflowInput(), ctx);
-            return acc;
-        }, {});
-        this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
-    }
-    registerActionsV1(workflow) {
-        const newActions = workflow._tasks.reduce((acc, task) => {
-            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.workflowInput(), ctx);
-            return acc;
-        }, {});
-        const onFailureFn = workflow.onFailure
-            ? typeof workflow.onFailure === 'function'
-                ? workflow.onFailure
-                : workflow.onFailure.fn
-            : undefined;
-        const onFailureAction = onFailureFn
-            ? {
-                [onFailureTaskName(workflow)]: (ctx) => onFailureFn(ctx.workflowInput(), ctx),
-            }
-            : {};
-        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
-    }
-    registerWorkflowV1(initWorkflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
-            // patch the namespace
-            const workflow = Object.assign(Object.assign({}, initWorkflow.definition), { name: (this.client.config.namespace + initWorkflow.definition.name).toLowerCase() });
-            try {
-                const { concurrency } = workflow;
-                let onFailureTask;
-                if (workflow.onFailure && typeof workflow.onFailure === 'function') {
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: '60s',
-                        inputs: '{}',
-                        parents: [],
-                        retries: 0,
-                        rateLimits: [],
-                        workerLabels: {},
-                        concurrency: [],
-                    };
-                }
-                if (workflow.onFailure && typeof workflow.onFailure === 'object') {
-                    const onFailure = workflow.onFailure;
-                    onFailureTask = {
-                        readableId: 'on-failure-task',
-                        action: onFailureTaskName(workflow),
-                        timeout: onFailure.executionTimeout || ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) || '60s',
-                        scheduleTimeout: onFailure.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
-                        inputs: '{}',
-                        parents: [],
-                        retries: onFailure.retries || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.retries) || 0,
-                        rateLimits: (0, step_1.mapRateLimit)(onFailure.rateLimits || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.rateLimits)),
-                        workerLabels: toPbWorkerLabel(onFailure.desiredWorkerLabels || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.workerLabels)),
-                        concurrency: [],
-                        backoffFactor: ((_f = onFailure.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
-                        backoffMaxSeconds: ((_j = onFailure.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
-                    };
-                }
-                let onSuccessTask;
-                if (workflow.onSuccess && typeof workflow.onSuccess === 'function') {
-                    const parents = getLeaves(workflow._tasks);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: workflow.onSuccess,
-                        timeout: '60s',
-                        parents,
-                        retries: 0,
-                        rateLimits: [],
-                        desiredWorkerLabels: {},
-                        concurrency: [],
-                    };
-                }
-                if (workflow.onSuccess && typeof workflow.onSuccess === 'object') {
-                    const onSuccess = workflow.onSuccess;
-                    const parents = getLeaves(workflow._tasks);
-                    onSuccessTask = {
-                        name: 'on-success-task',
-                        fn: onSuccess.fn,
-                        timeout: onSuccess.executionTimeout || ((_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.executionTimeout) || '60s',
-                        scheduleTimeout: onSuccess.scheduleTimeout || ((_o = workflow.taskDefaults) === null || _o === void 0 ? void 0 : _o.scheduleTimeout),
-                        parents,
-                        retries: onSuccess.retries || ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.retries) || 0,
-                        rateLimits: onSuccess.rateLimits || ((_q = workflow.taskDefaults) === null || _q === void 0 ? void 0 : _q.rateLimits),
-                        desiredWorkerLabels: onSuccess.desiredWorkerLabels || ((_r = workflow.taskDefaults) === null || _r === void 0 ? void 0 : _r.workerLabels),
-                        concurrency: onSuccess.concurrency || ((_s = workflow.taskDefaults) === null || _s === void 0 ? void 0 : _s.concurrency),
-                        backoff: onSuccess.backoff || ((_t = workflow.taskDefaults) === null || _t === void 0 ? void 0 : _t.backoff),
-                    };
-                }
-                if (onSuccessTask) {
-                    workflow._tasks.push(onSuccessTask);
-                }
-                // cron and event triggers
-                if (workflow.on) {
-                    this.logger.warn(`\`on\` for event and cron triggers is deprecated and will be removed soon, use \`onEvents\` and \`onCrons\` instead for ${workflow.name}`);
-                }
-                const eventTriggers = [
-                    ...(workflow.onEvents || []),
-                    ...(((_u = workflow.on) === null || _u === void 0 ? void 0 : _u.event) ? [workflow.on.event] : []),
-                ];
-                const cronTriggers = [
-                    ...(workflow.onCrons || []),
-                    ...(((_v = workflow.on) === null || _v === void 0 ? void 0 : _v.cron) ? [workflow.on.cron] : []),
-                ];
-                const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
-                const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
-                const registeredWorkflow = this.client.admin.putWorkflowV1({
-                    name: workflow.name,
-                    description: workflow.description || '',
-                    version: workflow.version || '',
-                    eventTriggers,
-                    cronTriggers,
-                    sticky: workflow.sticky,
-                    concurrencyArr,
-                    onFailureTask,
-                    defaultPriority: workflow.defaultPriority,
-                    tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
-                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
-                        return ({
-                            readableId: task.name,
-                            action: `${workflow.name}:${task.name}`,
-                            timeout: task.executionTimeout ||
-                                task.timeout ||
-                                ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) ||
-                                '60s',
-                            scheduleTimeout: task.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
-                            inputs: '{}',
-                            parents: (_d = (_c = task.parents) === null || _c === void 0 ? void 0 : _c.map((p) => p.name)) !== null && _d !== void 0 ? _d : [],
-                            userData: '{}',
-                            retries: task.retries || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.retries) || 0,
-                            rateLimits: (0, step_1.mapRateLimit)(task.rateLimits || ((_f = workflow.taskDefaults) === null || _f === void 0 ? void 0 : _f.rateLimits)),
-                            workerLabels: toPbWorkerLabel(task.desiredWorkerLabels || ((_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.workerLabels)),
-                            backoffFactor: ((_h = task.backoff) === null || _h === void 0 ? void 0 : _h.factor) || ((_k = (_j = workflow.taskDefaults) === null || _j === void 0 ? void 0 : _j.backoff) === null || _k === void 0 ? void 0 : _k.factor),
-                            backoffMaxSeconds: ((_l = task.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds) || ((_o = (_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.backoff) === null || _o === void 0 ? void 0 : _o.maxSeconds),
-                            conditions: (0, transformer_1.taskConditionsToPb)(task),
-                            concurrency: task.concurrency
-                                ? Array.isArray(task.concurrency)
-                                    ? task.concurrency
-                                    : [task.concurrency]
-                                : ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.concurrency)
-                                    ? Array.isArray(workflow.taskDefaults.concurrency)
-                                        ? workflow.taskDefaults.concurrency
-                                        : [workflow.taskDefaults.concurrency]
-                                    : [],
-                        });
-                    }),
-                    concurrency: concurrencySolo,
-                });
-                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.registerActionsV1(workflow);
-        });
-    }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -335,7 +173,7 @@ class V0Worker {
             const { actionId } = action;
             try {
                 // Note: we always use a DurableContext since its a superset of the Context class
-                const context = new step_1.DurableContext(action, this.client, this);
+                const context = new step_1.V0DurableContext(action, this.client, this);
                 this.contexts[action.stepRunId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
@@ -427,7 +265,7 @@ class V0Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { actionId } = action;
             try {
-                const context = new step_1.Context(action, this.client, this);
+                const context = new step_1.V0Context(action, this.client, this);
                 const key = action.getGroupKeyRunId;
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);

package/examples/fanout-worker.js

@@ -27,10 +27,9 @@ const parentWorkflow = {
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
                 const promises = Array.from({ length: 3 }, (_, i) => ctx
                     .spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: 'childValue' } })
-                    .result()
                     .then((result) => {
                     ctx.log('spawned workflow result:');
-                    return result;
+                    return result.output;
                 }));
                 const results = yield Promise.all(promises);
                 console.log('spawned workflow results:', results);

package/examples/manual-trigger.js

@@ -24,7 +24,7 @@ const hatchet = sdk_1.default.init();
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, e_1, _b, _c;
-        const workflowRun = hatchet.admin.runWorkflow('simple-workflow', {});
+        const workflowRun = yield hatchet.admin.runWorkflow('simple-workflow', {});
         const stream = yield workflowRun.stream();
         try {
             for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.3.1",
+  "version": "1.4.0-alpha.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -88,5 +88,6 @@
     "qs": "^6.14.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.2"
-  }
+  },
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0"
 }

package/protoc/workflows/workflows.d.ts

@@ -196,7 +196,7 @@ export interface ScheduleWorkflowRequest {
     /** (optional) the additional metadata for the workflow */
     additionalMetadata?: string | undefined;
     /** (optional) the priority of the workflow */
-    priority: number;
+    priority?: number | undefined;
 }
 /** ScheduledWorkflow represents a scheduled workflow. */
 export interface ScheduledWorkflow {

package/protoc/workflows/workflows.js

@@ -1409,7 +1409,7 @@ function createBaseScheduleWorkflowRequest() {
         childIndex: undefined,
         childKey: undefined,
         additionalMetadata: undefined,
-        priority: 0,
+        priority: undefined,
     };
 }
 exports.ScheduleWorkflowRequest = {
@@ -1438,7 +1438,7 @@ exports.ScheduleWorkflowRequest = {
         if (message.additionalMetadata !== undefined) {
             writer.uint32(66).string(message.additionalMetadata);
         }
-        if (message.priority !== 0) {
+        if (message.priority !== undefined) {
             writer.uint32(72).int32(message.priority);
         }
         return writer;
@@ -1537,7 +1537,7 @@ exports.ScheduleWorkflowRequest = {
             additionalMetadata: isSet(object.additionalMetadata)
                 ? globalThis.String(object.additionalMetadata)
                 : undefined,
-            priority: isSet(object.priority) ? globalThis.Number(object.priority) : 0,
+            priority: isSet(object.priority) ? globalThis.Number(object.priority) : undefined,
         };
     },
     toJSON(message) {
@@ -1567,7 +1567,7 @@ exports.ScheduleWorkflowRequest = {
         if (message.additionalMetadata !== undefined) {
             obj.additionalMetadata = message.additionalMetadata;
         }
-        if (message.priority !== 0) {
+        if (message.priority !== undefined) {
             obj.priority = Math.round(message.priority);
         }
         return obj;
@@ -1586,7 +1586,7 @@ exports.ScheduleWorkflowRequest = {
         message.childIndex = (_f = object.childIndex) !== null && _f !== void 0 ? _f : undefined;
         message.childKey = (_g = object.childKey) !== null && _g !== void 0 ? _g : undefined;
         message.additionalMetadata = (_h = object.additionalMetadata) !== null && _h !== void 0 ? _h : undefined;
-        message.priority = (_j = object.priority) !== null && _j !== void 0 ? _j : 0;
+        message.priority = (_j = object.priority) !== null && _j !== void 0 ? _j : undefined;
         return message;
     },
 };

package/step.d.ts

@@ -1,18 +1,20 @@
 import * as z from 'zod';
+import { JsonObject } from '@bufbuild/protobuf';
 import { Workflow } from './workflow';
 import { Action } from './clients/dispatcher/action-listener';
 import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
-import { InternalHatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
-import { V0Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
 import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
 import { CreateWorkflowTaskOpts, Priority } from './v1';
 import { RunOpts, TaskWorkflowDeclaration, BaseWorkflowDeclaration as WorkflowV1 } from './v1/declaration';
 import { Conditions } from './v1/conditions';
 import { Duration } from './v1/client/duration';
-import { JsonObject, JsonValue, OutputType } from './v1/types';
+import { JsonValue, OutputType } from './v1/types';
+import { V1Worker } from './v1/client/worker/worker-internal';
+import { V0Worker } from './clients/worker';
+import { LegacyHatchetClient } from './clients/hatchet-client';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -169,7 +171,7 @@ interface ContextData<T, K> {
 }
 export declare class ContextWorker {
     private worker;
-    constructor(worker: V0Worker);
+    constructor(worker: V0Worker | V1Worker);
     /**
      * Gets the ID of the worker.
      * @returns The ID of the worker.
@@ -193,17 +195,17 @@ export declare class ContextWorker {
      */
     upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }
-export declare class Context<T, K = {}> {
+export declare class V0Context<T, K = {}> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;
     action: Action;
-    client: InternalHatchetClient;
+    v0: LegacyHatchetClient;
     worker: ContextWorker;
     overridesData: Record<string, any>;
     logger: Logger;
     spawnIndex: number;
-    constructor(action: Action, client: InternalHatchetClient, worker: V0Worker);
+    constructor(action: Action, client: LegacyHatchetClient, worker: V0Worker | V1Worker);
     get abortController(): AbortController;
     get cancelled(): boolean;
     /**
@@ -359,7 +361,7 @@ export declare class Context<T, K = {}> {
      * @param options - An options object containing key, sticky, priority, and additionalMetadata.
      * @returns A reference to the spawned workflow run.
      */
-    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: ChildRunOpts): WorkflowRunRef<P>;
+    runNoWaitChild<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: ChildRunOpts): Promise<WorkflowRunRef<P>>;
     /**
      * Spawns a new workflow.
      *
@@ -369,7 +371,7 @@ export declare class Context<T, K = {}> {
      * @returns A reference to the spawned workflow run.
      * @deprecated Use runChild or runNoWaitChild instead.
      */
-    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, options?: ChildRunOpts): WorkflowRunRef<P>;
+    spawnWorkflow<Q extends JsonObject, P extends JsonObject>(workflow: string | Workflow | WorkflowV1<Q, P> | TaskWorkflowDeclaration<Q, P>, input: Q, options?: ChildRunOpts): Promise<WorkflowRunRef<P>>;
     /**
      * Retrieves additional metadata associated with the current workflow run.
      * @returns A record of metadata key-value pairs.
@@ -392,7 +394,7 @@ export declare class Context<T, K = {}> {
     parentWorkflowRunId(): string | undefined;
     priority(): Priority | undefined;
 }
-export declare class DurableContext<T, K = {}> extends Context<T, K> {
+export declare class V0DurableContext<T, K = {}> extends V0Context<T, K> {
     waitKey: number;
     /**
      * Pauses execution for the specified duration.
@@ -409,7 +411,7 @@ export declare class DurableContext<T, K = {}> extends Context<T, K> {
      */
     waitFor(conditions: Conditions | Conditions[]): Promise<Record<string, any>>;
 }
-export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep | void> | NextStep | void;
+export type StepRunFunction<T, K> = (ctx: V0Context<T, K>) => Promise<NextStep | void> | NextStep | void;
 /**
  * A step is a unit of work that can be run by a worker.
  * It is defined by a name, a function that returns the next step, and optional configuration.