motia 0.8.2-beta.140-306759 → 0.8.2-beta.140-131607

package/README.md

@@ -10,7 +10,7 @@
 
 [💡 Motia Manifesto](https://www.motia.dev/manifesto) •
 [🚀 Quick Start](https://www.motia.dev/docs/getting-started/quick-start) •
-[📋 Defining Steps](https://www.motia.dev/docs/concepts/steps/defining-steps) •
+[📋 Defining Steps](https://www.motia.dev/docs/concepts/steps/steps) •
 [📚 Docs](https://www.motia.dev/docs)
 
 ---

package/dist/cjs/__tests__/openapi/generate.test.d.ts

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

package/dist/cjs/__tests__/openapi/generate.test.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generate_1 = require("../../openapi/generate");
+jest.mock('fs', () => ({
+    readFileSync: jest.fn(),
+    writeFileSync: jest.fn(),
+}));
+describe('generateOpenApi', () => {
+    const mockProjectDir = '/mock/project';
+    const mockOutputFile = 'mock-project-openapi.json';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fs.readFileSync.mockReturnValue(JSON.stringify({ name: 'test-project', version: '1.0.0' }));
+    });
+    const MOCK_API_STEP = {
+        filePath: '/mock/project/steps/test.ts',
+        version: '1.0.0',
+        config: {
+            type: 'api',
+            name: 'testApi',
+            path: '/test',
+            method: 'GET',
+            emits: [],
+        },
+    };
+    it('should generate a basic OpenAPI spec with default info', () => {
+        const apiSteps = [MOCK_API_STEP];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should handle bodySchema and responseSchema correctly', () => {
+        const mockBodySchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+            },
+        };
+        const mockResponseSchema = {
+            200: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string' },
+                },
+            },
+        };
+        const mockApiStep = {
+            ...MOCK_API_STEP,
+            config: {
+                ...MOCK_API_STEP.config,
+                type: 'api',
+                name: 'testApiWithSchemas',
+                path: '/test-schemas',
+                method: 'POST',
+                bodySchema: mockBodySchema,
+                responseSchema: mockResponseSchema,
+                emits: [],
+            },
+        };
+        const apiSteps = [mockApiStep];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test-schemas': {
+                    post: {
+                        summary: 'testApiWithSchemas',
+                        description: undefined,
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: mockBodySchema,
+                                },
+                            },
+                        },
+                        responses: {
+                            200: {
+                                description: 'Response for status code 200',
+                                content: {
+                                    'application/json': {
+                                        schema: mockResponseSchema[200],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should use provided title', () => {
+        const apiSteps = [MOCK_API_STEP];
+        const customTitle = 'Custom API';
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, customTitle);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: customTitle,
+                version: '1.0.0',
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, 'openapi.json'), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should use provided version', () => {
+        const apiSteps = [MOCK_API_STEP];
+        const customVersion = '2.0.0';
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, customVersion, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: customVersion,
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should handle complex bodySchema with anyOf, nullable, and $ref', () => {
+        const mockUserSchema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                email: { type: 'string', format: 'email' },
+            },
+            required: ['name', 'email'],
+        };
+        const mockComplexBodySchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                status: {
+                    anyOf: [{ type: 'string', enum: ['active', 'inactive'] }, { type: 'number', enum: [0, 1] }, { type: 'null' }],
+                },
+                user: { $ref: '#/components/schemas/User' },
+            },
+            required: ['id'],
+            $defs: {
+                User: mockUserSchema,
+            },
+        };
+        const mockApiStep = {
+            ...MOCK_API_STEP,
+            filePath: '/mock/project/steps/complex.ts',
+            config: {
+                ...MOCK_API_STEP.config,
+                type: 'api',
+                name: 'testComplexApi',
+                path: '/test-complex',
+                method: 'PUT',
+                emits: [],
+                bodySchema: mockComplexBodySchema,
+            },
+        };
+        const apiSteps = [mockApiStep];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test-complex': {
+                    put: {
+                        summary: 'testComplexApi',
+                        description: undefined,
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            id: { type: 'string' },
+                                            status: {
+                                                anyOf: [
+                                                    { type: 'string', enum: ['active', 'inactive'] },
+                                                    { type: 'number', enum: [0, 1] },
+                                                ],
+                                                nullable: true,
+                                            },
+                                            user: { $ref: '#/components/schemas/User' },
+                                        },
+                                        required: ['id'],
+                                    },
+                                },
+                            },
+                        },
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    User: mockUserSchema,
+                },
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+});

