@mastra/inngest 0.11.0 → 0.11.1

package/dist/index.js

@@ -10,13 +10,17 @@ import { z } from 'zod';
 // src/index.ts
 function serve({ mastra, inngest }) {
   const wfs = mastra.getWorkflows();
-  const functions = Object.values(wfs).flatMap((wf) => {
-    if (wf instanceof InngestWorkflow) {
-      wf.__registerMastra(mastra);
-      return wf.getFunctions();
-    }
-    return [];
-  });
+  const functions = Array.from(
+    new Set(
+      Object.values(wfs).flatMap((wf) => {
+        if (wf instanceof InngestWorkflow) {
+          wf.__registerMastra(mastra);
+          return wf.getFunctions();
+        }
+        return [];
+      })
+    )
+  );
   return serve$1({
     client: inngest,
     functions
@@ -46,8 +50,14 @@ var InngestRun = class extends Run {
     while (runs?.[0]?.status !== "Completed" || runs?.[0]?.event_id !== eventId) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
       runs = await this.getRuns(eventId);
-      if (runs?.[0]?.status === "Failed" || runs?.[0]?.status === "Cancelled") {
+      if (runs?.[0]?.status === "Failed") {
         throw new Error(`Function run ${runs?.[0]?.status}`);
+      } else if (runs?.[0]?.status === "Cancelled") {
+        const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+          workflowName: this.workflowId,
+          runId: this.runId
+        });
+        return { output: { result: { steps: snapshot?.context, status: "canceled" } } };
       }
     }
     return runs?.[0];
@@ -58,6 +68,28 @@ var InngestRun = class extends Run {
       data
     });
   }
+  async cancel() {
+    await this.inngest.send({
+      name: `cancel.workflow.${this.workflowId}`,
+      data: {
+        runId: this.runId
+      }
+    });
+    const snapshot = await this.#mastra?.storage?.loadWorkflowSnapshot({
+      workflowName: this.workflowId,
+      runId: this.runId
+    });
+    if (snapshot) {
+      await this.#mastra?.storage?.persistWorkflowSnapshot({
+        workflowName: this.workflowId,
+        runId: this.runId,
+        snapshot: {
+          ...snapshot,
+          status: "canceled"
+        }
+      });
+    }
+  }
   async start({
     inputData
   }) {
@@ -91,7 +123,9 @@ var InngestRun = class extends Run {
     if (result.status === "failed") {
       result.error = new Error(result.error);
     }
-    this.cleanup?.();
+    if (result.status !== "suspended") {
+      this.cleanup?.();
+    }
     return result;
   }
   async resume(params) {
@@ -293,23 +327,26 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       this.inngest
     );
     this.runs.set(runIdToUse, run);
-    await this.mastra?.getStorage()?.persistWorkflowSnapshot({
-      workflowName: this.id,
-      runId: runIdToUse,
-      snapshot: {
+    const workflowSnapshotInStorage = await this.getWorkflowRunExecutionResult(runIdToUse);
+    if (!workflowSnapshotInStorage) {
+      await this.mastra?.getStorage()?.persistWorkflowSnapshot({
+        workflowName: this.id,
         runId: runIdToUse,
-        status: "pending",
-        value: {},
-        context: {},
-        activePaths: [],
-        serializedStepGraph: this.serializedStepGraph,
-        suspendedPaths: {},
-        result: void 0,
-        error: void 0,
-        // @ts-ignore
-        timestamp: Date.now()
-      }
-    });
+        snapshot: {
+          runId: runIdToUse,
+          status: "pending",
+          value: {},
+          context: {},
+          activePaths: [],
+          serializedStepGraph: this.serializedStepGraph,
+          suspendedPaths: {},
+          result: void 0,
+          error: void 0,
+          // @ts-ignore
+          timestamp: Date.now()
+        }
+      });
+    }
     return run;
   }
   getFunction() {
@@ -317,8 +354,12 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
       return this.function;
     }
     this.function = this.inngest.createFunction(
-      // @ts-ignore
-      { id: `workflow.${this.id}`, retries: this.retryConfig?.attempts ?? 0 },
+      {
+        id: `workflow.${this.id}`,
+        // @ts-ignore
+        retries: this.retryConfig?.attempts ?? 0,
+        cancelOn: [{ event: `cancel.workflow.${this.id}` }]
+      },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
         let { inputData, runId, resume } = event.data;
@@ -360,7 +401,8 @@ var InngestWorkflow = class _InngestWorkflow extends Workflow {
           retryConfig: this.retryConfig,
           runtimeContext: new RuntimeContext(),
           // TODO
-          resume
+          resume,
+          abortController: new AbortController()
         });
         return { result, runId };
       }
