@motiadev/core 0.1.0-beta.10 → 0.1.0-beta.12

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/get-step-config.js

@@ -38,7 +38,7 @@ const getStepConfig = (file) => {
         });
         child.on('message', (message) => {
             logger_1.globalLogger.debug('[Config] Read config', { config: message });
-            config = command === 'node' ? eval('(' + message + ')') : message;
+            config = message;
             resolve(config);
             child.kill(); // we can kill the child process since we already received the message
         });

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/get-config.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const serialize_javascript_1 = __importDefault(require("serialize-javascript"));
 // Add ts-node registration before dynamic imports
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
@@ -27,7 +26,7 @@ async function getConfig(filePath) {
         else if (module.config.bodySchema instanceof zod_1.ZodObject) {
             module.config.bodySchema = (0, zod_to_json_schema_1.default)(module.config.bodySchema);
         }
-        process.send?.((0, serialize_javascript_1.default)(module.config));
+        process.send?.(module.config);
         process.exit(0);
     }
     catch (error) {

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/{middleware-composer.js → node/middleware-compose.js}

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (...middlewares) => {
+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/python-runner.py

@@ -8,6 +8,7 @@ from logger import Logger
 from rpc import RpcSender, serialize_for_json
 from rpc_state_manager import RpcStateManager
 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,6 +90,17 @@ 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:
@@ -69,9 +108,22 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
                 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)
         
@@ -91,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_state_manager.py

@@ -10,7 +10,15 @@ class RpcStateManager:
         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]:
         future = await self.rpc.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
@@ -33,9 +41,14 @@ class RpcStateManager:
                 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)
-                    # Optional: Add error handling for the background task
-                    task.add_done_callback(lambda t: t.exception() if t.done() and not t.cancelled() else None)
+                    # 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

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,6 +8,7 @@ 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 flows_endpoint_1 = require("./flows-endpoint");
 const guards_1 = require("./guards");
@@ -17,13 +18,13 @@ const call_step_file_1 = require("./call-step-file");
 const LoggerFactory_1 = require("./LoggerFactory");
 const generate_trace_id_1 = require("./generate-trace-id");
 const flows_config_endpoint_1 = require("./flows-config-endpoint");
-const middleware_composer_1 = __importDefault(require("./middleware-composer"));
 const createServer = async (lockedData, eventManager, state, config) => {
     const printer = lockedData.printer;
     const app = (0, express_1.default)();
     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) => {
@@ -37,46 +38,24 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 headers: req.headers,
                 pathParams: req.params,
                 queryParams: req.query,
-            };
-            const ctx = {
-                emit: async (event) => {
-                    await eventManager.emit({
-                        topic: event.topic,
-                        data: event.data,
-                        traceId,
-                        logger,
-                    });
-                },
-                traceId,
-                state,
-                logger,
-            };
-            const finalHandler = async () => {
-                try {
-                    const result = await (0, call_step_file_1.callStepFile)({
-                        contextInFirstArg: false,
-                        data: request,
-                        step,
-                        printer,
-                        logger,
-                        eventManager,
-                        state,
-                        traceId,
-                    });
-                    if (!result) {
-                        return { status: 500, body: { error: 'Internal server error' } };
-                    }
-                    return result;
-                }
-                catch (error) {
-                    logger.error('[API] Internal server error', { error });
-                    console.log(error);
-                    return { status: 500, body: { error: 'Internal server error' } };
-                }
+                files: req.files,
             };
             try {
-                const middleware = step.config.middleware || [];
-                const result = await (0, middleware_composer_1.default)(...middleware)(request, ctx, finalHandler);
+                const data = request;
+                const result = await (0, call_step_file_1.callStepFile)({
+                    contextInFirstArg: false,
+                    data,
+                    step,
+                    printer,
+                    logger,
+                    eventManager,
+                    state,
+                    traceId,
+                });
+                if (!result) {
+                    res.status(500).json({ error: 'Internal server error' });
+                    return;
+                }
                 if (result.headers) {
                     Object.entries(result.headers).forEach(([key, value]) => res.setHeader(key, value));
                 }
@@ -84,7 +63,8 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 res.json(result.body);
             }
             catch (error) {
-                logger.error('[API] Error in middleware chain', { error });
+                logger.error('[API] Internal server error', { error });
+                console.log(error);
                 res.status(500).json({ error: 'Internal server error' });
             }
         };
@@ -95,15 +75,15 @@ const createServer = async (lockedData, eventManager, state, config) => {
     const addRoute = (step) => {
         const { method, path } = step.config;
         logger_1.globalLogger.debug('[API] Registering route', step.config);
-        const expressHandler = asyncHandler(step);
+        const handler = asyncHandler(step);
         const methods = {
-            GET: () => router.get(path, expressHandler),
-            POST: () => router.post(path, expressHandler),
-            PUT: () => router.put(path, expressHandler),
-            DELETE: () => router.delete(path, expressHandler),
-            PATCH: () => router.patch(path, expressHandler),
-            OPTIONS: () => router.options(path, expressHandler),
-            HEAD: () => router.head(path, expressHandler),
+            GET: () => router.get(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, upload.any(), handler),
+            OPTIONS: () => router.options(path, handler),
+            HEAD: () => router.head(path, handler),
         };
         const methodHandler = methods[method];
         if (!methodHandler) {

package/dist/src/types.d.ts

@@ -71,6 +71,9 @@ export type ApiRequest = {
     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;

package/package.json

@@ -2,14 +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.10",
+  "version": "0.1.0-beta.12",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
+    "dotenv": "^16.4.7",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
+    "multer": "1.4.5-lts.1",
     "node-cron": "^3.0.3",
-    "serialize-javascript": "^6.0.2",
     "socket.io": "^4.8.1",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
@@ -20,8 +21,8 @@
     "@types/body-parser": "^1.19.5",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
+    "@types/multer": "^1.4.12",
     "@types/node-cron": "^3.0.11",
-    "@types/serialize-javascript": "^5.0.4",
     "@types/supertest": "^6.0.2",
     "jest": "^29.7.0",
     "supertest": "^7.0.0",

package/dist/src/middleware-composer.d.ts

@@ -1,3 +0,0 @@
-import { ApiMiddleware, ApiRequest, ApiResponse, FlowContext } from './types';
-declare const _default: (...middlewares: ApiMiddleware[]) => (req: ApiRequest, ctx: FlowContext, handler: () => Promise<ApiResponse>) => Promise<ApiResponse>;
-export default _default;