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

package/dist/esm/create/utils.js

@@ -1,13 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-export const checkIfFileExists = (dir, fileName) => {
-    return fs.existsSync(path.join(dir, fileName));
-};
-export const checkIfDirectoryExists = (dir) => {
-    try {
-        return fs.statSync(dir).isDirectory();
-    }
-    catch {
-        return false;
-    }
-};

package/dist/esm/create-step/getAnswers.d.ts

@@ -1,3 +0,0 @@
-import { type StepAnswers } from './types';
-export declare const getStepAnswers: () => Promise<StepAnswers>;
-//# sourceMappingURL=getAnswers.d.ts.map

package/dist/esm/create-step/getAnswers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getAnswers.d.ts","sourceRoot":"","sources":["../../../src/create-step/getAnswers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuC,KAAK,WAAW,EAAE,MAAM,SAAS,CAAA;AAE/E,eAAO,MAAM,cAAc,QAAa,OAAO,CAAC,WAAW,CAmK1D,CAAA"}

package/dist/esm/create-step/getAnswers.js

@@ -1,163 +0,0 @@
-import inquirer from 'inquirer';
-import pc from 'picocolors';
-import { HTTP_METHODS, LANGUAGES, STEP_TYPES } from './types';
-export const getStepAnswers = async () => {
-    console.log('\n📝 ', pc.bold('Create a new Motia step\n'));
-    // Basic information prompts
-    const basicInfo = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'name',
-            message: 'Step name:',
-            validate: (input) => {
-                if (input.length === 0)
-                    return 'Name is required';
-                if (!/^[a-zA-Z][a-zA-Z0-9-_]*$/.test(input)) {
-                    return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores';
-                }
-                return true;
-            },
-        },
-        {
-            type: 'list',
-            name: 'type',
-            message: 'Select step type:',
-            choices: STEP_TYPES.map((type) => ({
-                name: type.toUpperCase(),
-                value: type,
-            })),
-        },
-    ]);
-    let answers = { ...basicInfo };
-    const languageAnswer = {
-        type: 'list',
-        name: 'language',
-        message: 'Select language:',
-        choices: LANGUAGES.map((lang) => ({
-            name: lang.charAt(0).toUpperCase() + lang.slice(1),
-            value: lang,
-        })),
-    };
-    // Type-specific configuration prompts
-    if (answers.type === 'api') {
-        const apiConfig = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'method',
-                message: 'HTTP method:',
-                choices: HTTP_METHODS,
-            },
-            {
-                type: 'input',
-                name: 'path',
-                message: 'API path (e.g. /users):',
-                validate: (input) => {
-                    if (!input.startsWith('/'))
-                        return 'Path must start with /';
-                    return true;
-                },
-            },
-        ]);
-        answers = { ...answers, ...apiConfig };
-    }
-    else if (answers.type === 'event') {
-        const eventConfig = await inquirer.prompt([
-            languageAnswer,
-            {
-                type: 'input',
-                name: 'subscriptions',
-                message: 'Event subscriptions (comma-separated):',
-                filter: (input) => input
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean),
-            },
-        ]);
-        answers = { ...answers, ...eventConfig };
-    }
-    else if (answers.type === 'cron') {
-        const cronConfig = await inquirer.prompt([
-            languageAnswer,
-            {
-                type: 'input',
-                name: 'cronExpression',
-                message: 'Cron expression:',
-                validate: (input) => {
-                    if (!input)
-                        return 'Cron expression is required';
-                    const parts = input.split(' ');
-                    if (parts.length !== 5)
-                        return 'Invalid cron expression format';
-                    return true;
-                },
-            },
-        ]);
-        answers = { ...answers, ...cronConfig };
-    }
-    else if (answers.type === 'noop') {
-        const noopConfig = await inquirer.prompt([
-            languageAnswer,
-            {
-                type: 'input',
-                name: 'virtualEmits',
-                message: 'Virtual emits (comma-separated):',
-                filter: (input) => input
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean),
-            },
-            {
-                type: 'input',
-                name: 'virtualSubscribes',
-                message: 'Virtual subscribes (comma-separated):',
-                filter: (input) => input
-                    .split(',')
-                    .map((s) => s.trim())
-                    .filter(Boolean),
-            },
-        ]);
-        answers = { ...answers, ...noopConfig };
-    }
-    // Common configuration prompts
-    const commonConfig = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'flows',
-            message: 'Flow names (comma-separated):',
-            filter: (input) => input
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean),
-            validate: (input) => {
-                if (input.length === 0)
-                    return 'At least one flow is required';
-                return true;
-            },
-        },
-        {
-            type: 'input',
-            name: 'emits',
-            message: 'Events to emit (comma-separated):',
-            filter: (input) => input
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean),
-        },
-        {
-            type: 'input',
-            name: 'description',
-            message: 'Step description:',
-        },
-        {
-            type: 'confirm',
-            name: 'createOverride',
-            message: 'Create UI component override?',
-            default: false,
-        },
-    ]);
-    const nextAnswers = { ...answers, ...commonConfig };
-    return {
-        ...nextAnswers,
-        language: nextAnswers.type === 'api' ? 'typescript' : nextAnswers.language,
-    };
-};

