@hatchet-dev/typescript-sdk 0.12.5 → 0.13.1

package/step.js

@@ -225,7 +225,7 @@ class Context {
         const name = this.client.config.namespace + workflowName;
         let key = '';
         let sticky = false;
-        let metadata = undefined;
+        let metadata;
         if (typeof options === 'string') {
             this.logger.warn('Using key param is deprecated and will be removed in a future release. Use options.key instead.');
             key = options;

package/util/workflow-run-ref.js

@@ -73,16 +73,39 @@ class WorkflowRunRef {
             return new Promise((resolve, reject) => {
                 (() => __awaiter(this, void 0, void 0, function* () {
                     var _a, e_1, _b, _c;
+                    var _d, _e;
                     try {
-                        for (var _d = true, _e = __asyncValues(streamable.stream()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                            _c = _f.value;
-                            _d = false;
+                        for (var _f = true, _g = __asyncValues(streamable.stream()), _h; _h = yield _g.next(), _a = _h.done, !_a; _f = true) {
+                            _c = _h.value;
+                            _f = false;
                             const event = _c;
                             if (event.eventType === dispatcher_1.WorkflowRunEventType.WORKFLOW_RUN_EVENT_TYPE_FINISHED) {
                                 if (event.results.some((r) => !!r.error)) {
                                     reject(event.results);
                                     return;
                                 }
+                                if (event.results.length === 0) {
+                                    const data = yield this.client.api.workflowRunGetShape(this.client.config.tenant_id, event.workflowRunId);
+                                    const mostRecentJobRun = (_d = data.data.jobRuns) === null || _d === void 0 ? void 0 : _d[0];
+                                    if (!mostRecentJobRun) {
+                                        reject(new Error('No job runs found'));
+                                        return;
+                                    }
+                                    const outputs = {};
+                                    (_e = mostRecentJobRun.stepRuns) === null || _e === void 0 ? void 0 : _e.forEach((stepRun) => {
+                                        var _a, _b;
+                                        const readable = (_b = (_a = mostRecentJobRun.job) === null || _a === void 0 ? void 0 : _a.steps) === null || _b === void 0 ? void 0 : _b.find((step) => step.metadata.id === stepRun.stepId);
+                                        const readableStepName = `${readable === null || readable === void 0 ? void 0 : readable.readableId}`;
+                                        try {
+                                            outputs[readableStepName] = JSON.parse(stepRun.output || '{}');
+                                        }
+                                        catch (error) {
+                                            outputs[readableStepName] = stepRun.output;
+                                        }
+                                    });
+                                    resolve(outputs);
+                                    return;
+                                }
                                 const result = event.results.reduce((acc, r) => (Object.assign(Object.assign({}, acc), { [r.stepReadableId]: JSON.parse(r.output || '{}') })), {});
                                 resolve(result);
                                 return;
@@ -92,7 +115,7 @@ class WorkflowRunRef {
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                            if (!_f && !_a && (_b = _g.return)) yield _b.call(_g);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }

package/workflow.d.ts

@@ -69,14 +69,17 @@ export declare const WorkflowConcurrency: z.ZodObject<{
     name: z.ZodString;
     maxRuns: z.ZodOptional<z.ZodNumber>;
     limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
+    expression: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+    expression?: string | undefined;
 }, {
     name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+    expression?: string | undefined;
 }>;
 export declare const HatchetTimeoutSchema: z.ZodString;
 export declare const StickyStrategy: typeof PbStickyStrategy;
@@ -331,7 +334,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
     concurrency?: z.infer<typeof WorkflowConcurrency> & {
-        key: (ctx: any) => string;
+        key?: (ctx: any) => string;
     };
     steps: CreateStep<any, any>[];
     onFailure?: CreateStep<any, any>;

package/workflow.js

@@ -42,6 +42,7 @@ exports.WorkflowConcurrency = z.object({
     name: z.string(),
     maxRuns: z.number().optional(),
     limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
+    expression: z.string().optional(),
 });
 exports.HatchetTimeoutSchema = z.string();
 exports.StickyStrategy = workflows_1.StickyStrategy;