@mastra/inngest 0.12.3-alpha.0 → 0.12.3-alpha.1

package/src/index.test.ts

@@ -7904,4 +7904,180 @@ describe('MastraInngestWorkflow', () => {
       });
     });
   });
+
+  describe.sequential('Flow Control Configuration', () => {
+    it('should accept workflow configuration with flow control properties', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-flow-control',
+        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() }),
+      });
+
+      // Test workflow with flow control configuration
+      const workflow = createWorkflow({
+        id: 'flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // Flow control properties
+        concurrency: {
+          limit: 5,
+          key: 'event.data.userId',
+        },
+        rateLimit: {
+          period: '1h',
+          limit: 100,
+        },
+        priority: {
+          run: 'event.data.priority ?? 50',
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('flow-control-test');
+
+      // Verify that function creation includes flow control config
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should handle workflow configuration with partial flow control properties', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-partial-flow-control',
+        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() }),
+      });
+
+      // Test workflow with only some flow control properties
+      const workflow = createWorkflow({
+        id: 'partial-flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // Only concurrency control
+        concurrency: {
+          limit: 10,
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('partial-flow-control-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should handle workflow configuration without flow control properties (backward compatibility)', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-backward-compat',
+        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() }),
+      });
+
+      // Test workflow without any flow control properties (existing behavior)
+      const workflow = createWorkflow({
+        id: 'backward-compat-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        retryConfig: {
+          attempts: 3,
+          delay: 1000,
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('backward-compat-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+
+    it('should support all flow control configuration types', async ctx => {
+      const inngest = new Inngest({
+        id: 'mastra-all-flow-control',
+        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() }),
+      });
+
+      // Test workflow with all flow control configuration types
+      const workflow = createWorkflow({
+        id: 'all-flow-control-test',
+        inputSchema: z.object({ value: z.string() }),
+        outputSchema: z.object({ result: z.string() }),
+        steps: [step1],
+        // All flow control properties
+        concurrency: {
+          limit: 5,
+          key: 'event.data.userId',
+        },
+        rateLimit: {
+          period: '1m',
+          limit: 10,
+        },
+        throttle: {
+          period: '10s',
+          limit: 1,
+          key: 'event.data.organizationId',
+        },
+        debounce: {
+          period: '5s',
+          key: 'event.data.messageId',
+        },
+        priority: {
+          run: 'event.data.priority ?? 0',
+        },
+      });
+
+      expect(workflow).toBeDefined();
+      expect(workflow.id).toBe('all-flow-control-test');
+
+      const inngestFunction = workflow.getFunction();
+      expect(inngestFunction).toBeDefined();
+    });
+  });
 }, 40e3);

package/src/index.ts

@@ -33,6 +33,30 @@ import type { Inngest, BaseContext } from 'inngest';
 import { serve as inngestServe } from 'inngest/hono';
 import { z } from 'zod';
 
+// Extract Inngest's native flow control configuration types
+type InngestCreateFunctionConfig = Parameters<Inngest['createFunction']>[0];
+
+// Extract specific flow control properties (excluding batching)
+export type InngestFlowControlConfig = Pick<
+  InngestCreateFunctionConfig,
+  'concurrency' | 'rateLimit' | 'throttle' | 'debounce' | 'priority'
+>;
+
+// Union type for Inngest workflows with flow control
+export type InngestWorkflowConfig<
+  TWorkflowId extends string = string,
+  TInput extends z.ZodType<any> = z.ZodType<any>,
+  TOutput extends z.ZodType<any> = z.ZodType<any>,
+  TSteps extends Step<string, any, any, any, any, any>[] = Step<string, any, any, any, any, any>[],
+> = WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps> & InngestFlowControlConfig;
+
+// Compile-time compatibility assertion
+type _AssertInngestCompatibility =
+  InngestFlowControlConfig extends Pick<Parameters<Inngest['createFunction']>[0], keyof InngestFlowControlConfig>
+    ? true
+    : never;
+const _compatibilityCheck: _AssertInngestCompatibility = true;
+
 export type InngestEngineType = {
   step: any;
 };
@@ -342,9 +366,19 @@ export class InngestWorkflow<
   public inngest: Inngest;
 
   private function: ReturnType<Inngest['createFunction']> | undefined;
+  private readonly flowControlConfig?: InngestFlowControlConfig;
+
+  constructor(params: InngestWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
+    const { concurrency, rateLimit, throttle, debounce, priority, ...workflowParams } = params;
+
+    super(workflowParams as WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>);
+
+    const flowControlEntries = Object.entries({ concurrency, rateLimit, throttle, debounce, priority }).filter(
+      ([_, value]) => value !== undefined,
+    );
+
+    this.flowControlConfig = flowControlEntries.length > 0 ? Object.fromEntries(flowControlEntries) : undefined;
 
-  constructor(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>, inngest: Inngest) {
-    super(params);
     this.#mastra = params.mastra!;
     this.inngest = inngest;
   }
@@ -513,6 +547,8 @@ export class InngestWorkflow<
         // @ts-ignore
         retries: this.retryConfig?.attempts ?? 0,
         cancelOn: [{ event: `cancel.workflow.${this.id}` }],
+        // Spread flow control configuration
+        ...this.flowControlConfig,
       },
       { event: `workflow.${this.id}` },
       async ({ event, step, attempt, publish }) => {
@@ -801,7 +837,7 @@ export function init(inngest: Inngest) {
         any,
         InngestEngineType
       >[],
-    >(params: WorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
+    >(params: InngestWorkflowConfig<TWorkflowId, TInput, TOutput, TSteps>) {
       return new InngestWorkflow<InngestEngineType, TSteps, TWorkflowId, TInput, TOutput, TInput>(params, inngest);
     },
     createStep,