package/dist/esm/create-step/index.d.ts

@@ -1,4 +0,0 @@
-export declare function createStep(options: {
-    stepFilePath?: string;
-}): Promise<void>;
-//# sourceMappingURL=index.d.ts.map

package/dist/esm/create-step/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/create-step/index.ts"],"names":[],"mappings":"AAQA,wBAAsB,UAAU,CAAC,OAAO,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,iBAsClE"}

package/dist/esm/create-step/index.js

@@ -1,41 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import pc from 'picocolors';
-import { getStepAnswers } from './getAnswers';
-import { generateTemplate } from './teamplateUtils';
-import { generateOverride } from './templates/ui/overrides';
-import { getFileExtension } from './utils';
-export async function createStep(options) {
-    try {
-        const answers = await getStepAnswers();
-        // Create steps directory if it doesn't exist
-        const stepDir = path.join(process.cwd(), 'steps', options?.stepFilePath || '');
-        if (!fs.existsSync(stepDir)) {
-            fs.mkdirSync(stepDir, { recursive: true });
-        }
-        // Create step file
-        const extension = getFileExtension(answers.language);
-        const stepPath = path.join(stepDir, `${answers.name}${answers.type === 'api' ? '.api' : ''}.step${extension}`);
-        // Check if file already exists
-        if (fs.existsSync(stepPath)) {
-            console.error(pc.red(`\n❌ Error: Step file already exists at ${stepPath}`));
-            process.exit(1);
-        }
-        // Generate and write step file
-        const stepContent = await generateTemplate(answers);
-        fs.writeFileSync(stepPath, stepContent);
-        console.log(pc.green(`\n✨ Created step file at ${stepPath}`));
-        // Create UI override if requested
-        if (answers.createOverride) {
-            const overridePath = path.join(stepDir, `${answers.name}.step.tsx`);
-            const overrideContent = await generateOverride(answers);
-            fs.writeFileSync(overridePath, overrideContent);
-            console.log(pc.green(`✨ Created UI override at ${overridePath}`));
-        }
-        console.log(pc.bold('\n🎉 Step creation complete!'));
-    }
-    catch (error) {
-        console.error(pc.red('\n❌ Error creating step:'), error);
-        process.exit(1);
-    }
-}

package/dist/esm/create-step/teamplateUtils.d.ts

@@ -1,6 +0,0 @@
-import type { StepAnswers } from './types';
-/**
- * Generates the appropriate template based on language and type
- */
-export declare function generateTemplate(answers: StepAnswers): Promise<string>;
-//# sourceMappingURL=teamplateUtils.d.ts.map

package/dist/esm/create-step/teamplateUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"teamplateUtils.d.ts","sourceRoot":"","sources":["../../../src/create-step/teamplateUtils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAiC1C;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAU5E"}

package/dist/esm/create-step/teamplateUtils.js

