@motiadev/core 0.0.6 → 0.0.7-build.20250529212805

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,142 @@
+# @motiadev/core
+
+Core functionality for the Motia framework, providing the foundation for building event-driven workflows.
+
+## Installation
+
+```bash
+npm install @motiadev/core
+# or
+yarn add @motiadev/core
+# or
+pnpm add @motiadev/core
+```
+
+## Overview
+
+`@motiadev/core` is the foundation of the Motia framework, providing:
+
+- Event-driven architecture with pub/sub capabilities
+- Multi-language support (TypeScript, Python, Ruby)
+- State management
+- Cron job scheduling
+- API route handling
+- Logging infrastructure
+
+## Key Components
+
+### Server
+
+Create and manage an HTTP server for handling API requests:
+
+```typescript
+import { createServer } from '@motiadev/core'
+
+const server = await createServer(lockedData, eventManager, stateAdapter, config)
+```
+
+### Event Management
+
+Publish and subscribe to events across your application:
+
+```typescript
+import { createEventManager } from '@motiadev/core'
+
+const eventManager = createEventManager()
+
+// Subscribe to events
+eventManager.subscribe({
+  event: 'user.created',
+  handlerName: 'sendWelcomeEmail',
+  filePath: '/path/to/handler.ts',
+  handler: (event) => {
+    // Handle the event
+  }
+})
+
+// Emit events
+eventManager.emit({
+  topic: 'user.created',
+  data: { userId: '123' },
+  traceId: 'trace-123',
+  logger: logger
+})
+```
+
+### Step Handlers
+
+Create handlers for different types of steps (API, Event, Cron):
+
+```typescript
+import { createStepHandlers } from '@motiadev/core'
+
+const stepHandlers = createStepHandlers(lockedData, eventManager, state, config)
+```
+
+### State Management
+
+Manage application state with different adapters:
+
+```typescript
+import { createStateAdapter } from '@motiadev/core'
+
+const stateAdapter = createStateAdapter({
+  adapter: 'redis',
+  host: 'localhost',
+  port: 6379
+})
+
+// Use state in your handlers
+await state.set(traceId, 'key', value)
+const value = await state.get(traceId, 'key')
+```
+
+### Cron Jobs
+
+Schedule and manage cron jobs:
+
+```typescript
+import { setupCronHandlers } from '@motiadev/core'
+
+const cronManager = setupCronHandlers(lockedData, eventManager, state, loggerFactory)
+```
+
+### Logging
+
+Use the built-in logging system:
+
+```typescript
+import { globalLogger } from '@motiadev/core'
+
+globalLogger.info('Application started')
+globalLogger.error('Something went wrong', { error: err })
+```
+
+## Multi-language Support
+
+Motia supports writing step handlers in multiple languages:
+
+- TypeScript/JavaScript
+- Python
+- Ruby
+
+Each language has its own runner that communicates with the core framework.
+
+## Types
+
+The package exports TypeScript types for all components:
+
+```typescript
+import { 
+  Event, 
+  FlowContext, 
+  ApiRouteConfig, 
+  EventConfig, 
+  CronConfig 
+} from '@motiadev/core'
+```
+
+## License
+
+This package is part of the Motia framework and is licensed under the same terms.
+```

package/dist/index.d.ts

@@ -1,9 +1,14 @@
 export * from './src/types';
-export * from './src/server';
-export * from './src/step-handlers';
-export * from './src/event-manager';
-export * from './src/logger';
-export * from './src/state/create-state-adapter';
-export * from './src/python/get-python-config';
-export * from './src/ruby/get-ruby-config';
-export * from './src/node/get-config';
+export { createServer, MotiaServer } from './src/server';
+export { createStepHandlers, MotiaEventManager } from './src/step-handlers';
+export { createEventManager } from './src/event-manager';
+export { globalLogger, Logger } from './src/logger';
+export { createStateAdapter } from './src/state/create-state-adapter';
+export { setupCronHandlers, CronManager } from './src/cron-handler';
+export { isApiStep, isCronStep, isEventStep, isNoopStep } from './src/guards';
+export { LockedData } from './src/locked-data';
+export { getStepConfig, getStreamConfig } from './src/get-step-config';
+export { StateAdapter } from './src/state/state-adapter';
+export { createMermaidGenerator } from './src/mermaid-generator';
+export { StateStream } from './src/state-stream';
+export { StateStreamConfig, IStateStream } from './src/types-stream';

package/dist/index.js

@@ -14,12 +14,32 @@ 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.StateStream = exports.createMermaidGenerator = exports.getStreamConfig = 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);
-__exportStar(require("./src/server"), exports);
-__exportStar(require("./src/step-handlers"), exports);
-__exportStar(require("./src/event-manager"), exports);
-__exportStar(require("./src/logger"), exports);
-__exportStar(require("./src/state/create-state-adapter"), exports);
-__exportStar(require("./src/python/get-python-config"), exports);
-__exportStar(require("./src/ruby/get-ruby-config"), exports);
-__exportStar(require("./src/node/get-config"), exports);
+var server_1 = require("./src/server");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
+var step_handlers_1 = require("./src/step-handlers");
+Object.defineProperty(exports, "createStepHandlers", { enumerable: true, get: function () { return step_handlers_1.createStepHandlers; } });
+var event_manager_1 = require("./src/event-manager");
+Object.defineProperty(exports, "createEventManager", { enumerable: true, get: function () { return event_manager_1.createEventManager; } });
+var logger_1 = require("./src/logger");
+Object.defineProperty(exports, "globalLogger", { enumerable: true, get: function () { return logger_1.globalLogger; } });
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var create_state_adapter_1 = require("./src/state/create-state-adapter");
+Object.defineProperty(exports, "createStateAdapter", { enumerable: true, get: function () { return create_state_adapter_1.createStateAdapter; } });
+var cron_handler_1 = require("./src/cron-handler");
+Object.defineProperty(exports, "setupCronHandlers", { enumerable: true, get: function () { return cron_handler_1.setupCronHandlers; } });
+var guards_1 = require("./src/guards");
+Object.defineProperty(exports, "isApiStep", { enumerable: true, get: function () { return guards_1.isApiStep; } });
+Object.defineProperty(exports, "isCronStep", { enumerable: true, get: function () { return guards_1.isCronStep; } });
+Object.defineProperty(exports, "isEventStep", { enumerable: true, get: function () { return guards_1.isEventStep; } });
+Object.defineProperty(exports, "isNoopStep", { enumerable: true, get: function () { return guards_1.isNoopStep; } });
+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; } });
+Object.defineProperty(exports, "getStreamConfig", { enumerable: true, get: function () { return get_step_config_1.getStreamConfig; } });
+var mermaid_generator_1 = require("./src/mermaid-generator");
+Object.defineProperty(exports, "createMermaidGenerator", { enumerable: true, get: function () { return mermaid_generator_1.createMermaidGenerator; } });
+var state_stream_1 = require("./src/state-stream");
+Object.defineProperty(exports, "StateStream", { enumerable: true, get: function () { return state_stream_1.StateStream; } });

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

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

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

@@ -4,68 +4,109 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callStepFile = void 0;
-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 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 utils_1 = require("./utils");
+const process_manager_1 = require("./process-communication/process-manager");
 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 = (stepPath, step, event, eventManager, state) => {
+const callStepFile = (options) => {
+    const { step, printer, eventManager, state, traceId, data, contextInFirstArg, lockedData } = 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(stepPath);
-        const child = (0, child_process_1.spawn)(command, [runner, stepPath, jsonData], {
-            stdio: [undefined, undefined, undefined, 'ipc'],
+        const streamConfig = lockedData.getStreams();
+        const streams = Object.keys(streamConfig).map((name) => ({ name }));
+        const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg, streams });
+        const { runner, command, args } = getLanguageBasedRunner(step.filePath);
+        let result;
+        // Create process manager with unified communication handling
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, step.filePath, jsonData],
+            logger,
+            context: 'StepExecution',
         });
-        const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
-        rpcProcessor.handler('log', async (input) => {
-            event.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('emit', (input) => {
-            return eventManager.emit({
-                ...input,
-                traceId: event.traceId,
-                flows: event.flows,
-                logger: event.logger,
-            }, stepPath);
-        });
-        rpcProcessor.init();
-        child.stdout?.on('data', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                event.logger.log(message);
-            }
-            catch (error) {
-                event.logger.info(Buffer.from(data).toString(), { step });
-            }
-        });
-        child.stderr?.on('data', (data) => event.logger.error(Buffer.from(data).toString(), { step }));
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Process exited with code ${code}`));
-            }
-            else {
-                resolve();
-            }
+        processManager
+            .spawn()
+            .then(() => {
+            // Register all step handlers
+            processManager.handler('close', async () => processManager.kill());
+            processManager.handler('log', async (input) => logger.log(input));
+            processManager.handler('state.get', (input) => state.get(input.traceId, input.key));
+            processManager.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
+            processManager.handler('state.delete', (input) => state.delete(input.traceId, input.key));
+            processManager.handler('state.clear', (input) => state.clear(input.traceId));
+            processManager.handler(`state.getGroup`, (input) => state.getGroup(input.groupId));
+            processManager.handler('result', async (input) => {
+                result = input;
+            });
+            processManager.handler('emit', async (input) => {
+                if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
+                    return printer.printInvalidEmit(step, input.topic);
+                }
+                return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
+            });
+            Object.entries(streamConfig).forEach(([name, streamFactory]) => {
+                const stateStream = streamFactory();
+                processManager.handler(`streams.${name}.get`, (input) => stateStream.get(input.groupId, input.id));
+                processManager.handler(`streams.${name}.set`, (input) => stateStream.set(input.groupId, input.id, input.data));
+                processManager.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.groupId, input.id));
+                processManager.handler(`streams.${name}.getGroup`, (input) => stateStream.getGroup(input.groupId));
+            });
+            processManager.onStdout((data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    logger.log(message);
+                }
+                catch {
+                    logger.info(Buffer.from(data).toString());
+                }
+            });
+            // Handle stderr
+            processManager.onStderr((data) => logger.error(Buffer.from(data).toString()));
+            // Handle process close
+            processManager.onProcessClose((code) => {
+                processManager.close();
+                if (code !== 0 && code !== null) {
+                    reject(`Process exited with code ${code}`);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+            // Handle process errors
+            processManager.onProcessError((error) => {
+                processManager.close();
+                if (error.code === 'ENOENT') {
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        })
+            .catch((error) => {
+            reject(`Failed to spawn process: ${error}`);
         });
     });
 };

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

@@ -0,0 +1,13 @@
+import { LoggerFactory } from './logger-factory';
+import { LockedData } from './locked-data';
+import { CronConfig, EventManager, InternalStateManager, 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, state: InternalStateManager, loggerFactory: LoggerFactory) => {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => void;
+};

package/dist/src/cron-handler.js

@@ -0,0 +1,98 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCronHandlers = void 0;
+const cron = __importStar(require("node-cron"));
+const call_step_file_1 = require("./call-step-file");
+const generate_trace_id_1 = require("./generate-trace-id");
+const logger_1 = require("./logger");
+const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
+    const cronJobs = new Map();
+    const printer = lockedData.printer;
+    const createCronJob = (step) => {
+        const { config, filePath } = step;
+        const { cron: cronExpression, name: stepName, flows } = config;
+        if (!cron.validate(cronExpression)) {
+            logger_1.globalLogger.error('[cron handler] invalid cron expression', {
+                expression: cronExpression,
+                step: stepName,
+            });
+            return;
+        }
+        logger_1.globalLogger.debug('[cron handler] setting up cron job', {
+            filePath,
+            step: stepName,
+            cron: cronExpression,
+        });
+        const task = cron.schedule(cronExpression, async () => {
+            const traceId = (0, generate_trace_id_1.generateTraceId)();
+            const logger = loggerFactory.create({ traceId, flows, stepName });
+            try {
+                await (0, call_step_file_1.callStepFile)({
+                    contextInFirstArg: true,
+                    lockedData,
+                    step,
+                    eventManager,
+                    printer,
+                    state,
+                    traceId,
+                    logger,
+                });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                logger.error('[cron handler] error executing cron job', {
+                    error: error.message,
+                    step: step.config.name,
+                });
+            }
+        });
+        cronJobs.set(step.filePath, task);
+    };
+    const removeCronJob = (step) => {
+        const task = cronJobs.get(step.filePath);
+        if (task) {
+            task.stop();
+            cronJobs.delete(step.filePath);
+        }
+    };
+    const close = () => {
+        cronJobs.forEach((task) => task.stop());
+        cronJobs.clear();
+    };
+    lockedData.cronSteps().forEach(createCronJob);
+    return { createCronJob, removeCronJob, close };
+};
+exports.setupCronHandlers = setupCronHandlers;

