motia 0.8.2-beta.140-628177 → 0.8.2-beta.140-111855

package/dist/cjs/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-require-imports */
 const commander_1 = require("commander");
 require("./cloud");
 const config_utils_1 = require("./cloud/config-utils");
@@ -20,30 +19,6 @@ commander_1.program
     console.log(`Motia CLI v${version_1.version}`);
     process.exit(0);
 });
-commander_1.program
-    .command('test')
-    .description('Run all tests in your local project')
-    .option('-w, --watch', 'Run tests in watch mode')
-    .action(async (options) => {
-    // CommonJS style
-    const execa = require('execa'); // no destructuring
-    const projectRoot = process.cwd();
-    try {
-        await execa('npx', options.watch ? ['jest', '--watch'] : ['jest'], {
-            stdio: 'inherit',
-            cwd: projectRoot,
-        });
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            console.error('Error running tests:', err.message);
-        }
-        else {
-            console.error('Unknown error:', err);
-        }
-        process.exit(1);
-    }
-});
 commander_1.program
     .command('create [name]')
     .description('Create a new motia project')

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,322 @@
+"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,
+                        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.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 {};