@@ -1,44 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-/**
- * Reads a template file and replaces variables
- */
-async function readTemplate(templatePath, answers) {
-    const content = await fs.readFile(templatePath, 'utf8');
-    return replaceTemplateVariables(content, answers);
-}
-/**
- * Replaces template variables with actual values
- */
-function replaceTemplateVariables(content, answers) {
-    const replacements = {
-        STEP_NAME: answers.name,
-        DESCRIPTION: answers.description || '',
-        FLOWS: JSON.stringify(answers.flows),
-        EMITS: JSON.stringify(answers.emits),
-        METHOD: answers.method || '',
-        PATH: answers.path || '',
-        SUBSCRIPTIONS: JSON.stringify(answers.subscriptions || []),
-        CRON_EXPRESSION: answers.cronExpression || '',
-        VIRTUAL_EMITS: JSON.stringify(answers.virtualEmits || []),
-        VIRTUAL_SUBSCRIBES: JSON.stringify(answers.virtualSubscribes || []),
-    };
-    return Object.entries(replacements).reduce((content, [key, value]) => {
-        const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
-        return content.replace(regex, String(value));
-    }, content);
-}
-/**
- * Generates the appropriate template based on language and type
- */
-export async function generateTemplate(answers) {
-    const templateDir = path.join(__dirname, 'templates', answers.type);
-    const templateFile = `template.${answers.language}.txt`;
-    const templatePath = path.join(templateDir, templateFile);
-    try {
-        return await readTemplate(templatePath, answers);
-    }
-    catch (error) {
-        throw new Error(`Failed to generate template: ${error}`);
-    }
-}

package/dist/esm/create-step/templates/api/template.javascript.txt

@@ -1,25 +0,0 @@
-const { z } = require('zod')
-
-export const config = {
-  type: 'api',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  path: '{{PATH}}',
-  method: '{{METHOD}}',
-  emits: {{EMITS}},
-  flows: {{FLOWS}},
-  bodySchema: z.object({
-    // Add your schema here
-  })
-}
-
-export const handler = async (req, { logger, emit }) => {
-  logger.info('Processing {{STEP_NAME}}', req)
-
-  // Add your handler logic here
-  
-  return {
-    status: 200,
-    body: { message: 'Success' }
-  }
-}

package/dist/esm/create-step/templates/api/template.python.txt

@@ -1,29 +0,0 @@
-config = {
-    "type": "api",
-    "name": "{{STEP_NAME}}",
-    "description": "{{DESCRIPTION}}",
-    "path": "{{PATH}}",
-    "method": "{{METHOD}}",
-    "emits": {{EMITS}},
-    "flows": {{FLOWS}},
-    "bodySchema": None,  # Replace with Pydantic model for validation
-}
-
-# Example of using Pydantic for request body validation:
-# from pydantic import BaseModel
-# 
-# class RequestBody(BaseModel):
-#     message: str
-#     count: int = 0
-# 
-# config["bodySchema"] = RequestBody
-
-async def handler(req, context):
-    context.logger.info("Processing {{STEP_NAME}}", req)
-
-    # Add your handler logic here
-    
-    return {
-        "status": 200,
-        "body": {"message": "Success"}
-    }

package/dist/esm/create-step/templates/api/template.ruby.txt

@@ -1,22 +0,0 @@
-def config
-  {
-    type: 'api',
-    name: '{{STEP_NAME}}',
-    description: '{{DESCRIPTION}}',
-    path: '{{PATH}}',
-    method: '{{METHOD}}',
-    emits: {{EMITS}},
-    flows: {{FLOWS}}
-  }
-end
-
-def handler(req, context)
-  context.logger.info('Processing {{STEP_NAME}}', req)
-
-  # Add your handler logic here
-  
-  {
-    status: 200,
-    body: { message: 'Success' }
-  }
-end

package/dist/esm/create-step/templates/api/template.typescript.txt

@@ -1,31 +0,0 @@
-import { ApiRouteConfig, Handlers } from 'motia'
-import { z } from 'zod'
-
-export const config: ApiRouteConfig = {
-  type: 'api',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  path: '{{PATH}}',
-  method: '{{METHOD}}',
-  emits: {{EMITS}},
-  flows: {{FLOWS}},
-  bodySchema: z.object({
-    // Add your schema here
-  }),
-  responseSchema: {
-    200: z.object({ 
-      // add your response schema here
-    }),
-  },
-}
-
-export const handler: Handlers['{{STEP_NAME}}'] = async (req, { logger, emit }) => {
-  logger.info('Processing {{STEP_NAME}}', req)
-
-  // Add your handler logic here
-  
-  return {
-    status: 200,
-    body: { message: 'Success' }
-  }
-}