package/dist/src/event-manager.js

@@ -5,18 +5,23 @@ const logger_1 = require("./logger");
 const createEventManager = () => {
     const handlers = {};
     const emit = async (event, file) => {
-        const eventHandlers = handlers[event.type] ?? [];
+        const eventHandlers = handlers[event.topic] ?? [];
         const { logger, ...rest } = event;
         logger.debug('[Flow Emit] Event emitted', { handlers: eventHandlers.length, data: rest, file });
-        eventHandlers.map((handler) => handler(event));
+        eventHandlers.map((eventHandler) => eventHandler.handler(event));
     };
-    const subscribe = (event, handlerName, handler) => {
+    const subscribe = (config) => {
+        const { event, handlerName, handler, filePath } = config;
         if (!handlers[event]) {
             handlers[event] = [];
         }
         logger_1.globalLogger.debug('[Flow Sub] Subscribing to event', { event, handlerName });
-        handlers[event].push(handler);
+        handlers[event].push({ filePath, handler: handler });
     };
-    return { emit, subscribe };
+    const unsubscribe = (config) => {
+        const { filePath, event } = config;
+        handlers[event] = handlers[event]?.filter((handler) => handler.filePath !== filePath);
+    };
+    return { emit, subscribe, unsubscribe };
 };
 exports.createEventManager = createEventManager;

package/dist/src/flows-config-endpoint.d.ts

@@ -0,0 +1,2 @@
+import { Express } from 'express';
+export declare const flowsConfigEndpoint: (app: Express, baseDir: string) => void;

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

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowsConfigEndpoint = void 0;
+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 {
+            const existingConfig = getConfig();
+            const updatedConfig = {
+                ...existingConfig,
+            };
+            Object.entries(newFlowConfig).forEach(([flowName, filePathPositions]) => {
+                updatedConfig[flowName] = {
+                    ...(updatedConfig[flowName] || {}),
+                    ...filePathPositions,
+                };
+            });
+            fs_1.default.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2));
+            res.status(200).send({ message: 'Flow config saved successfully' });
+        }
+        catch (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 allFlowsConfig = getConfig();
+            const flowConfig = allFlowsConfig[id] || {};
+            res.status(200).send(flowConfig);
+        }
+        catch (error) {
+            console.error('Error reading flow config:', error.message);
+            res.status(400).send({ error: 'Failed to read flow config' });
+        }
+    });
+};
+exports.flowsConfigEndpoint = flowsConfigEndpoint;

