motia 0.14.0-beta.165-285707 → 0.15.0-beta.165

package/dist/esm/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":";AAIA,OAAO,SAAS,CAAA"}

package/dist/esm/cli.js

@@ -1,188 +0,0 @@
-#!/usr/bin/env node
-import { MemoryStreamAdapterManager } from '@motiadev/core';
-import { program } from 'commander';
-import './cloud';
-import { handler } from './cloud/config-utils';
-import { loadMotiaConfig } from './load-motia-config';
-import { wrapAction } from './utils/analytics';
-import { version } from './version';
-const defaultPort = 3000;
-const defaultHost = '0.0.0.0';
-require('dotenv/config');
-require('ts-node').register({
-    transpileOnly: true,
-    compilerOptions: { module: 'commonjs' },
-});
-program
-    .command('version')
-    .description('Display detailed version information')
-    .action(() => {
-    console.log(`Motia CLI v${version}`);
-    process.exit(0);
-});
-program
-    .command('create [name]')
-    .description('Create a new motia project')
-    .option('-t, --template <template>', 'The template to use for your project')
-    .option('-p, --plugin', 'Create a plugin project')
-    .option('-i, --interactive', 'Use interactive prompts to create project') // it's default
-    .action((projectName, options) => {
-    const mergedArgs = { ...options, name: projectName };
-    return handler(async (arg, context) => {
-        const { createInteractive } = require('./create/interactive');
-        await createInteractive({
-            name: arg.name,
-            template: arg.template,
-            plugin: !!arg.plugin,
-        }, context);
-    })(mergedArgs);
-});
-program
-    .command('rules')
-    .command('pull')
-    .description('Install essential AI development guides (AGENTS.md, CLAUDE.md) and optional Cursor IDE rules')
-    .option('-f, --force', 'Overwrite existing files')
-    .action(handler(async (arg, context) => {
-    const { pullRules } = require('./create/pull-rules');
-    await pullRules({ force: arg.force, rootDir: process.cwd() }, context);
-}));
-program
-    .command('generate-types')
-    .description('Generate types.d.ts file for your project')
-    .action(wrapAction(async () => {
-    const { generateTypes } = require('./generate-types');
-    await generateTypes(process.cwd());
-    process.exit(0);
-}));
-program
-    .command('install')
-    .description('Sets up Python virtual environment and install dependencies')
-    .option('-v, --verbose', 'Enable verbose logging')
-    .action(wrapAction(async (options) => {
-    const { install } = require('./install');
-    await install({ isVerbose: options.verbose });
-}));
-program
-    .command('dev')
-    .description('Start the development server')
-    .option('-p, --port <port>', 'The port to run the server on', `${defaultPort}`)
-    .option('-H, --host [host]', 'The host address for the server', `${defaultHost}`)
-    .option('-v, --disable-verbose', 'Disable verbose logging')
-    .option('-d, --debug', 'Enable debug logging')
-    .option('-m, --mermaid', 'Enable mermaid diagram generation')
-    .option('--motia-dir <path>', 'Path where .motia folder will be created')
-    .action(wrapAction(async (arg) => {
-    if (arg.debug) {
-        console.log('🔍 Debug logging enabled');
-        process.env.LOG_LEVEL = 'debug';
-    }
-    const port = arg.port ? parseInt(arg.port) : defaultPort;
-    const host = arg.host ? arg.host : defaultHost;
-    const { dev } = require('./dev');
-    await dev(port, host, arg.disableVerbose, arg.mermaid, arg.motiaDir);
-}));
-program
-    .command('start')
-    .description('Start a server to run your Motia project')
-    .option('-p, --port <port>', 'The port to run the server on', `${defaultPort}`)
-    .option('-H, --host [host]', 'The host address for the server', `${defaultHost}`)
-    .option('-v, --disable-verbose', 'Disable verbose logging')
-    .option('-d, --debug', 'Enable debug logging')
-    .option('--motia-dir <path>', 'Path where .motia folder will be created')
-    .action(wrapAction(async (arg) => {
-    if (arg.debug) {
-        console.log('🔍 Debug logging enabled');
-        process.env.LOG_LEVEL = 'debug';
-    }
-    const port = arg.port ? parseInt(arg.port) : defaultPort;
-    const host = arg.host ? arg.host : defaultHost;
-    const { start } = require('./start');
-    await start(port, host, arg.disableVerbose, arg.motiaDir);
-}));
-program
-    .command('emit')
-    .description('Emit an event to the Motia server')
-    .requiredOption('--topic <topic>', 'Event topic/type to emit')
-    .requiredOption('--message <message>', 'Event payload as JSON string')
-    .option('-p, --port <number>', 'Port number (default: 3000)')
-    .action(wrapAction(async (options) => {
-    const port = options.port || 3000;
-    const url = `http://localhost:${port}/emit`;
-    const response = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            topic: options.topic,
-            data: JSON.parse(options.message),
-        }),
-    });
-    if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const result = await response.json();
-    console.log('Event emitted successfully:', result);
-}));
-const generate = program.command('generate').description('Generate motia resources');
-generate
-    .command('step')
-    .description('Create a new step with interactive prompts')
-    .option('-d, --dir <step file path>', 'The path relative to the steps directory, used to create the step file')
-    .action(wrapAction(async (arg) => {
-    const { createStep } = require('./create-step');
-    await createStep({
-        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(wrapAction(async (options) => {
-    const { generateLockedData } = require('./generate-locked-data');
-    const { generateOpenApi } = require('./openapi/generate');
-    const baseDir = process.cwd();
-    const appConfig = await loadMotiaConfig(baseDir);
-    const lockedData = await generateLockedData({
-        projectDir: baseDir,
-        streamAdapter: new MemoryStreamAdapterManager(),
-        streamAuth: appConfig.streamAuth,
-    });
-    const apiSteps = lockedData.apiSteps();
-    generateOpenApi(process.cwd(), apiSteps, options.title, options.version, options.output);
-    process.exit(0);
-}));
-const docker = program.command('docker').description('Motia docker commands');
-docker
-    .command('setup')
-    .description('Setup a motia-docker for your project')
-    .action(wrapAction(async () => {
-    const { setup } = require('./docker/setup');
-    await setup();
-    process.exit(0);
-}));
-docker
-    .command('run')
-    .description('Build and run your project in a docker container')
-    .option('-p, --port <port>', 'The port to run the server on', `${defaultPort}`)
-    .option('-n, --project-name <project name>', 'The name for your project')
-    .option('-s, --skip-build', 'Skip docker build')
-    .action(wrapAction(async (arg) => {
-    const { run } = require('./docker/run');
-    await run(arg.port, arg.projectName, arg.skipBuild);
-    process.exit(0);
-}));
-docker
-    .command('build')
-    .description('Build your project in a docker container')
-    .option('-n, --project-name <project name>', 'The name for your project')
-    .action(wrapAction(async (arg) => {
-    const { build } = require('./docker/build');
-    await build(arg.projectName);
-    process.exit(0);
-}));
-program.version(version, '-V, --version', 'Output the current version');
-program.parseAsync(process.argv).catch(() => {
-    process.exit(1);
-});

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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=infrastructure-serialization.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"infrastructure-serialization.test.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/build/__tests__/infrastructure-serialization.test.ts"],"names":[],"mappings":""}

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

@@ -1,320 +0,0 @@
-import { z } from '@motiadev/core/node_modules/zod';
-describe('Infrastructure Config Serialization', () => {
-    function createMockStepWithInfrastructure() {
-        const inputSchema = z.object({
-            traceId: z.string(),
-            userId: 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/esm/cloud/build/__tests__/infrastructure-validation.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=infrastructure-validation.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"infrastructure-validation.test.d.ts","sourceRoot":"","sources":["../../../../../src/cloud/build/__tests__/infrastructure-validation.test.ts"],"names":[],"mappings":""}