@motiadev/core 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/index.d.ts

@@ -9,3 +9,4 @@ export { isApiStep, isCronStep, isEventStep, isNoopStep } from './src/guards';
 export { LockedData } from './src/locked-data';
 export { getStepConfig } from './src/get-step-config';
 export { StateAdapter } from './src/state/state-adapter';
+export { createMermaidGenerator } from './src/mermaid-generator';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
+exports.createMermaidGenerator = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
 var server_1 = require("./src/server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
@@ -38,3 +38,5 @@ var locked_data_1 = require("./src/locked-data");
 Object.defineProperty(exports, "LockedData", { enumerable: true, get: function () { return locked_data_1.LockedData; } });
 var get_step_config_1 = require("./src/get-step-config");
 Object.defineProperty(exports, "getStepConfig", { enumerable: true, get: function () { return get_step_config_1.getStepConfig; } });
+var mermaid_generator_1 = require("./src/mermaid-generator");
+Object.defineProperty(exports, "createMermaidGenerator", { enumerable: true, get: function () { return mermaid_generator_1.createMermaidGenerator; } });

package/dist/src/flows-config-endpoint.js

@@ -8,13 +8,16 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const flowsConfigEndpoint = (app, baseDir) => {
     const configPath = path_1.default.join(baseDir, 'motia-workbench.json');
+    const getConfig = () => {
+        if (fs_1.default.existsSync(configPath)) {
+            return JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+        }
+        return {};
+    };
     app.post('/flows/:id/config', (req, res) => {
         const newFlowConfig = req.body;
         try {
-            if (!fs_1.default.existsSync(configPath)) {
-                fs_1.default.writeFileSync(configPath, JSON.stringify({}, null, 2));
-            }
-            const existingConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            const existingConfig = getConfig();
             const updatedConfig = {
                 ...existingConfig,
             };
@@ -28,21 +31,20 @@ const flowsConfigEndpoint = (app, baseDir) => {
             res.status(200).send({ message: 'Flow config saved successfully' });
         }
         catch (error) {
-            console.error('Error saving flow config:', error);
+            console.error('Error saving flow config:', error.message);
             res.status(500).json({ error: 'Failed to save flow config' });
         }
     });
     app.get('/flows/:id/config', (req, res) => {
         const { id } = req.params;
         try {
-            const file = fs_1.default.readFileSync(configPath, 'utf8');
-            const allFlowsConfig = JSON.parse(file);
+            const allFlowsConfig = getConfig();
             const flowConfig = allFlowsConfig[id] || {};
             res.status(200).send(flowConfig);
         }
         catch (error) {
-            console.error('Error reading flow config:', error);
-            res.status(400).send({});
+            console.error('Error reading flow config:', error.message);
+            res.status(400).send({ error: 'Failed to read flow config' });
         }
     });
 };

package/dist/src/mermaid-generator.d.ts

@@ -0,0 +1,4 @@
+import { LockedData } from './locked-data';
+export declare const createMermaidGenerator: (baseDir: string) => {
+    initialize: (lockedData: LockedData) => void;
+};

package/dist/src/mermaid-generator.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMermaidGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const guards_1 = require("./guards");
+// Pure function to ensure diagrams directory exists
+const ensureDiagramsDirectory = (diagramsDir) => {
+    if (!fs_1.default.existsSync(diagramsDir)) {
+        fs_1.default.mkdirSync(diagramsDir, { recursive: true });
+    }
+};
+// Pure function to get node ID
+const getNodeId = (step, baseDir) => {
+    // Get relative path from the base directory
+    const relativePath = path_1.default.relative(baseDir, step.filePath);
+    // Remove common file extensions
+    const pathWithoutExtension = relativePath.replace(/\.(ts|js|tsx|jsx)$/, '');
+    // Replace slashes with underscores and dots with underscores
+    // Only keep alphanumeric characters and underscores
+    return pathWithoutExtension.replace(/[^a-zA-Z0-9]/g, '_');
+};
+// Pure function to get node label
+const getNodeLabel = (step) => {
+    // Get display name for node
+    const displayName = step.config.name || path_1.default.basename(step.filePath, path_1.default.extname(step.filePath));
+    // Add node type prefix to help distinguish types
+    let prefix = '';
+    if ((0, guards_1.isApiStep)(step))
+        prefix = '🌐 ';
+    else if ((0, guards_1.isEventStep)(step))
+        prefix = '⚡ ';
+    else if ((0, guards_1.isCronStep)(step))
+        prefix = '⏰ ';
+    else if ((0, guards_1.isNoopStep)(step))
+        prefix = '⚙️ ';
+    // Create a node label with the step name
+    return `["${prefix}${displayName}"]`;
+};
+// Pure function to get node style
+const getNodeStyle = (step) => {
+    // Apply style class based on step type
+    if ((0, guards_1.isApiStep)(step))
+        return ':::apiStyle';
+    if ((0, guards_1.isEventStep)(step))
+        return ':::eventStyle';
+    if ((0, guards_1.isCronStep)(step))
+        return ':::cronStyle';
+    if ((0, guards_1.isNoopStep)(step))
+        return ':::noopStyle';
+    return '';
+};
+// Pure function to generate connections
+const generateConnections = (emits, sourceStep, steps, sourceId, baseDir) => {
+    const connections = [];
+    if (!emits || !Array.isArray(emits) || emits.length === 0) {
+        return '';
+    }
+    // Helper function to check if a step subscribes to a topic
+    const stepSubscribesToTopic = (step, topic) => {
+        // Event steps use regular subscribes
+        if ((0, guards_1.isEventStep)(step) &&
+            step.config.subscribes &&
+            Array.isArray(step.config.subscribes) &&
+            step.config.subscribes.includes(topic)) {
+            return true;
+        }
+        // Noop and API steps use virtualSubscribes
+        if (((0, guards_1.isNoopStep)(step) || (0, guards_1.isApiStep)(step)) &&
+            step.config.virtualSubscribes &&
+            Array.isArray(step.config.virtualSubscribes) &&
+            step.config.virtualSubscribes.includes(topic)) {
+            return true;
+        }
+        return false;
+    };
+    emits.forEach((emit) => {
+        const topic = typeof emit === 'string' ? emit : emit.topic;
+        const label = typeof emit === 'string' ? topic : emit.label || topic;
+        steps.forEach((targetStep) => {
+            if (stepSubscribesToTopic(targetStep, topic)) {
+                const targetId = getNodeId(targetStep, baseDir);
+                connections.push(`    ${sourceId} -->|${label}| ${targetId}`);
+            }
+        });
+    });
+    return connections.join('\n');
+};
+// Pure function to generate flow diagram
+const generateFlowDiagram = (flowName, steps, baseDir) => {
+    // Start mermaid flowchart with top-down direction
+    let diagram = `flowchart TD\n`;
+    // Add class definitions for styling with explicit text color
+    const classDefinitions = [
+        `    classDef apiStyle fill:#f96,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef eventStyle fill:#69f,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef cronStyle fill:#9c6,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef noopStyle fill:#3f3a50,stroke:#333,stroke-width:2px,color:#fff`,
+    ];
+    diagram += classDefinitions.join('\n') + '\n';
+    // Check if we have any steps
+    if (!steps || steps.length === 0) {
+        return diagram + '    empty[No steps in this flow]';
+    }
+    // Create node definitions with proper format
+    steps.forEach((step) => {
+        const nodeId = getNodeId(step, baseDir);
+        const nodeLabel = getNodeLabel(step);
+        const nodeStyle = getNodeStyle(step);
+        diagram += `    ${nodeId}${nodeLabel}${nodeStyle}\n`;
+    });
+    // Create connections between nodes
+    let connectionsStr = '';
+    steps.forEach((sourceStep) => {
+        const sourceId = getNodeId(sourceStep, baseDir);
+        // Helper function to process emissions if they exist
+        function processEmissions(emissionsArray, stepSource, stepsCollection, sourceIdentifier) {
+            if (emissionsArray && Array.isArray(emissionsArray)) {
+                return generateConnections(emissionsArray, stepSource, stepsCollection, sourceIdentifier, baseDir);
+            }
+            return '';
+        }
+        // Semantic variables to clarify which step types support which emission types
+        const supportsEmits = (0, guards_1.isApiStep)(sourceStep) || (0, guards_1.isEventStep)(sourceStep) || (0, guards_1.isCronStep)(sourceStep);
+        const supportsVirtualEmits = supportsEmits || (0, guards_1.isNoopStep)(sourceStep);
+        // Process regular emissions if supported
+        if (supportsEmits) {
+            const emitConnections = processEmissions(sourceStep.config.emits, sourceStep, steps, sourceId);
+            if (emitConnections) {
+                connectionsStr += emitConnections + '\n';
+            }
+        }
+        // Process virtual emissions if supported
+        if (supportsVirtualEmits) {
+            const virtualEmitConnections = processEmissions(sourceStep.config.virtualEmits, sourceStep, steps, sourceId);
+            if (virtualEmitConnections) {
+                connectionsStr += virtualEmitConnections + '\n';
+            }
+        }
+    });
+    // Add connections to the diagram
+    diagram += connectionsStr;
+    return diagram;
+};
+// Function to save a diagram to a file
+const saveDiagram = (diagramsDir, flowName, diagram) => {
+    const filePath = path_1.default.join(diagramsDir, `${flowName}.mmd`);
+    fs_1.default.writeFileSync(filePath, diagram);
+};
+// Function to remove a diagram file
+const removeDiagram = (diagramsDir, flowName) => {
+    const filePath = path_1.default.join(diagramsDir, `${flowName}.mmd`);
+    if (fs_1.default.existsSync(filePath)) {
+        fs_1.default.unlinkSync(filePath);
+    }
+};
+// Function to generate and save a diagram
+const generateAndSaveDiagram = (diagramsDir, flowName, flow, baseDir) => {
+    const diagram = generateFlowDiagram(flowName, flow.steps, baseDir);
+    saveDiagram(diagramsDir, flowName, diagram);
+};
+// Main exported function that creates the mermaid generator
+const createMermaidGenerator = (baseDir) => {
+    const diagramsDir = path_1.default.join(baseDir, '.mermaid');
+    ensureDiagramsDirectory(diagramsDir);
+    // Event handlers
+    const handleFlowCreated = (flowName, flow) => {
+        generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+    };
+    const handleFlowUpdated = (flowName, flow) => {
+        generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+    };
+    const handleFlowRemoved = (flowName) => {
+        removeDiagram(diagramsDir, flowName);
+    };
+    // Initialize function to hook into LockedData events
+    const initialize = (lockedData) => {
+        // Hook into flow events
+        lockedData.on('flow-created', (flowName) => {
+            handleFlowCreated(flowName, lockedData.flows[flowName]);
+        });
+        lockedData.on('flow-updated', (flowName) => {
+            handleFlowUpdated(flowName, lockedData.flows[flowName]);
+        });
+        lockedData.on('flow-removed', (flowName) => {
+            handleFlowRemoved(flowName);
+        });
+        // Generate diagrams for all existing flows
+        if (lockedData.flows && typeof lockedData.flows === 'object') {
+            Object.entries(lockedData.flows).forEach(([flowName, flow]) => {
+                generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+            });
+        }
+    };
+    // Return the public API
+    return {
+        initialize,
+    };
+};
+exports.createMermaidGenerator = createMermaidGenerator;

package/dist/src/node/middleware-compose.d.ts

@@ -0,0 +1 @@
+export declare const composeMiddleware: (...middlewares: any[]) => (req: any, ctx: any, handler: () => Promise<any>) => Promise<any>;

package/dist/src/node/middleware-compose.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeMiddleware = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const composeMiddleware = (...middlewares) => {
+    return async (req, ctx, handler) => {
+        const composedHandler = middlewares.reduceRight((nextHandler, middleware) => () => middleware(req, ctx, nextHandler), handler);
+        return composedHandler();
+    };
+};
+exports.composeMiddleware = composeMiddleware;
+/* eslint-enable @typescript-eslint/no-explicit-any */

package/dist/src/node/node-runner.js

@@ -7,6 +7,7 @@ const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
 const rpc_state_manager_1 = require("./rpc-state-manager");
 const rpc_1 = require("./rpc");
+const middleware_compose_1 = require("./middleware-compose");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('dotenv').config();
 // Add ts-node registration before dynamic imports
@@ -38,8 +39,12 @@ async function runTypescriptModule(filePath, event) {
         const emit = async (data) => sender.send('emit', data);
         const context = { traceId, flows, logger, state, emit };
         sender.init();
-        // Call the function with provided arguments
-        const result = contextInFirstArg ? await module.handler(context) : await module.handler(event.data, context);
+        const middlewares = Array.isArray(module.config.middleware) ? module.config.middleware : [];
+        const composedMiddleware = (0, middleware_compose_1.composeMiddleware)(...middlewares);
+        const handlerFn = () => {
+            return contextInFirstArg ? module.handler(context) : module.handler(event.data, context);
+        };
+        const result = await composedMiddleware(event.data, context, handlerFn);
         await sender.send('result', result);
         await sender.close();
         process.exit(0);

package/dist/src/python/logger.py

@@ -1,6 +1,6 @@
 import time
 from typing import Any, Dict, Optional
-from rpc import RpcSender
+from rpc import RpcSender, serialize_for_json
 
 class Logger:
     def __init__(self, trace_id: str, flows: list[str], rpc: RpcSender):
@@ -18,7 +18,7 @@ class Logger:
         }
 
         if args:
-            # Convert SimpleNamespace to dict if needed
+            # Use our serializer to ensure args are JSON-serializable
             if hasattr(args, '__dict__'):
                 args = vars(args)
             elif not isinstance(args, dict):

package/dist/src/python/python-runner.py

@@ -5,9 +5,10 @@ import os
 import asyncio
 import traceback
 from logger import Logger
-from rpc import RpcSender
+from rpc import RpcSender, serialize_for_json
 from rpc_state_manager import RpcStateManager
-from typing import Any
+from typing import Any, Optional
+import functools
 
 def parse_args(arg: str) -> Any:
     from types import SimpleNamespace
@@ -19,16 +20,43 @@ def parse_args(arg: str) -> Any:
         return arg
 
 class Context:
-    def __init__(self, args: Any, rpc: RpcSender):
+    def __init__(self, args: Any, rpc: RpcSender, is_api_handler: bool = False):
         self.trace_id = args.traceId
         self.traceId = args.traceId
         self.flows = args.flows
         self.rpc = rpc
         self.state = RpcStateManager(rpc)
         self.logger = Logger(self.trace_id, self.flows, rpc)
+        self._loop = asyncio.get_event_loop()
+        self.is_api_handler = is_api_handler
+        self._pending_tasks = []
 
     async def emit(self, event: Any):
-        return await self.rpc.send('emit', event)
+        if self.is_api_handler:
+            self.rpc.send_no_wait('emit', event)
+            return None
+        else:
+            return await self.rpc.send('emit', event)
+        
+    # Add wrapper to handle non-awaited emit coroutine
+    def __getattribute__(self, name):
+        attr = super().__getattribute__(name)
+        if name == 'emit' and asyncio.iscoroutinefunction(attr):
+            @functools.wraps(attr)
+            def wrapper(*args, **kwargs):
+                coro = attr(*args, **kwargs)
+                # Check if this is being awaited
+                frame = sys._getframe(1)
+                if frame.f_code.co_name != '__await__':
+                    task = asyncio.create_task(coro)
+                    def handle_exception(t):
+                        if t.done() and not t.cancelled() and t.exception():
+                            print(f"Unhandled exception in background task: {t.exception()}", file=sys.stderr)
+                    task.add_done_callback(handle_exception)
+                    return task
+                return coro
+            return wrapper
+        return attr
 
 async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
     try:
@@ -62,14 +90,40 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
 
         context = Context(args, rpc)
 
+        # Check if this is an API handler
+        is_api_handler = False
+        if hasattr(module, 'config'):
+            if isinstance(module.config, dict) and module.config.get('type') == 'api':
+                is_api_handler = True
+            elif hasattr(module.config, 'type') and module.config.type == 'api':
+                is_api_handler = True
+
+        # Create context with is_api_handler flag
+        context = Context(args, rpc, is_api_handler)
+
         if contextInFirstArg:
             result = await module.handler(context)
         else:
+            if hasattr(args.data, 'body'):
+                args.data.body = serialize_for_json(args.data.body)
             result = await module.handler(args.data, context)
 
+        # For API handlers, we want to return immediately without waiting for background tasks
+        # This prevents the API from getting stuck
+        if not is_api_handler:
+            pending = asyncio.all_tasks() - {asyncio.current_task()}
+            if pending:
+                await asyncio.gather(*pending)
+
         if result:
             await rpc.send('result', result)
 
+        # For non-API handlers, ensure all pending tasks are completed before closing
+        if not is_api_handler:
+            pending = asyncio.all_tasks() - {asyncio.current_task()}
+            if pending:
+                await asyncio.gather(*pending)
+
         rpc.close()
         rpc.send_no_wait('close', None)
         
@@ -89,4 +143,4 @@ if __name__ == "__main__":
     rpc = RpcSender()
     loop = asyncio.get_event_loop()
     tasks = asyncio.gather(rpc.init(), run_python_module(file_path, rpc, parse_args(arg)))
-    loop.run_until_complete(tasks)
+    loop.run_until_complete(tasks)

package/dist/src/python/rpc.py

@@ -8,6 +8,20 @@ from typing import Any, Dict, Tuple
 # get the FD from ENV
 NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
 
+def serialize_for_json(obj: Any) -> Any:
+    """Convert Python objects to JSON-serializable types"""
+    if hasattr(obj, '__dict__'):
+        return obj.__dict__
+    elif hasattr(obj, '_asdict'):  # For namedtuples
+        return obj._asdict()
+    elif isinstance(obj, (list, tuple)):
+        return [serialize_for_json(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {k: serialize_for_json(v) for k, v in obj.items()}
+    else:
+        # Try to return the object as is, letting json handle basic types
+        return obj
+
 class RpcSender:
     def __init__(self):
         self.executing = True

package/dist/src/python/rpc_state_manager.py

@@ -1,19 +1,56 @@
 from typing import Any
 import asyncio
 from rpc import RpcSender
+import functools
+import sys
 
 class RpcStateManager:
     def __init__(self, rpc: RpcSender):
         self.rpc = rpc
+        self._loop = asyncio.get_event_loop()
 
     async def get(self, trace_id: str, key: str) -> asyncio.Future[Any]:
-        return await self.rpc.send('state.get', {'traceId': trace_id, 'key': key})
+        result = await self.rpc.send('state.get', {'traceId': trace_id, 'key': key})
+        
+        if result is None:
+            return {'data': None}
+        elif isinstance(result, dict):
+            if 'data' not in result:
+                return {'data': result}
+        
+        return result
 
     async def set(self, trace_id: str, key: str, value: Any) -> asyncio.Future[None]:
-        return await self.rpc.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
+        future = await self.rpc.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
+        return future
 
     async def delete(self, trace_id: str, key: str) -> asyncio.Future[None]:
         return await self.rpc.send('state.delete', {'traceId': trace_id, 'key': key})
 
     async def clear(self, trace_id: str) -> asyncio.Future[None]:
         return await self.rpc.send('state.clear', {'traceId': trace_id})
+
+    # Add wrappers to handle non-awaited coroutines
+    def __getattribute__(self, name):
+        attr = super().__getattribute__(name)
+        if name in ('get', 'set', 'delete', 'clear') and asyncio.iscoroutinefunction(attr):
+            @functools.wraps(attr)
+            def wrapper(*args, **kwargs):
+                coro = attr(*args, **kwargs)
+                # Check if this is being awaited
+                frame = sys._getframe(1)
+                if frame.f_code.co_name != '__await__':
+                    # Not being awaited, schedule in background
+                    # But we need to make sure this task completes before the handler returns
+                    # So we'll return the task for the caller to await if needed
+                    task = asyncio.create_task(coro)
+                    # Add error handling for the background task
+                    def handle_exception(t):
+                        if t.done() and not t.cancelled() and t.exception():
+                            print(f"Unhandled exception in background task: {t.exception()}", file=sys.stderr)
+                    task.add_done_callback(handle_exception)
+                    return task
+                # Being awaited, return coroutine as normal
+                return coro
+            return wrapper
+        return attr

package/dist/src/ruby/rpc_state_manager.rb

@@ -3,6 +3,22 @@ class RpcStateManager
     @sender = sender
   end
 
+  # Support hash-like access with [:method_name] syntax
+  def [](method_name)
+    case method_name.to_sym
+    when :get
+      ->(trace_id, key) { get(trace_id, key) }
+    when :set
+      ->(trace_id, key, value) { set(trace_id, key, value) }
+    when :delete
+      ->(trace_id, key) { delete(trace_id, key) }
+    when :clear
+      ->(trace_id) { clear(trace_id) }
+    else
+      raise NoMethodError, "undefined method `#{method_name}' for #{self.class}"
+    end
+  end
+
   def get(trace_id, key)
     # Return promise to match Python/Node behavior
     @sender.send('state.get', { traceId: trace_id, key: key })
@@ -22,4 +38,4 @@ class RpcStateManager
     # Return promise to match Python/Node behavior
     @sender.send('state.clear', { traceId: trace_id })
   end
-end
+end

package/dist/src/ruby/ruby-runner.rb

@@ -20,7 +20,7 @@ class Context
 
   def emit(event)
     # Add type field if not present to match Node.js/Python behavior
-    event = { type: event[:type] || event['type'], data: event[:data] || event['data'] } unless event.is_a?(String)
+    event = { topic: event[:topic] || event['topic'], data: event[:data] || event['data'] } unless event.is_a?(String)
     promise = @rpc.send('emit', event)
     promise  # Return promise to maintain async pattern
   end

package/dist/src/server.js

@@ -8,7 +8,9 @@ const cron_handler_1 = require("./cron-handler");
 const body_parser_1 = __importDefault(require("body-parser"));
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
+const multer_1 = __importDefault(require("multer"));
 const socket_io_1 = require("socket.io");
+const cors_1 = __importDefault(require("cors"));
 const flows_endpoint_1 = require("./flows-endpoint");
 const guards_1 = require("./guards");
 const logger_1 = require("./logger");
@@ -23,6 +25,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
     const server = http_1.default.createServer(app);
     const io = new socket_io_1.Server(server);
     const loggerFactory = new LoggerFactory_1.LoggerFactory(config.isVerbose, io);
+    const upload = (0, multer_1.default)();
     const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
     const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, loggerFactory);
     const asyncHandler = (step) => {
@@ -36,6 +39,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 headers: req.headers,
                 pathParams: req.params,
                 queryParams: req.query,
+                files: req.files,
             };
             try {
                 const data = request;
@@ -75,10 +79,10 @@ const createServer = async (lockedData, eventManager, state, config) => {
         const handler = asyncHandler(step);
         const methods = {
             GET: () => router.get(path, handler),
-            POST: () => router.post(path, handler),
-            PUT: () => router.put(path, handler),
+            POST: () => router.post(path, upload.any(), handler),
+            PUT: () => router.put(path, upload.any(), handler),
             DELETE: () => router.delete(path, handler),
-            PATCH: () => router.patch(path, handler),
+            PATCH: () => router.patch(path, upload.any(), handler),
             OPTIONS: () => router.options(path, handler),
             HEAD: () => router.head(path, handler),
         };
@@ -102,6 +106,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
         router.stack = filteredStack;
     };
     allSteps.filter(guards_1.isApiStep).forEach(addRoute);
+    app.use((0, cors_1.default)());
     app.use(router);
     (0, flows_endpoint_1.flowsEndpoint)(lockedData, app);
     (0, flows_config_endpoint_1.flowsConfigEndpoint)(app, process.cwd());

package/dist/src/step-validator.js

@@ -63,8 +63,9 @@ const eventSchema = zod_1.z
     subscribes: zod_1.z.array(zod_1.z.string()),
     emits: emits,
     virtualEmits: emits.optional(),
-    input: zod_1.z.union([jsonSchema, zod_1.z.null()]).optional(),
+    input: zod_1.z.union([jsonSchema, zod_1.z.object({}), zod_1.z.null()]).optional(),
     flows: zod_1.z.array(zod_1.z.string()).optional(),
+    includeFiles: zod_1.z.array(zod_1.z.string()).optional(),
 })
     .strict();
 const apiSchema = zod_1.z
@@ -78,7 +79,9 @@ const apiSchema = zod_1.z
     virtualEmits: emits.optional(),
     virtualSubscribes: zod_1.z.array(zod_1.z.string()).optional(),
     flows: zod_1.z.array(zod_1.z.string()).optional(),
-    bodySchema: zod_1.z.union([jsonSchema, zod_1.z.null()]).optional(),
+    bodySchema: zod_1.z.union([jsonSchema, zod_1.z.object({}), zod_1.z.null()]).optional(),
+    includeFiles: zod_1.z.array(zod_1.z.string()).optional(),
+    middleware: zod_1.z.array(zod_1.z.any()).optional(),
 })
     .strict();
 const cronSchema = zod_1.z