package/dist/esm/create-step/templates/cron/template.javascript.txt

@@ -1,20 +0,0 @@
-export const config = {
-  type: 'cron',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  cron: '{{CRON_EXPRESSION}}',
-  emits: {{EMITS}},
-  flows: {{FLOWS}}
-}
-
-export const handler = async ({ logger, emit }) => {
-  logger.info('Running {{STEP_NAME}} cron job')
-
-  // Add your cron logic here
-  
-  // Example emit
-  // await emit({
-  //   topic: 'event-type',
-  //   data: {}
-  // })
-}

package/dist/esm/create-step/templates/cron/template.python.txt

@@ -1,19 +0,0 @@
-config = {
-    "type": "cron",
-    "name": "{{STEP_NAME}}",
-    "description": "{{DESCRIPTION}}",
-    "cron": "{{CRON_EXPRESSION}}",
-    "emits": {{EMITS}},
-    "flows": {{FLOWS}}
-}
-
-async def handler(context):
-    context.logger.info("Running {{STEP_NAME}} cron job")
-
-    # Add your cron logic here
-    
-    # Example emit
-    # await context.emit({
-    #     "topic": "event-type",
-    #     "data": {}
-    # })

package/dist/esm/create-step/templates/cron/template.ruby.txt

@@ -1,22 +0,0 @@
-def config
-  {
-    type: 'cron',
-    name: '{{STEP_NAME}}',
-    description: '{{DESCRIPTION}}',
-    cron: '{{CRON_EXPRESSION}}',
-    emits: {{EMITS}},
-    flows: {{FLOWS}}
-  }
-end
-
-def handler(context)
-  context.logger.info('Running {{STEP_NAME}} cron job')
-
-  # Add your cron logic here
-  
-  # Example emit
-  # context.emit({
-  #   topic: 'event-type',
-  #   data: {}
-  # })
-end

package/dist/esm/create-step/templates/cron/template.type.txt

@@ -1,22 +0,0 @@
-import { CronConfig, Handlers } from 'motia'
-
-export const config: CronConfig = {
-  type: 'cron',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  cron: '{{CRON_EXPRESSION}}',
-  emits: {{EMITS}},
-  flows: {{FLOWS}}
-}
-
-export const handler: Handlers['{{STEP_NAME}}'] = async ({ logger, emit }) => {
-  logger.info('Running {{STEP_NAME}} cron job')
-
-  // Add your cron logic here
-  
-  // Example emit
-  // await emit({
-  //   topic: 'event-type',
-  //   data: {}
-  // })
-}

package/dist/esm/create-step/templates/cron/template.typescript.txt

@@ -1,22 +0,0 @@
-import { CronConfig, FlowContext } from 'motia'
-
-export const config = {
-  type: 'cron',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  cron: '{{CRON_EXPRESSION}}',
-  emits: {{EMITS}},
-  flows: {{FLOWS}}
-}
-
-export const handler = async ({ logger, emit }: FlowContext) => {
-  logger.info('Running {{STEP_NAME}} cron job')
-
-  // Add your cron logic here
-  
-  // Example emit
-  // await emit({
-  //   topic: 'event-type',
-  //   data: {}
-  // })
-}

package/dist/esm/create-step/templates/event/template.javascript.txt

@@ -1,27 +0,0 @@
-const { z } = require('zod')
-
-const inputSchema = z.object({
-  // Add your schema here
-})
-
-export const config = {
-  type: 'event',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  subscribes: {{SUBSCRIPTIONS}},
-  emits: {{EMITS}},
-  input: inputSchema,
-  flows: {{FLOWS}}
-}
-
-export const handler = async (input, { logger, emit }) => {
-  logger.info('Processing {{STEP_NAME}}', input)
-
-  // Add your handler logic here
-  
-  // Example emit
-  // await emit({
-  //   topic: 'event-type',
-  //   data: {}
-  // })
-}