package/dist/cjs/cli.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-require-imports */
 const commander_1 = require("commander");
 require("./cloud");
-const version_1 = require("./version");
 const config_utils_1 = require("./cloud/config-utils");
+const version_1 = require("./version");
 const defaultPort = 3000;
 const defaultHost = '0.0.0.0';
 require('dotenv/config');
@@ -56,11 +56,9 @@ commander_1.program
     .command('install')
     .description('Sets up Python virtual environment and install dependencies')
     .option('-v, --verbose', 'Enable verbose logging')
-    .option('-p, --python <python_version>', 'Specify the python version to use, only supported >3.12')
-    .option('-d, --docker', 'Indicate if the install is for a motia docker install')
     .action(async (options) => {
     const { install } = require('./install');
-    await install({ isVerbose: options.verbose, pythonVersion: options.python, skipPythonPlatform: !!options.docker });
+    await install({ isVerbose: options.verbose });
 });
 commander_1.program
     .command('dev')
@@ -137,6 +135,20 @@ generate
         stepFilePath: arg.dir,
     });
 });
+generate
+    .command('openapi')
+    .description('Generate OpenAPI spec for your project')
+    .option('-t, --title <title>', 'Title for the OpenAPI document. Defaults to project name')
+    .option('-v, --version <version>', 'Version for the OpenAPI document. Defaults to 1.0.0', '1.0.0')
+    .option('-o, --output <output>', 'Output file for the OpenAPI document. Defaults to openapi.json', 'openapi.json')
+    .action(async (options) => {
+    const { generateLockedData } = require('./generate-locked-data');
+    const { generateOpenApi } = require('./openapi/generate');
+    const lockedData = await generateLockedData(process.cwd());
+    const apiSteps = lockedData.apiSteps();
+    generateOpenApi(process.cwd(), apiSteps, options.title, options.version, options.output);
+    process.exit(0);
+});
 const docker = commander_1.program.command('docker').description('Motia docker commands');
 docker
     .command('setup')

package/dist/cjs/cloud/build/__tests__/infrastructure-serialization.test.d.ts

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

