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

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/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 = message;
+            config = command === 'node' ? eval('(' + message + ')') : message;
             resolve(config);
             child.kill(); // we can kill the child process since we already received the message
         });

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

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

package/dist/src/middleware-composer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (...middlewares) => {
+    return async (req, ctx, handler) => {
+        const composedHandler = middlewares.reduceRight((nextHandler, middleware) => () => middleware(req, ctx, nextHandler), handler);
+        return composedHandler();
+    };
+};

package/dist/src/node/get-config.js

@@ -6,6 +6,7 @@ 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({
@@ -26,7 +27,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?.(module.config);
+        process.send?.((0, serialize_javascript_1.default)(module.config));
         process.exit(0);
     }
     catch (error) {

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,9 @@ 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
 
 def parse_args(arg: str) -> Any:
     from types import SimpleNamespace
@@ -65,6 +65,8 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
         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)
 
         if result:

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,43 @@
 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})
 
     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
+                    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)
+                    return task
+                # Being awaited, return coroutine as normal
+                return coro
+            return wrapper
+        return attr

package/dist/src/server.js

@@ -17,6 +17,7 @@ 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)();
@@ -37,22 +38,45 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 pathParams: req.params,
                 queryParams: req.query,
             };
-            try {
-                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;
+            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' } };
                 }
+            };
+            try {
+                const middleware = step.config.middleware || [];
+                const result = await (0, middleware_composer_1.default)(...middleware)(request, ctx, finalHandler);
                 if (result.headers) {
                     Object.entries(result.headers).forEach(([key, value]) => res.setHeader(key, value));
                 }
@@ -60,8 +84,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 res.json(result.body);
             }
             catch (error) {
-                logger.error('[API] Internal server error', { error });
-                console.log(error);
+                logger.error('[API] Error in middleware chain', { error });
                 res.status(500).json({ error: 'Internal server error' });
             }
         };
@@ -72,15 +95,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 handler = asyncHandler(step);
+        const expressHandler = asyncHandler(step);
         const methods = {
-            GET: () => router.get(path, handler),
-            POST: () => router.post(path, handler),
-            PUT: () => router.put(path, handler),
-            DELETE: () => router.delete(path, handler),
-            PATCH: () => router.patch(path, handler),
-            OPTIONS: () => router.options(path, handler),
-            HEAD: () => router.head(path, handler),
+            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),
         };
         const methodHandler = methods[method];
         if (!methodHandler) {

package/dist/src/step-validator.js

@@ -65,6 +65,7 @@ const eventSchema = zod_1.z
     virtualEmits: emits.optional(),
     input: zod_1.z.union([jsonSchema, 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
@@ -79,6 +80,8 @@ const apiSchema = zod_1.z
     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(),
+    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) => {

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,7 +58,13 @@ 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>;
@@ -74,6 +86,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,13 +2,14 @@
   "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",
+  "version": "0.1.0-beta.10",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
     "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,6 +21,7 @@
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
     "@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",