package/dist/src/flows-endpoint.d.ts

@@ -1,13 +1,15 @@
 import { Express } from 'express';
-import { Emit, LockedData } from './types';
+import { LockedData } from './locked-data';
+import { Emit, Step } from './types';
 type FlowListResponse = {
     id: string;
     name: string;
 };
 export type EdgeData = {
-    label?: string;
     variant: 'event' | 'virtual';
-    emitType: string;
+    topic: string;
+    label?: string;
+    labelVariant?: 'default' | 'conditional';
 };
 type FlowEdge = {
     id: string;
@@ -18,21 +20,23 @@ type FlowEdge = {
 type FlowStepResponse = {
     id: string;
     name: string;
-    type: 'event' | 'api' | 'noop';
+    type: 'event' | 'api' | 'noop' | 'cron';
     description?: string;
     subscribes?: string[];
     emits: Emit[];
     virtualEmits?: Emit[];
     action?: 'webhook';
     webhookUrl?: string;
-    bodySchema?: any;
+    bodySchema?: unknown;
     language?: string;
     nodeComponentPath?: string;
+    filePath?: string;
+    cronExpression?: string;
 };
 type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];
     edges: FlowEdge[];
 };
-export declare const flowsEndpoint: (flows: LockedData["flows"], app: Express) => void;
-export declare const generateFlowsList: (flows: LockedData["flows"]) => FlowResponse[];
+export declare const flowsEndpoint: (lockedData: LockedData, app: Express) => void;
+export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;
 export {};