package/dist/esm/create-step/templates/event/template.python.txt

@@ -1,29 +0,0 @@
-config = {
-    "type": "event",
-    "name": "{{STEP_NAME}}",
-    "description": "{{DESCRIPTION}}",
-    "subscribes": {{SUBSCRIPTIONS}}, 
-    "emits": {{EMITS}},
-    "flows": {{FLOWS}},
-    "input": None,  # Replace with Pydantic model for validation
-}
-
-# Example of using Pydantic for input validation:
-# from pydantic import BaseModel
-# 
-# class InputModel(BaseModel):
-#     message: str
-#     count: int = 0
-# 
-# config["input"] = InputModel
-
-async def handler(args, ctx):
-    ctx.logger.info('Processing {{STEP_NAME}}', args)
-
-    # Add your handler logic here
-
-    # Add your handler logic here
-    # await ctx.emit({
-    #   topic: 'event-type',
-    #   data: {}
-    # })

package/dist/esm/create-step/templates/event/template.ruby.txt

@@ -1,22 +0,0 @@
-def config
-  {
-    type: 'event',
-    name: '{{STEP_NAME}}',
-    description: '{{DESCRIPTION}}',
-    subscribes: {{SUBSCRIPTIONS}},
-    emits: {{EMITS}},
-    flows: {{FLOWS}}
-  }
-end
-
-def handler(input, context)
-  context.logger.info('Processing {{STEP_NAME}}', input)
-
-  # Add your handler logic here
-  
-  # Example emit
-  # context.emit({
-  #   topic: 'event-type',
-  #   data: {}
-  # })
-end

package/dist/esm/create-step/templates/event/template.typescript.txt

@@ -1,26 +0,0 @@
-import { EventConfig, Handlers } from 'motia'
-import { z } from 'zod'
-
-export const config: EventConfig = {
-  type: 'event',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  subscribes: {{SUBSCRIPTIONS}},
-  emits: {{EMITS}},
-  input: inputSchema = z.object({
-    // Add your schema here
-  }),
-  flows: {{FLOWS}}
-}
-
-export const handler: Handlers['{{STEP_NAME}}'] = async (input, { logger, emit }) => {
-  logger.info('Processing {{STEP_NAME}}', input)
-
-  // Add your handler logic here
-  
-  // Example emit
-  // await emit({
-  //   topic: 'event-type',
-  //   data: {}
-  // })
-}

package/dist/esm/create-step/templates/noop/template.javascript.txt

@@ -1,8 +0,0 @@
-export const config = {
-  type: 'noop',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  virtualEmits: {{VIRTUAL_EMITS}},
-  virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
-  flows: {{FLOWS}}
-}

package/dist/esm/create-step/templates/noop/template.python.txt

@@ -1,8 +0,0 @@
-config = {
-    "type": "noop",
-    "name": "{{STEP_NAME}}",
-    "description": "{{DESCRIPTION}}",
-    "virtualEmits": {{VIRTUAL_EMITS}},
-    "virtualSubscribes": {{VIRTUAL_SUBSCRIBES}},
-    "flows": {{FLOWS}}
-}

package/dist/esm/create-step/templates/noop/template.ruby.txt

@@ -1,10 +0,0 @@
-def config
-  {
-    type: 'noop',
-    name: '{{STEP_NAME}}',
-    description: '{{DESCRIPTION}}',
-    virtualEmits: {{VIRTUAL_EMITS}},
-    virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
-    flows: {{FLOWS}}
-  }
-end

package/dist/esm/create-step/templates/noop/template.typescript.txt

@@ -1,10 +0,0 @@
-import { NoopConfig } from 'motia'
-
-export const config: NoopConfig = {
-  type: 'noop',
-  name: '{{STEP_NAME}}',
-  description: '{{DESCRIPTION}}',
-  virtualEmits: {{VIRTUAL_EMITS}},
-  virtualSubscribes: {{VIRTUAL_SUBSCRIBES}},
-  flows: {{FLOWS}}
-}