package/dist/cjs/cloud/build/__tests__/infrastructure-serialization.test.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("@motiadev/core/node_modules/zod");
+describe('Infrastructure Config Serialization', () => {
+    function createMockStepWithInfrastructure() {
+        const inputSchema = zod_1.z.object({
+            traceId: zod_1.z.string(),
+            userId: zod_1.z.string(),
+        });
+        return {
+            type: 'node',
+            entrypointPath: '/mock/steps/testStep.step.ts',
+            filePath: '/mock/project/steps/testStep.step.ts',
+            config: {
+                type: 'event',
+                name: 'testStep',
+                description: 'Test step with infrastructure',
+                subscribes: ['test.event'],
+                emits: [],
+                input: inputSchema,
+                infrastructure: {
+                    handler: {
+                        ram: 2048,
+                        timeout: 30,
+                        cpu: 1,
+                    },
+                    queue: {
+                        type: 'fifo',
+                        visibilityTimeout: 31,
+                        messageGroupId: 'traceId',
+                        maxRetries: 5,
+                    },
+                },
+            },
+        };
+    }
+    function createMockStepWithoutInfrastructure() {
+        return {
+            type: 'node',
+            entrypointPath: '/mock/steps/legacyStep.step.ts',
+            filePath: '/mock/project/steps/legacyStep.step.ts',
+            config: {
+                type: 'event',
+                name: 'legacyStep',
+                description: 'Legacy step without infrastructure',
+                subscribes: ['test.event'],
+                emits: [],
+                input: {},
+            },
+        };
+    }
+    function createMockStepWithPartialInfrastructure() {
+        return {
+            type: 'node',
+            entrypointPath: '/mock/steps/partialStep.step.ts',
+            filePath: '/mock/project/steps/partialStep.step.ts',
+            config: {
+                type: 'event',
+                name: 'partialStep',
+                description: 'Step with partial infrastructure',
+                subscribes: ['test.event'],
+                emits: [],
+                input: {},
+                infrastructure: {
+                    handler: {
+                        ram: 4096,
+                        timeout: 60,
+                    },
+                },
+            },
+        };
+    }
+    describe('JSON Serialization', () => {
+        it('should serialize step with infrastructure config correctly', () => {
+            const step = createMockStepWithInfrastructure();
+            const stepsConfig = { testStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile, null, 2);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.testStep).toBeDefined();
+            expect(parsed.steps.testStep.config.infrastructure).toBeDefined();
+            expect(parsed.steps.testStep.config.infrastructure.handler).toBeDefined();
+            expect(parsed.steps.testStep.config.infrastructure.queue).toBeDefined();
+        });
+        it('should serialize handler configuration correctly', () => {
+            const step = createMockStepWithInfrastructure();
+            const stepsConfig = { testStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            const handler = parsed.steps.testStep.config.infrastructure.handler;
+            expect(handler.ram).toBe(2048);
+            expect(handler.timeout).toBe(30);
+            expect(handler.cpu).toBe(1);
+        });
+        it('should serialize queue configuration correctly', () => {
+            const step = createMockStepWithInfrastructure();
+            const stepsConfig = { testStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            const queue = parsed.steps.testStep.config.infrastructure.queue;
+            expect(queue.type).toBe('fifo');
+            expect(queue.visibilityTimeout).toBe(31);
+            expect(queue.messageGroupId).toBe('traceId');
+            expect(queue.maxRetries).toBe(5);
+        });
+        it('should serialize partial infrastructure config correctly', () => {
+            const step = createMockStepWithPartialInfrastructure();
+            const stepsConfig = { partialStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.partialStep.config.infrastructure).toBeDefined();
+            expect(parsed.steps.partialStep.config.infrastructure.handler).toBeDefined();
+            expect(parsed.steps.partialStep.config.infrastructure.queue).toBeUndefined();
+            const handler = parsed.steps.partialStep.config.infrastructure.handler;
+            expect(handler.ram).toBe(4096);
+            expect(handler.timeout).toBe(60);
+        });
+    });
+    describe('Backward Compatibility', () => {
+        it('should serialize step without infrastructure config correctly', () => {
+            const step = createMockStepWithoutInfrastructure();
+            const stepsConfig = { legacyStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile, null, 2);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.legacyStep).toBeDefined();
+            expect(parsed.steps.legacyStep.config.name).toBe('legacyStep');
+            expect(parsed.steps.legacyStep.config.type).toBe('event');
+            expect(parsed.steps.legacyStep.config.infrastructure).toBeUndefined();
+        });
+        it('should handle mixed steps (with and without infrastructure)', () => {
+            const stepWithInfra = createMockStepWithInfrastructure();
+            const stepWithoutInfra = createMockStepWithoutInfrastructure();
+            const stepsConfig = {
+                testStep: stepWithInfra,
+                legacyStep: stepWithoutInfra,
+            };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.testStep.config.infrastructure).toBeDefined();
+            expect(parsed.steps.legacyStep.config.infrastructure).toBeUndefined();
+        });
+        it('should maintain all existing step properties when infrastructure is added', () => {
+            const step = createMockStepWithInfrastructure();
+            const stepsConfig = { testStep: step };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            const config = parsed.steps.testStep.config;
+            expect(config.type).toBe('event');
+            expect(config.name).toBe('testStep');
+            expect(config.description).toBe('Test step with infrastructure');
+            expect(config.subscribes).toEqual(['test.event']);
+            expect(config.emits).toEqual([]);
+        });
+        it('should not break existing step configs when infrastructure field is absent', () => {
+            const apiStep = {
+                type: 'node',
+                entrypointPath: '/mock/steps/apiStep.step.ts',
+                filePath: '/mock/project/steps/apiStep.step.ts',
+                config: {
+                    type: 'api',
+                    name: 'apiStep',
+                    description: 'API step without infrastructure',
+                    path: '/test',
+                    method: 'GET',
+                    emits: [],
+                },
+            };
+            const stepsConfig = { apiStep };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.apiStep.config.type).toBe('api');
+            expect(parsed.steps.apiStep.config.path).toBe('/test');
+            expect(parsed.steps.apiStep.config.method).toBe('GET');
+            expect(parsed.steps.apiStep.config.infrastructure).toBeUndefined();
+        });
+        it('should not break existing cron step configs', () => {
+            const cronStep = {
+                type: 'node',
+                entrypointPath: '/mock/steps/cronStep.step.ts',
+                filePath: '/mock/project/steps/cronStep.step.ts',
+                config: {
+                    type: 'cron',
+                    name: 'cronStep',
+                    description: 'Cron step without infrastructure',
+                    cron: '0 0 * * *',
+                    emits: [],
+                },
+            };
+            const stepsConfig = { cronStep };
+            const stepsFile = {
+                steps: stepsConfig,
+                streams: {},
+                routers: {},
+            };
+            const json = JSON.stringify(stepsFile);
+            const parsed = JSON.parse(json);
+            expect(parsed.steps.cronStep.config.type).toBe('cron');
+            expect(parsed.steps.cronStep.config.cron).toBe('0 0 * * *');
+            expect(parsed.steps.cronStep.config.infrastructure).toBeUndefined();
+        });
+    });
+    describe('Deserialization', () => {
+        it('should deserialize step with infrastructure config correctly', () => {
+            const jsonString = JSON.stringify({
+                steps: {
+                    testStep: {
+                        type: 'node',
+                        entrypointPath: '/mock/steps/testStep.step.ts',
+                        filePath: '/mock/project/steps/testStep.step.ts',
+                        config: {
+                            type: 'event',
+                            name: 'testStep',
+                            subscribes: ['test.event'],
+                            emits: [],
+                            infrastructure: {
+                                handler: {
+                                    ram: 2048,
+                                    timeout: 30,
+                                },
+                                queue: {
+                                    type: 'standard',
+                                    visibilityTimeout: 60,
+                                    maxRetries: 3,
+                                },
+                            },
+                        },
+                    },
+                },
+                streams: {},
+                routers: {},
+            });
+            const parsed = JSON.parse(jsonString);
+            expect(parsed.steps.testStep).toBeDefined();
+            const config = parsed.steps.testStep.config;
+            expect(config.infrastructure).toBeDefined();
+            const infra = config.infrastructure;
+            expect(infra.handler.ram).toBe(2048);
+            expect(infra.queue.type).toBe('standard');
+        });
+        it('should deserialize step without infrastructure config correctly', () => {
+            const jsonString = JSON.stringify({
+                steps: {
+                    legacyStep: {
+                        type: 'node',
+                        entrypointPath: '/mock/steps/legacyStep.step.ts',
+                        filePath: '/mock/project/steps/legacyStep.step.ts',
+                        config: {
+                            type: 'event',
+                            name: 'legacyStep',
+                            subscribes: ['test.event'],
+                            emits: [],
+                        },
+                    },
+                },
+                streams: {},
+                routers: {},
+            });
+            const parsed = JSON.parse(jsonString);
+            expect(parsed.steps.legacyStep).toBeDefined();
+            expect(parsed.steps.legacyStep.config.infrastructure).toBeUndefined();
+        });
+    });
+    describe('Type Safety', () => {
+        it('should maintain type safety with infrastructure config', () => {
+            const step = createMockStepWithInfrastructure();
+            const config = step.config;
+            expect(config.infrastructure).toBeDefined();
+            expect(typeof config.infrastructure).toBe('object');
+            const infra = config.infrastructure;
+            expect(typeof infra.handler).toBe('object');
+            expect(typeof infra.queue).toBe('object');
+        });
+        it('should handle undefined infrastructure gracefully', () => {
+            const step = createMockStepWithoutInfrastructure();
+            const config = step.config;
+            expect(config.infrastructure).toBeUndefined();
+            expect(() => {
+                const infra = config.infrastructure;
+                if (infra) {
+                    console.log(infra.handler);
+                }
+            }).not.toThrow();
+        });
+    });
+});

package/dist/cjs/cloud/build/__tests__/infrastructure-validation.test.d.ts

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