@@ -404,7 +446,7 @@ function createStep(params) {
       outputSchema: z.object({
         text: z.string()
       }),
-      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext }) => {
+      execute: async ({ inputData, [EMITTER_SYMBOL]: emitter, runtimeContext, abortSignal, abort }) => {
         let streamPromise = {};
         streamPromise.promise = new Promise((resolve, reject) => {
           streamPromise.resolve = resolve;
@@ -424,8 +466,12 @@ function createStep(params) {
           runtimeContext,
           onFinish: (result) => {
             streamPromise.resolve(result.text);
-          }
+          },
+          abortSignal
         });
+        if (abortSignal.aborted) {
+          return abort();
+        }
         for await (const chunk of fullStream) {
           switch (chunk.type) {
             case "text-delta":
@@ -600,6 +646,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
+    abortController,
     runtimeContext
   }) {
     return super.executeStep({
@@ -611,6 +658,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
       resume,
       prevOutput,
       emitter,
+      abortController,
       runtimeContext
     });
   }
@@ -634,6 +682,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     resume,
     prevOutput,
     emitter,
+    abortController,
     runtimeContext
   }) {
     const startedAt = await this.inngestStep.run(
@@ -664,7 +713,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
         await emitter.emit("watch-v2", {
           type: "step-start",
           payload: {
-            id: step.id
+            id: step.id,
+            status: "running"
           }
         });
         return startedAt2;
@@ -732,7 +782,9 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               type: "step-result",
               payload: {
                 id: step.id,
-                status: "failed"
+                status: "failed",
+                error: result?.error,
+                payload: prevOutput
               }
             });
             return { executionContext, result: { status: "failed", error: result?.error } };
@@ -764,7 +816,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               await emitter.emit("watch-v2", {
                 type: "step-suspended",
                 payload: {
-                  id: step.id
+                  id: step.id,
+                  status: "suspended"
                 }
               });
               return {
@@ -817,6 +870,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             },
             eventTimestamp: Date.now()
           });
+          await emitter.emit("watch-v2", {
+            type: "step-result",
+            payload: {
+              id: step.id,
+              status: "success",
+              output: result?.result
+            }
+          });
           await emitter.emit("watch-v2", {
             type: "step-finish",
             payload: {
@@ -865,7 +926,8 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           [EMITTER_SYMBOL]: emitter,
           engine: {
             step: this.inngestStep
-          }
+          },
+          abortSignal: abortController.signal
         });
         const endedAt = Date.now();
         execResults = {
@@ -927,8 +989,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           type: "step-suspended",
           payload: {
             id: step.id,
-            status: execResults.status,
-            output: execResults.status === "success" ? execResults?.output : void 0
+            ...execResults
           }
         });
       } else {
@@ -936,8 +997,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
           type: "step-result",
           payload: {
             id: step.id,
-            status: execResults.status,
-            output: execResults.status === "success" ? execResults?.output : void 0
+            ...execResults
           }
         });
         await emitter.emit("watch-v2", {
@@ -998,6 +1058,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
     resume,
     executionContext,
     emitter,
+    abortController,
     runtimeContext
   }) {
     let execResults;
@@ -1009,6 +1070,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               runId,
               mastra: this.mastra,
               runtimeContext,
+              runCount: -1,
               inputData: prevOutput,
               getInitData: () => stepResults?.input,
               getStepResult: (step) => {
@@ -1026,10 +1088,14 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
               },
               bail: () => {
               },
+              abort: () => {
+                abortController.abort();
+              },
               [EMITTER_SYMBOL]: emitter,
               engine: {
                 step: this.inngestStep
-              }
+              },
+              abortSignal: abortController.signal
             });
             return result ? index : null;
           } catch (e) {
@@ -1058,6 +1124,7 @@ var InngestExecutionEngine = class extends DefaultExecutionEngine {
             executionSpan: executionContext.executionSpan
           },
           emitter,
+          abortController,
           runtimeContext
         })
       )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/inngest",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Mastra Inngest integration",
   "type": "module",
   "main": "dist/index.js",