@@ -90,6 +93,7 @@ const cronSchema = zod_1.z
     virtualEmits: emits.optional(),
     emits: emits,
     flows: zod_1.z.array(zod_1.z.string()).optional(),
+    includeFiles: zod_1.z.array(zod_1.z.string()).optional(),
 })
     .strict();
 const validateStep = (step) => {
@@ -118,7 +122,7 @@ const validateStep = (step) => {
         if (error instanceof zod_1.z.ZodError) {
             return {
                 success: false,
-                error: 'Invalid step configuration',
+                error: error.errors.map((err) => err.message).join(', '),
                 errors: error.errors.map((err) => ({ path: err.path.join('.'), message: err.message })),
             };
         }

package/dist/src/types.d.ts

@@ -32,6 +32,11 @@ export type EventConfig<TInput extends ZodObject<any> = any> = {
     virtualEmits?: Emit[];
     input: TInput;
     flows?: string[];
+    /**
+     * Files to include in the step bundle.
+     * Needs to be relative to the step file.
+     */
+    includeFiles?: string[];
 };
 export type NoopConfig = {
     type: 'noop';
@@ -42,6 +47,7 @@ export type NoopConfig = {
     flows?: string[];
 };
 export type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type ApiMiddleware = (req: ApiRequest, ctx: FlowContext, next: () => Promise<ApiResponse>) => Promise<ApiResponse>;
 export type ApiRouteConfig = {
     type: 'api';
     name: string;
@@ -52,13 +58,22 @@ export type ApiRouteConfig = {
     virtualEmits?: Emit[];
     virtualSubscribes?: string[];
     flows?: string[];
+    middleware?: ApiMiddleware[];
     bodySchema?: ZodObject<any>;
+    /**
+     * Files to include in the step bundle.
+     * Needs to be relative to the step file.
+     */
+    includeFiles?: string[];
 };
 export type ApiRequest = {
     pathParams: Record<string, string>;
     queryParams: Record<string, string | string[]>;
     body: Record<string, any>;
     headers: Record<string, string | string[]>;
+    files?: Express.Multer.File[] | {
+        [fieldname: string]: Express.Multer.File[];
+    };
 };
 export type ApiResponse = {
     status: number;
@@ -74,6 +89,11 @@ export type CronConfig = {
     virtualEmits?: Emit[];
     emits: Emit[];
     flows?: string[];
+    /**
+     * Files to include in the step bundle.
+     * Needs to be relative to the step file.
+     */
+    includeFiles?: string[];
 };
 export type CronHandler = (ctx: FlowContext) => Promise<void>;
 export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : T extends CronConfig ? CronHandler : never;

package/package.json

@@ -2,12 +2,15 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.20",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
+    "multer": "1.4.5-lts.1",
     "node-cron": "^3.0.3",
     "socket.io": "^4.8.1",
     "ts-node": "^10.9.2",
@@ -17,8 +20,10 @@
   },
   "devDependencies": {
     "@types/body-parser": "^1.19.5",
+    "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
+    "@types/multer": "^1.4.12",
     "@types/node-cron": "^3.0.11",
     "@types/supertest": "^6.0.2",
     "jest": "^29.7.0",