@motiadev/core 0.0.21 → 0.0.23

package/dist/src/call-step-file.d.ts

@@ -1,3 +1,15 @@
-import { LockedData } from './locked-data';
-import { Event, EventConfig, EventManager, InternalStateManager, Step } from './types';
-export declare const callStepFile: <TData>(step: Step<EventConfig>, lockedData: LockedData, event: Event<TData>, eventManager: EventManager, state: InternalStateManager) => Promise<void>;
+import { EventManager, InternalStateManager, Step } from './types';
+import { BaseLogger } from './logger';
+import { Printer } from './printer';
+type CallStepFileOptions = {
+    step: Step;
+    logger: BaseLogger;
+    eventManager: EventManager;
+    state: InternalStateManager;
+    traceId: string;
+    printer: Printer;
+    data?: any;
+    contextInFirstArg: boolean;
+};
+export declare const callStepFile: <TData>(options: CallStepFileOptions) => Promise<TData | undefined>;
+export {};

package/dist/src/call-step-file.js

@@ -8,67 +8,72 @@ const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
-const nodeRunner = path_1.default.join(__dirname, 'node', 'node-runner.js');
-const pythonRunner = path_1.default.join(__dirname, 'python', 'python-runner.py');
-const rubyRunner = path_1.default.join(__dirname, 'ruby', 'ruby_runner.rb');
 const getLanguageBasedRunner = (stepFilePath = '') => {
     const isPython = stepFilePath.endsWith('.py');
     const isRuby = stepFilePath.endsWith('.rb');
     const isNode = stepFilePath.endsWith('.js') || stepFilePath.endsWith('.ts');
     if (isPython) {
-        return { runner: pythonRunner, command: 'python' };
+        const pythonRunner = path_1.default.join(__dirname, 'python', 'python-runner.py');
+        return { runner: pythonRunner, command: 'python', args: [] };
     }
     else if (isRuby) {
-        return { runner: rubyRunner, command: 'ruby' };
+        const rubyRunner = path_1.default.join(__dirname, 'ruby', 'ruby-runner.rb');
+        return { runner: rubyRunner, command: 'ruby', args: [] };
     }
     else if (isNode) {
-        return { runner: nodeRunner, command: 'node' };
+        if (process.env._MOTIA_TEST_MODE === 'true') {
+            const nodeRunner = path_1.default.join(__dirname, 'node', 'node-runner.ts');
+            return { runner: nodeRunner, command: 'node', args: ['-r', 'ts-node/register'] };
+        }
+        const nodeRunner = path_1.default.join(__dirname, 'node', 'node-runner.js');
+        return { runner: nodeRunner, command: 'node', args: [] };
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const callStepFile = (step, lockedData, event, eventManager, state) => {
+const callStepFile = (options) => {
+    const { step, printer, eventManager, state, traceId, data, contextInFirstArg } = options;
+    const logger = options.logger.child({ step: step.config.name });
+    const flows = step.config.flows;
     return new Promise((resolve, reject) => {
-        const jsonData = JSON.stringify({ ...event });
-        const { runner, command } = getLanguageBasedRunner(step.filePath);
-        const child = (0, child_process_1.spawn)(command, [runner, step.filePath, jsonData], {
+        const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg });
+        const { runner, command, args } = getLanguageBasedRunner(step.filePath);
+        let result;
+        const child = (0, child_process_1.spawn)(command, [...args, runner, step.filePath, jsonData], {
             stdio: [undefined, undefined, undefined, 'ipc'],
         });
         const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
         rpcProcessor.handler('close', async () => child.kill());
-        rpcProcessor.handler('log', async (input) => event.logger.log(input));
+        rpcProcessor.handler('log', async (input) => logger.log(input));
         rpcProcessor.handler('state.get', (input) => state.get(input.traceId, input.key));
         rpcProcessor.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
         rpcProcessor.handler('state.delete', (input) => state.delete(input.traceId, input.key));
         rpcProcessor.handler('state.clear', (input) => state.clear(input.traceId));
+        rpcProcessor.handler('result', async (input) => {
+            result = input;
+        });
         rpcProcessor.handler('emit', async (input) => {
             if (!(0, utils_1.isAllowedToEmit)(step, input.type)) {
-                lockedData.printer.printInvalidEmit(step, input.type);
-                return;
+                return printer.printInvalidEmit(step, input.type);
             }
-            return eventManager.emit({
-                ...input,
-                traceId: event.traceId,
-                flows: event.flows,
-                logger: event.logger,
-            }, step.filePath);
+            return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
         });
         rpcProcessor.init();
         child.stdout?.on('data', (data) => {
             try {
                 const message = JSON.parse(data.toString());
-                event.logger.log(message);
+                logger.log(message);
             }
             catch {
-                event.logger.info(Buffer.from(data).toString(), { step });
+                logger.info(Buffer.from(data).toString());
             }
         });
-        child.stderr?.on('data', (data) => event.logger.error(Buffer.from(data).toString(), { step }));
+        child.stderr?.on('data', (data) => logger.error(Buffer.from(data).toString()));
         child.on('close', (code) => {
             if (code !== 0 && code !== null) {
                 reject(new Error(`Process exited with code ${code}`));
             }
             else {
-                resolve();
+                resolve(result);
             }
         });
     });

package/dist/src/cron-handler.d.ts

@@ -1,12 +1,13 @@
 import { Server } from 'socket.io';
 import { LockedData } from './locked-data';
-import { EventManager, Step, CronConfig } from './types';
+import { StateAdapter } from './state/state-adapter';
+import { CronConfig, EventManager, Step } from './types';
 export type CronManager = {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;
 };
-export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, socketServer: Server) => {
+export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, socketServer: Server) => {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;

package/dist/src/cron-handler.js

@@ -34,45 +34,41 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCronHandlers = void 0;
+const crypto_1 = require("crypto");
 const cron = __importStar(require("node-cron"));
+const call_step_file_1 = require("./call-step-file");
 const logger_1 = require("./logger");
-const get_module_export_1 = require("./node/get-module-export");
-const setupCronHandlers = (lockedData, eventManager, socketServer) => {
+const setupCronHandlers = (lockedData, eventManager, state, socketServer) => {
     const cronJobs = new Map();
+    const printer = lockedData.printer;
     const createCronJob = (step) => {
         const { config, filePath } = step;
-        const { cron: cronExpression } = config;
+        const { cron: cronExpression, name: stepName } = config;
         if (!cron.validate(cronExpression)) {
             logger_1.globalLogger.error('[cron handler] invalid cron expression', {
                 expression: cronExpression,
-                step: step.config.name,
+                step: stepName,
             });
             return;
         }
         logger_1.globalLogger.debug('[cron handler] setting up cron job', {
             filePath,
-            step: step.config.name,
+            step: stepName,
             cron: cronExpression,
         });
         const task = cron.schedule(cronExpression, async () => {
-            const traceId = Math.random().toString(36).substring(7);
-            const logger = new logger_1.Logger(traceId, config.flows, step.config.name, socketServer);
-            const flows = config.flows;
+            const traceId = (0, crypto_1.randomUUID)();
+            const logger = new logger_1.Logger(traceId, config.flows, stepName, socketServer);
             try {
-                const handler = await (0, get_module_export_1.getModuleExport)(filePath, 'handler');
-                const emit = async (event) => {
-                    await eventManager.emit({ ...event, traceId, flows, logger }, filePath);
-                };
-                if (handler) {
-                    await handler({ emit, logger, traceId });
-                }
-                else {
-                    const data = { timestamp: Date.now() };
-                    await Promise.all(config.emits.map((item) => {
-                        const type = typeof item === 'string' ? item : item.type;
-                        emit({ type, data });
-                    }));
-                }
+                await (0, call_step_file_1.callStepFile)({
+                    contextInFirstArg: true,
+                    step,
+                    eventManager,
+                    printer,
+                    state,
+                    traceId,
+                    logger,
+                });
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
             catch (error) {

package/dist/src/flows-endpoint.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFlowsList = exports.flowsEndpoint = void 0;
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const guards_1 = require("./guards");
 const get_step_language_1 = require("./get-step-language");
 const flowsEndpoint = (lockedData, app) => {
@@ -81,7 +80,7 @@ const createApiStepResponse = (step, id) => {
         subscribes: step.config.virtualSubscribes ?? undefined,
         action: 'webhook',
         webhookUrl: `${step.config.method} ${step.config.path}`,
-        bodySchema: step.config.bodySchema ? (0, zod_to_json_schema_1.default)(step.config.bodySchema) : undefined,
+        bodySchema: step.config.bodySchema ?? undefined,
     };
 };
 const createEventStepResponse = (step, id) => {

package/dist/src/get-step-config.d.ts

@@ -1,2 +1,2 @@
 import { StepConfig } from './types';
-export declare const getStepConfig: (filePath: string) => Promise<StepConfig | null>;
+export declare const getStepConfig: (file: string) => Promise<StepConfig | null>;

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

@@ -1,22 +1,58 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStepConfig = void 0;
-const get_config_1 = require("./node/get-config");
-const get_python_config_1 = require("./python/get-python-config");
-const get_ruby_config_1 = require("./ruby/get-ruby-config");
-const getStepConfig = async (filePath) => {
-    const isRb = filePath.endsWith('.rb');
-    const isPython = filePath.endsWith('.py');
-    const isNode = filePath.endsWith('.js') || filePath.endsWith('.ts');
-    if (isRb) {
-        return (0, get_ruby_config_1.getRubyConfig)(filePath);
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const getLanguageBasedRunner = (stepFilePath = '') => {
+    const isPython = stepFilePath.endsWith('.py');
+    const isRuby = stepFilePath.endsWith('.rb');
+    const isNode = stepFilePath.endsWith('.js') || stepFilePath.endsWith('.ts');
+    if (isPython) {
+        const pythonRunner = path_1.default.join(__dirname, 'python', 'get-config.py');
+        return { runner: pythonRunner, command: 'python', args: [] };
     }
-    else if (isPython) {
-        return (0, get_python_config_1.getPythonConfig)(filePath);
+    else if (isRuby) {
+        const rubyRunner = path_1.default.join(__dirname, 'ruby', 'get-config.rb');
+        return { runner: rubyRunner, command: 'ruby', args: [] };
     }
     else if (isNode) {
-        return (0, get_config_1.getNodeFileConfig)(filePath);
+        if (process.env._MOTIA_TEST_MODE === 'true') {
+            const nodeRunner = path_1.default.join(__dirname, 'node', 'get-config.ts');
+            return { runner: nodeRunner, command: 'node', args: ['-r', 'ts-node/register'] };
+        }
+        const nodeRunner = path_1.default.join(__dirname, 'node', 'get-config.js');
+        return { runner: nodeRunner, command: 'node', args: [] };
     }
-    return null;
+    throw Error(`Unsupported file extension ${stepFilePath}`);
+};
+const getStepConfig = (file) => {
+    const { runner, command, args } = getLanguageBasedRunner(file);
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const child = (0, child_process_1.spawn)(command, [...args, runner, file], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        });
+        child.on('message', (message) => {
+            logger_1.globalLogger.debug('[Config] Read config', { config: message });
+            config = message;
+            resolve(config);
+            child.kill(); // we can kill the child process since we already received the message
+        });
+        child.on('close', (code) => {
+            if (config) {
+                return; // Config was already resolved
+            }
+            else if (code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+            else if (!config) {
+                reject(new Error(`No config found for file ${file}`));
+            }
+        });
+    });
 };
 exports.getStepConfig = getStepConfig;

package/dist/src/logger.d.ts

@@ -1,18 +1,23 @@
 import { Server } from 'socket.io';
-declare class BaseLogger {
+export declare class BaseLogger {
+    private readonly meta;
     private logger;
     constructor(meta?: Record<string, unknown>);
+    child(meta?: Record<string, unknown>): this;
     info(message: string, args?: unknown): void;
     error(message: string, args?: unknown): void;
     debug(message: string, args?: unknown): void;
     warn(message: string, args?: unknown): void;
+    log(args: unknown): void;
 }
 export declare class Logger extends BaseLogger {
     private readonly traceId;
     private readonly flows;
-    private readonly file;
+    private readonly step;
+    private readonly socketServer?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, file: string, socketServer?: Server);
+    constructor(traceId: string, flows: string[] | undefined, step: string, socketServer?: Server | undefined);
+    child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;
     error: (message: string, args?: unknown) => void;
@@ -20,4 +25,3 @@ export declare class Logger extends BaseLogger {
     warn: (message: string, args?: unknown) => void;
 }
 export declare const globalLogger: BaseLogger;
-export {};

package/dist/src/logger.js

@@ -3,11 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globalLogger = exports.Logger = void 0;
+exports.globalLogger = exports.Logger = exports.BaseLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 const isDebugEnabled = () => process.env.LOG_LEVEL === 'debug';
 class BaseLogger {
     constructor(meta = {}) {
+        this.meta = meta;
         this.logger = (0, pino_1.default)({
             level: process.env.LOG_LEVEL || 'info',
             formatters: { level: (level) => ({ level }) },
@@ -15,6 +16,9 @@ class BaseLogger {
             mixin: () => meta,
         });
     }
+    child(meta = {}) {
+        return new BaseLogger({ ...this.meta, ...meta });
+    }
     info(message, args) {
         this.logger.info(args, message);
     }
@@ -27,13 +31,18 @@ class BaseLogger {
     warn(message, args) {
         this.logger.warn(args, message);
     }
+    log(args) {
+        this.logger.info(args);
+    }
 }
+exports.BaseLogger = BaseLogger;
 class Logger extends BaseLogger {
-    constructor(traceId, flows, file, socketServer) {
-        super({ traceId, flows, file });
+    constructor(traceId, flows, step, socketServer) {
+        super({ traceId, flows, step });
         this.traceId = traceId;
         this.flows = flows;
-        this.file = file;
+        this.step = step;
+        this.socketServer = socketServer;
         this.info = (message, args) => {
             super.info(message, args);
             this.emitLog('info', message, args);
@@ -53,11 +62,8 @@ class Logger extends BaseLogger {
             this.emitLog('warn', message, args);
         };
         this.emitLog = (level, msg, args) => {
-            if (!socketServer) {
-                return;
-            }
-            socketServer.emit('log', {
-                file: this.file,
+            socketServer?.emit('log', {
+                step: this.step,
                 ...(args ?? {}),
                 level,
                 time: Date.now(),
@@ -67,6 +73,9 @@ class Logger extends BaseLogger {
             });
         };
     }
+    child(meta = {}) {
+        return new Logger(this.traceId, this.flows, meta.step, this.socketServer);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(message) {
         console.log(JSON.stringify(message));

package/dist/src/node/get-config.d.ts

@@ -1,2 +1 @@
-import { StepConfig } from '../types';
-export declare const getNodeFileConfig: (filePath: string) => Promise<StepConfig>;
+export {};

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

@@ -1,14 +1,45 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeFileConfig = void 0;
-const get_module_export_1 = require("./get-module-export");
-const getNodeFileConfig = async (filePath) => {
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+// Add ts-node registration before dynamic imports
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+async function getConfig(filePath) {
     try {
-        return await (0, get_module_export_1.getModuleExport)(filePath, 'config');
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const module = require(path_1.default.resolve(filePath));
+        // Check if the specified function exists in the module
+        if (!module.config) {
+            throw new Error(`Config not found in module ${filePath}`);
+        }
+        if (module.config.input instanceof zod_1.ZodObject) {
+            module.config.input = (0, zod_to_json_schema_1.default)(module.config.input);
+        }
+        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.exit(0);
     }
     catch (error) {
-        console.error(`Failed to extract config from ${filePath}:`, error);
-        throw new Error(`No config found in step ${filePath}`);
+        console.error('Error running TypeScript module:', error);
+        process.exit(1);
     }
-};
-exports.getNodeFileConfig = getNodeFileConfig;
+}
+const [, , filePath] = process.argv;
+if (!filePath) {
+    console.error('Usage: node get-config.js <file-path>');
+    process.exit(1);
+}
+getConfig(filePath).catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/dist/src/node/logger.d.ts

@@ -2,9 +2,8 @@ import { RpcSender } from './rpc';
 export declare class Logger {
     private readonly traceId;
     private readonly flows;
-    private readonly fileName;
     private readonly sender;
-    constructor(traceId: string, flows: string[], fileName: string, sender: RpcSender);
+    constructor(traceId: string, flows: string[], sender: RpcSender);
     private _log;
     info(message: string, args?: Record<string, unknown>): void;
     error(message: string, args?: Record<string, unknown>): void;

package/dist/src/node/logger.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 class Logger {
-    constructor(traceId, flows, fileName, sender) {
+    constructor(traceId, flows, sender) {
         this.traceId = traceId;
         this.flows = flows;
-        this.fileName = fileName;
         this.sender = sender;
     }
     _log(level, message, args) {
@@ -15,7 +14,6 @@ class Logger {
             time: Date.now(),
             traceId: this.traceId,
             flows: this.flows,
-            file: this.fileName,
             msg: message,
         };
         this.sender.sendNoWait('log', logEntry);

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

@@ -7,6 +7,8 @@ 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");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+require('dotenv').config();
 // Add ts-node registration before dynamic imports
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('ts-node').register({
@@ -29,15 +31,16 @@ async function runTypescriptModule(filePath, event) {
         if (typeof module.handler !== 'function') {
             throw new Error(`Function handler not found in module ${filePath}`);
         }
-        const { traceId, flows } = event;
+        const { traceId, flows, contextInFirstArg } = event;
         const sender = new rpc_1.RpcSender(process);
-        const logger = new logger_1.Logger(traceId, flows, filePath, sender);
+        const logger = new logger_1.Logger(traceId, flows, sender);
         const state = new rpc_state_manager_1.RpcStateManager(sender);
         const emit = async (data) => sender.send('emit', data);
         const context = { traceId, flows, logger, state, emit };
         sender.init();
         // Call the function with provided arguments
-        await module.handler(event.data, context);
+        const result = contextInFirstArg ? await module.handler(context) : await module.handler(event.data, context);
+        await sender.send('result', result);
         await sender.close();
         process.exit(0);
     }

package/dist/src/python/logger.py

@@ -3,10 +3,9 @@ from typing import Any, Dict, Optional
 from rpc import RpcSender
 
 class Logger:
-    def __init__(self, trace_id: str, flows: list[str], file_path: str, rpc: RpcSender):
+    def __init__(self, trace_id: str, flows: list[str], rpc: RpcSender):
         self.trace_id = trace_id
         self.flows = flows
-        self.file_name = file_path.split('/')[-1]
         self.rpc = rpc
 
     def _log(self, level: str, message: str, args: Optional[Dict[str, Any]] = None) -> None:
@@ -15,7 +14,6 @@ class Logger:
             "time": int(time.time() * 1000),
             "traceId": self.trace_id,
             "flows": self.flows,
-            "file": self.file_name,
             "msg": message
         }
 

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

@@ -20,13 +20,13 @@ def parse_args(arg: str) -> Any:
         return arg
 
 class Context:
-    def __init__(self, args: Any, rpc: RpcSender, file_name: str):
+    def __init__(self, args: Any, rpc: RpcSender):
         self.trace_id = args.traceId
+        self.traceId = args.traceId
         self.flows = args.flows
-        self.file_name = file_name
         self.rpc = rpc
         self.state = RpcStateManager(rpc)
-        self.logger = Logger(self.trace_id, self.flows, self.file_name, rpc)
+        self.logger = Logger(self.trace_id, self.flows, rpc)
 
     async def emit(self, event: Any):
         return await self.rpc.send('emit', event)
@@ -36,6 +36,7 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
         # Construct path relative to steps directory
         flows_dir = os.path.join(os.getcwd(), 'steps')
         module_path = os.path.join(flows_dir, file_path)
+        contextInFirstArg = args.contextInFirstArg
 
         # Load the module dynamically
         spec = importlib.util.spec_from_file_location("dynamic_module", module_path)
@@ -49,9 +50,15 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
         if not hasattr(module, 'handler'):
             raise AttributeError(f"Function 'handler' not found in module {module_path}")
 
-        context = Context(args, rpc, file_path)
+        context = Context(args, rpc)
 
-        await module.handler(args.data, context)
+        if contextInFirstArg:
+            result = await module.handler(context)
+        else:
+            result = await module.handler(args.data, context)
+
+        if (result):
+            await rpc.send('result', result)
 
         rpc.close()
 

package/dist/src/ruby/{get_config.rb → get-config.rb}

@@ -10,8 +10,7 @@ def send_message(message)
     io.write(json_message)
     io.flush
   rescue Errno::EBADF => e
-    warn "Error writing to IPC channel: #{e.message}"
-    exit(1)
+    raise "Error writing to IPC channel: #{e.message}"
   ensure
     io.close if io && !io.closed?
   end
@@ -41,20 +40,17 @@ end
 # Main execution block
 begin
   if ARGV.empty?
-    warn 'Error: No file path provided'
-    exit(1)
+    raise 'Error: No file path provided'
   end
 
   file_path = ARGV[0]
   
   unless File.exist?(file_path)
-    warn "Error: File not found: #{file_path}"
-    exit(1)
+    raise "Error: File not found: #{file_path}"
   end
   
   unless File.readable?(file_path)
-    warn "Error: File is not readable: #{file_path}"
-    exit(1)
+    raise "Error: File is not readable: #{file_path}"
   end
 
   # Extract and send config
@@ -62,7 +58,4 @@ begin
   send_message(config)
   
   exit(0)
-rescue => e
-  warn "Error: #{e.message}"
-  exit(1)
 end

package/dist/src/ruby/logger.rb

@@ -2,10 +2,9 @@ require 'json'
 require 'time'
 
 class CustomLogger
-  def initialize(trace_id, flows, file_path, sender)
+  def initialize(trace_id, flows, sender)
     @trace_id = trace_id
     @flows = flows
-    @file_name = file_path.split('/').last
     @sender = sender
   end
 
@@ -25,7 +24,6 @@ class CustomLogger
       time: (Time.now.to_f * 1000).to_i,  # Milliseconds since epoch to match Node
       traceId: @trace_id,
       flows: @flows,
-      file: @file_name,
       msg: message
     }
 

package/dist/src/ruby/{ruby_runner.rb → ruby-runner.rb}

@@ -16,7 +16,7 @@ def parse_args(arg)
 end
 
 class Context
-  attr_reader :trace_id, :flows, :file_name, :state, :logger
+  attr_reader :trace_id, :traceId, :flows, :file_name, :state, :logger
 
   def emit(event)
     # Add type field if not present to match Node.js/Python behavior
@@ -25,13 +25,13 @@ class Context
     promise  # Return promise to maintain async pattern
   end
 
-  def initialize(rpc, args, file_path)
+  def initialize(rpc, args)
     @rpc = rpc
     @trace_id = args.traceId
+    @traceId = args.traceId
     @flows = args.flows
-    @file_name = file_path.split('/').last  # Consistent with Python/Node
     @state = RpcStateManager.new(rpc)
-    @logger = CustomLogger.new(@trace_id, @flows, @file_name, @rpc)
+    @logger = CustomLogger.new(@trace_id, @flows, @rpc)
   end
 end
 
@@ -50,15 +50,18 @@ def run_ruby_module(file_path, args)
     end
 
     rpc = RpcSender.new
-    context = Context.new(rpc, args, file_path)
+    context = Context.new(rpc, args)
     rpc.init
 
     # Call handler and wait for any promises
-    result = handler(args.data, context)
-    
-    # If handler returns a promise-like object, wait for it
-    if result.respond_to?(:value)
-      result.value
+    if args.contextInFirstArg
+      result = handler(context)
+    else
+      result = handler(args.data, context)
+    end
+
+    if result
+      rpc.send('result', result)
     end
 
   rescue => e

package/dist/src/server.js

@@ -13,36 +13,43 @@ const socket_io_1 = require("socket.io");
 const flows_endpoint_1 = require("./flows-endpoint");
 const guards_1 = require("./guards");
 const logger_1 = require("./logger");
-const get_module_export_1 = require("./node/get-module-export");
 const steps_1 = require("./steps");
-const utils_1 = require("./utils");
+const call_step_file_1 = require("./call-step-file");
 const createServer = async (lockedData, eventManager, state) => {
+    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 allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
-    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, io);
-    const asyncHandler = (step, flows) => {
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, io);
+    const asyncHandler = (step) => {
         return async (req, res) => {
             const traceId = (0, crypto_1.randomUUID)();
-            const logger = new logger_1.Logger(traceId, flows, step.config.name, io);
-            logger.debug('[API] Received request, processing step', { path: req.path, step });
-            const handler = (await (0, get_module_export_1.getModuleExport)(step.filePath, 'handler'));
+            const { name, flows } = step.config;
+            const logger = new logger_1.Logger(traceId, flows, name, io);
+            logger.debug('[API] Received request, processing step', { path: req.path });
             const request = {
                 body: req.body,
                 headers: req.headers,
                 pathParams: req.params,
                 queryParams: req.query,
             };
-            const emit = async ({ data, type }) => {
-                if (!(0, utils_1.isAllowedToEmit)(step, type)) {
-                    lockedData.printer.printInvalidEmit(step, type);
+            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;
                 }
-                await eventManager.emit({ data, type, traceId, flows, logger }, step.filePath);
-            };
-            try {
-                const result = await handler(request, { emit, state, logger, traceId });
                 if (result.headers) {
                     Object.entries(result.headers).forEach(([key, value]) => res.setHeader(key, value));
                 }
@@ -60,13 +67,13 @@ const createServer = async (lockedData, eventManager, state) => {
     app.use(body_parser_1.default.urlencoded({ extended: true }));
     const router = express_1.default.Router();
     const addRoute = (step) => {
-        const { method, flows, path } = step.config;
+        const { method, path } = step.config;
         logger_1.globalLogger.debug('[API] Registering route', step.config);
         if (method === 'POST') {
-            router.post(path, asyncHandler(step, flows));
+            router.post(path, asyncHandler(step));
         }
         else if (method === 'GET') {
-            router.get(path, asyncHandler(step, flows));
+            router.get(path, asyncHandler(step));
         }
         else {
             throw new Error(`Unsupported method: ${method}`);

package/dist/src/state/adapters/default-state-adapter.js

@@ -41,10 +41,10 @@ const fs_1 = __importDefault(require("fs"));
 const path = __importStar(require("path"));
 class FileStateAdapter {
     constructor(config) {
-        this.filePath = path.join(config.filePath, 'motia-state.json');
+        this.filePath = path.join(config.filePath, 'motia.state.json');
     }
     async init() {
-        const dir = this.filePath.replace('motia-state.json', '');
+        const dir = this.filePath.replace('motia.state.json', '');
         try {
             fs_1.default.realpathSync(dir);
         }

package/dist/src/step-handlers.js

@@ -5,10 +5,16 @@ const logger_1 = require("./logger");
 const call_step_file_1 = require("./call-step-file");
 const createStepHandlers = (lockedData, eventManager, state) => {
     const eventSteps = lockedData.eventSteps();
+    const printer = lockedData.printer;
     logger_1.globalLogger.debug(`[step handler] creating step handlers for ${eventSteps.length} steps`);
+    const removeLogger = (event) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { logger, ...rest } = event;
+        return rest;
+    };
     const createHandler = (step) => {
         const { config, filePath } = step;
-        const { subscribes } = config;
+        const { subscribes, name } = config;
         logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
         subscribes.forEach((subscribe) => {
             eventManager.subscribe({
@@ -16,18 +22,26 @@ const createStepHandlers = (lockedData, eventManager, state) => {
                 event: subscribe,
                 handlerName: step.config.name,
                 handler: async (event) => {
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                    const { logger, ...rest } = event;
-                    logger_1.globalLogger.debug('[step handler] received event', { event: rest, step: step.config.name });
+                    const { logger, data, traceId } = event;
+                    logger_1.globalLogger.debug('[step handler] received event', { event: removeLogger(event), step: name });
                     try {
-                        await (0, call_step_file_1.callStepFile)(step, lockedData, event, eventManager, state);
+                        await (0, call_step_file_1.callStepFile)({
+                            contextInFirstArg: false,
+                            step,
+                            printer,
+                            eventManager,
+                            state,
+                            data,
+                            traceId,
+                            logger,
+                        });
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     }
                     catch (error) {
                         logger_1.globalLogger.error(`[step handler] error calling step`, {
                             error: error.message,
                             filePath,
-                            step: step.config.name,
+                            step: name,
                         });
                     }
                 },

package/dist/src/step-validator.js

@@ -2,6 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStep = void 0;
 const zod_1 = require("zod");
+const jsonSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    properties: zod_1.z.record(zod_1.z.any()),
+    required: zod_1.z.array(zod_1.z.string()).optional(),
+    additionalProperties: zod_1.z.boolean().optional(),
+    description: zod_1.z.string().optional(),
+    title: zod_1.z.string().optional(),
+    definitions: zod_1.z.record(zod_1.z.any()).optional(),
+    $ref: zod_1.z.string().optional(),
+    items: zod_1.z.any().optional(),
+    enum: zod_1.z.array(zod_1.z.any()).optional(),
+    allOf: zod_1.z.array(zod_1.z.any()).optional(),
+    anyOf: zod_1.z.array(zod_1.z.any()).optional(),
+    oneOf: zod_1.z.array(zod_1.z.any()).optional(),
+    not: zod_1.z.any().optional(),
+    format: zod_1.z.string().optional(),
+    default: zod_1.z.any().optional(),
+    examples: zod_1.z.array(zod_1.z.any()).optional(),
+    multipleOf: zod_1.z.number().optional(),
+    maximum: zod_1.z.number().optional(),
+    exclusiveMaximum: zod_1.z.union([zod_1.z.boolean(), zod_1.z.number()]).optional(),
+    minimum: zod_1.z.number().optional(),
+    exclusiveMinimum: zod_1.z.union([zod_1.z.boolean(), zod_1.z.number()]).optional(),
+    maxLength: zod_1.z.number().optional(),
+    minLength: zod_1.z.number().optional(),
+    pattern: zod_1.z.string().optional(),
+    maxItems: zod_1.z.number().optional(),
+    minItems: zod_1.z.number().optional(),
+    uniqueItems: zod_1.z.boolean().optional(),
+    maxProperties: zod_1.z.number().optional(),
+    minProperties: zod_1.z.number().optional(),
+    const: zod_1.z.any().optional(),
+});
 const emits = zod_1.z.array(zod_1.z.union([
     zod_1.z.string(),
     zod_1.z
@@ -30,7 +63,7 @@ const eventSchema = zod_1.z
     subscribes: zod_1.z.array(zod_1.z.string()),
     emits: emits,
     virtualEmits: emits.optional(),
-    input: zod_1.z.any(),
+    input: zod_1.z.union([jsonSchema, zod_1.z.null()]).optional(),
     flows: zod_1.z.array(zod_1.z.string()).optional(),
 })
     .strict();
@@ -45,7 +78,7 @@ 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.instanceof(zod_1.z.ZodObject).optional(),
+    bodySchema: zod_1.z.union([jsonSchema, zod_1.z.null()]).optional(),
 })
     .strict();
 const cronSchema = zod_1.z

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
 import { z, ZodObject } from 'zod';
-import { Logger } from './logger';
+import { BaseLogger, Logger } from './logger';
 export type InternalStateManager = {
     get<T>(traceId: string, key: string): Promise<T | null>;
     set<T>(traceId: string, key: string, value: T): Promise<void>;
@@ -75,13 +75,14 @@ export type CronConfig = {
     emits: Emit[];
     flows?: string[];
 };
-export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : T extends CronConfig ? never : never;
+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;
 export type Event<TData = unknown> = {
     type: string;
     data: TData;
     traceId: string;
     flows?: string[];
-    logger: Logger;
+    logger: BaseLogger;
 };
 export type Handler<TData = unknown> = (event: Event<TData>) => Promise<void>;
 export type SubscribeConfig<TData> = {

package/dist/src/utils.js

@@ -10,6 +10,9 @@ const isAllowedToEmit = (step, emit) => {
     if ((0, guards_1.isEventStep)(step)) {
         return step.config.emits.map(toType).includes(emit);
     }
+    if ((0, guards_1.isCronStep)(step)) {
+        return step.config.emits.map(toType).includes(emit);
+    }
     return false;
 };
 exports.isAllowedToEmit = isAllowedToEmit;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
@@ -20,13 +20,15 @@
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
     "@types/node-cron": "^3.0.11",
+    "@types/supertest": "^6.0.2",
     "jest": "^29.7.0",
+    "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.2"
   },
   "scripts": {
-    "move:python": "cp src/python/*.py dist/src/python",
-    "move:rb": "cp src/ruby/*.rb dist/src/ruby",
+    "move:python": "mkdir -p dist/src/python && cp src/python/*.py dist/src/python",
+    "move:rb": "mkdir -p dist/src/ruby && cp src/ruby/*.rb dist/src/ruby",
     "move:steps": "cp src/steps/*.ts dist/src/steps",
     "build": "rm -rf dist && tsc && npm run move:python && npm run move:rb && npm run move:steps",
     "lint": "eslint --config ../../eslint.config.js",

package/dist/src/node/get-module-export.d.ts

@@ -1 +0,0 @@
-export declare const getModuleExport: (filePath: string, exportName: string) => Promise<any>;

package/dist/src/node/get-module-export.js

@@ -1,68 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModuleExport = void 0;
-const path_1 = __importDefault(require("path"));
-const tsconfigPaths = __importStar(require("tsconfig-paths"));
-const tsConfigPath = path_1.default.resolve(process.cwd(), 'tsconfig.json');
-const result = tsconfigPaths.loadConfig(tsConfigPath);
-if (result.resultType !== 'success') {
-    throw Error('Failed to load tsconfig.json');
-}
-const { absoluteBaseUrl, paths } = result;
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-require('ts-node').register({
-    transpileOnly: true,
-    compilerOptions: { module: 'commonjs', baseUrl: absoluteBaseUrl, paths },
-});
-const getModuleExport = async (filePath, exportName) => {
-    try {
-        const resolvedFilePath = require.resolve(filePath);
-        if (resolvedFilePath in require.cache) {
-            delete require.cache[resolvedFilePath];
-        }
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const module = require(resolvedFilePath);
-        return module[exportName];
-    }
-    catch (error) {
-        console.error(`Failed to extract ${exportName} from`, error);
-        return undefined;
-    }
-};
-exports.getModuleExport = getModuleExport;

package/dist/src/python/get-python-config.d.ts

@@ -1,2 +0,0 @@
-import { StepConfig } from '../types';
-export declare const getPythonConfig: (file: string) => Promise<StepConfig>;

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

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPythonConfig = void 0;
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
-const logger_1 = require("../logger");
-const getPythonConfig = (file) => {
-    const getConfig = path_1.default.join(__dirname, 'get-config.py');
-    return new Promise((resolve, reject) => {
-        let config = null;
-        const child = (0, child_process_1.spawn)('python', [getConfig, file], {
-            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-        });
-        child.on('message', (message) => {
-            logger_1.globalLogger.debug('[Python Config] Read config', { config: message });
-            config = message;
-        });
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Process exited with code ${code}`));
-            }
-            else if (!config) {
-                reject(new Error(`No config found for file ${file}`));
-            }
-            else {
-                resolve(config);
-            }
-        });
-    });
-};
-exports.getPythonConfig = getPythonConfig;