@@ -33,17 +33,17 @@
     "eslint": "^9.29.0",
     "execa": "^9.6.0",
     "get-port": "7.1.0",
-    "hono": "^4.7.11",
+    "hono": "^4.8.3",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^2.1.9",
-    "@internal/lint": "0.0.14",
-    "@mastra/core": "0.10.7",
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.16",
     "@mastra/libsql": "0.11.0",
-    "@mastra/deployer": "0.10.7"
+    "@mastra/deployer": "0.10.9",
+    "@mastra/core": "0.10.9"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
+    "@mastra/core": ">=0.10.9-0 <0.11.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/index.test.ts

@@ -732,6 +732,203 @@ describe('MastraInngestWorkflow', () => {
     });
   });
 
+  describe('abort', () => {
+    it('should be able to abort workflow execution in between steps', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData }) => {
+          return { result: 'step2: ' + inputData.result };
+        },
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1, step2],
+      });
+
+      workflow.then(step1).sleep(2000).then(step2).commit();
+
+      const mastra = new Mastra({
+        storage: new DefaultStorage({
+          url: ':memory:',
+        }),
+        workflows: {
+          'test-workflow': workflow,
+        },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
+      });
+
+      const app = await createHonoServer(mastra);
+
+      const srv = serve({
+        fetch: app.fetch,
+        port: (ctx as any).handlerPort,
+      });
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const run = await workflow.createRunAsync();
+      const p = run.start({ inputData: { value: 'test' } });
+
+      setTimeout(() => {
+        run.cancel();
+      }, 1000);
+
+      const result = await p;
+
+      srv.close();
+
+      expect(result.status).toBe('canceled');
+      expect(result.steps['step1']).toEqual({
+        status: 'success',
+        output: { result: 'step1: test' },
+        payload: { value: 'test' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+
+      expect(result.steps['step2']).toBeUndefined();
+    });
+
+    it('should be able to abort workflow execution during a step', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra',
+        baseUrl: `http://localhost:${(ctx as any).inngestPort}`,
+        middleware: [realtimeMiddleware()],
+      });
+
+      const { createWorkflow, createStep } = init(inngest);
+
+      const step1 = createStep({
+        id: 'step1',
+        execute: async ({ inputData }) => {
+          return { result: 'step1: ' + inputData.value };
+        },
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+      const step2 = createStep({
+        id: 'step2',
+        execute: async ({ inputData, abortSignal, abort }) => {
+          console.log('abort signal', abortSignal);
+          const timeout: Promise<string> = new Promise((resolve, _reject) => {
+            const ref = setTimeout(() => {
+              resolve('step2: ' + inputData.result);
+            }, 5000);
+
+            abortSignal.addEventListener('abort', () => {
+              resolve('');
+              clearTimeout(ref);
+            });
+          });
+
+          const result = await timeout;
+          if (abortSignal.aborted) {
+            return abort();
+          }
+          return { result };
+        },
+        inputSchema: z.object({ result: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+      });
+
+      const workflow = createWorkflow({
+        id: 'test-workflow',
+        inputSchema: z.object({}),
+        outputSchema: z.object({
+          result: z.string(),
+        }),
+        steps: [step1, step2],
+      });
+
+      workflow.then(step1).then(step2).commit();
+
+      const mastra = new Mastra({
+        storage: new DefaultStorage({
+          url: ':memory:',
+        }),
+        workflows: {
+          'test-workflow': workflow,
+        },
+        server: {
+          apiRoutes: [
+            {
+              path: '/inngest/api',
+              method: 'ALL',
+              createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+            },
+          ],
+        },
+      });
+
+      const app = await createHonoServer(mastra);
+
+      const srv = serve({
+        fetch: app.fetch,
+        port: (ctx as any).handlerPort,
+      });
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      const run = await workflow.createRunAsync();
+      const p = run.start({ inputData: { value: 'test' } });
+
+      setTimeout(() => {
+        run.cancel();
+      }, 1000);
+
+      const result = await p;
+      console.log('result', result);
+
+      srv.close();
+
+      expect(result.status).toBe('canceled');
+      expect(result.steps['step1']).toEqual({
+        status: 'success',
+        output: { result: 'step1: test' },
+        payload: { value: 'test' },
+        startedAt: expect.any(Number),
+        endedAt: expect.any(Number),
+      });
+
+      // expect(result.steps['step2']).toEqual({
+      //   status: 'canceled',
+      //   payload: { result: 'step1: test' },
+      //   output: undefined,
+      //   startedAt: expect.any(Number),
+      //   endedAt: expect.any(Number),
+      // });
+    });
+  });
+
   describe('Variable Resolution', () => {
     it('should resolve trigger data', async ctx => {
       const inngest = new Inngest({
@@ -5965,68 +6162,76 @@ describe('MastraInngestWorkflow', () => {
       srv.close();
 
       expect(watchData.length).toBe(8);
-      expect(watchData).toMatchInlineSnapshot(`
-        [
-          {
-            "payload": {
-              "runId": "test-run-id",
-            },
-            "type": "start",
+      expect(watchData).toMatchObject([
+        {
+          payload: {
+            runId: 'test-run-id',
           },
-          {
-            "payload": {
-              "id": "step1",
-            },
-            "type": "step-start",
+          type: 'start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            status: 'running',
           },
-          {
-            "payload": {
-              "id": "step1",
-              "output": {
-                "result": "success1",
-              },
-              "status": "success",
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step1',
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            payload: {},
+            output: {
+              result: 'success1',
             },
-            "type": "step-result",
+            status: 'success',
           },
-          {
-            "payload": {
-              "id": "step1",
-              "metadata": {},
-            },
-            "type": "step-finish",
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step1',
+            metadata: {},
           },
-          {
-            "payload": {
-              "id": "step2",
-            },
-            "type": "step-start",
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            id: 'step2',
+            status: 'running',
           },
-          {
-            "payload": {
-              "id": "step2",
-              "output": {
-                "result": "success2",
-              },
-              "status": "success",
+          type: 'step-start',
+        },
+        {
+          payload: {
+            id: 'step2',
+            endedAt: expect.any(Number),
+            startedAt: expect.any(Number),
+            payload: {
+              result: 'success1',
             },
-            "type": "step-result",
-          },
-          {
-            "payload": {
-              "id": "step2",
-              "metadata": {},
+            output: {
+              result: 'success2',
             },
-            "type": "step-finish",
+            status: 'success',
           },
-          {
-            "payload": {
-              "runId": "test-run-id",
-            },
-            "type": "finish",
+          type: 'step-result',
+        },
+        {
+          payload: {
+            id: 'step2',
+            metadata: {},
           },
-        ]
-      `);
+          type: 'step-finish',
+        },
+        {
+          payload: {
+            runId: 'test-run-id',
+          },
+          type: 'finish',
+        },
+      ]);
       // Verify execution completed successfully
       expect(executionResult.steps.step1).toMatchObject({
         status: 'success',