@motiadev/core 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -6,3 +6,4 @@ 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';

package/dist/index.js

@@ -22,3 +22,4 @@ __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);

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

@@ -0,0 +1,2 @@
+import { Event, EventManager, InternalStateManager } from './types';
+export declare const callStepFile: <TData>(stepPath: string, step: string, event: Event<TData>, eventManager: EventManager, state: InternalStateManager) => Promise<void>;

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 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' };
+    }
+    else if (isRuby) {
+        return { runner: rubyRunner, command: 'ruby' };
+    }
+    else if (isNode) {
+        return { runner: nodeRunner, command: 'node' };
+    }
+    throw Error(`Unsupported file extension ${stepFilePath}`);
+};
+const callStepFile = (stepPath, step, event, eventManager, state) => {
+    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 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();
+            }
+        });
+    });
+};
+exports.callStepFile = callStepFile;

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

@@ -4,6 +4,17 @@ type FlowListResponse = {
     id: string;
     name: string;
 };
+export type EdgeData = {
+    label?: string;
+    variant: 'event' | 'virtual';
+    emitType: string;
+};
+type FlowEdge = {
+    id: string;
+    source: string;
+    target: string;
+    data: EdgeData;
+};
 type FlowStepResponse = {
     id: string;
     name: string;
@@ -11,6 +22,7 @@ type FlowStepResponse = {
     description?: string;
     subscribes?: string[];
     emits: Emit[];
+    virtualEmits?: Emit[];
     action?: 'webhook';
     webhookUrl?: string;
     bodySchema?: any;
@@ -19,7 +31,8 @@ type FlowStepResponse = {
 };
 type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];
+    edges: FlowEdge[];
 };
-export declare const generateFlowsList: (flows: LockedData["flows"]) => FlowResponse[];
 export declare const flowsEndpoint: (flows: LockedData["flows"], app: Express) => void;
+export declare const generateFlowsList: (flows: LockedData["flows"]) => FlowResponse[];
 export {};

package/dist/src/flows-endpoint.js

@@ -3,65 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flowsEndpoint = exports.generateFlowsList = void 0;
+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 generateFlowsList = (flows) => {
-    const list = [];
-    Object.keys(flows).forEach((flowId) => {
-        const steps = [];
-        const flowSteps = flows[flowId].steps;
-        flowSteps.forEach((step) => {
-            const filePathWithoutExtension = step.filePath.replace(/\.[^/.]+$/, '');
-            const tsxPath = filePathWithoutExtension + '.tsx';
-            const nodeComponentPath = fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
-            if ((0, guards_1.isApiStep)(step)) {
-                steps.push({
-                    id: (0, crypto_1.randomUUID)(),
-                    type: 'api',
-                    name: step.config.name,
-                    description: step.config.description,
-                    emits: [...step.config.emits, ...(step.config.virtualEmits ?? [])],
-                    subscribes: step.config.virtualSubscribes ?? undefined,
-                    action: 'webhook',
-                    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
-                    webhookUrl: `${step.config.method} ${step.config.path}`,
-                    bodySchema: step?.config.bodySchema ? (0, zod_to_json_schema_1.default)(step.config.bodySchema) : undefined,
-                    nodeComponentPath,
-                });
-            }
-            else if ((0, guards_1.isEventStep)(step)) {
-                steps.push({
-                    id: (0, crypto_1.randomUUID)(),
-                    type: 'event',
-                    name: step.config.name,
-                    description: step.config.description,
-                    emits: [...step.config.emits, ...(step.config.virtualEmits ?? [])],
-                    subscribes: step.config.subscribes,
-                    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
-                    nodeComponentPath,
-                });
-            }
-            else if ((0, guards_1.isNoopStep)(step)) {
-                steps.push({
-                    id: (0, crypto_1.randomUUID)(),
-                    type: 'noop',
-                    name: step.config.name,
-                    description: step.config.description,
-                    emits: step.config.virtualEmits,
-                    subscribes: step.config.virtualSubscribes,
-                    nodeComponentPath,
-                });
-            }
-        });
-        list.push({ id: flowId, name: flowId, steps });
-    });
-    return list;
-};
-exports.generateFlowsList = generateFlowsList;
 const flowsEndpoint = (flows, app) => {
     const list = (0, exports.generateFlowsList)(flows);
     app.get('/flows', async (_, res) => {
@@ -79,3 +26,106 @@ const flowsEndpoint = (flows, app) => {
     });
 };
 exports.flowsEndpoint = flowsEndpoint;
+const generateFlowsList = (flows) => {
+    return Object.entries(flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
+};
+exports.generateFlowsList = generateFlowsList;
+// Helper functions
+const getNodeComponentPath = (filePath) => {
+    const filePathWithoutExtension = filePath.replace(/\.[^/.]+$/, '');
+    const tsxPath = filePathWithoutExtension + '.tsx';
+    return fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
+};
+const createEdge = (sourceId, targetId, emitType, label, variant) => ({
+    id: `${sourceId}-${targetId}`,
+    source: sourceId,
+    target: targetId,
+    data: { variant, label, emitType },
+});
+const processEmit = (emit) => {
+    const isString = typeof emit === 'string';
+    return {
+        type: isString ? emit : emit.type,
+        label: isString ? undefined : emit.label,
+    };
+};
+const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
+    const edges = [];
+    emits.forEach((emit) => {
+        const { type: emitType, label } = processEmit(emit);
+        targetSteps.forEach((targetStep) => {
+            if (targetStep.subscribes?.includes(emitType)) {
+                edges.push(createEdge(sourceStep.id, targetStep.id, emitType, label, variant));
+            }
+        });
+    });
+    return edges;
+};
+const createBaseStepResponse = (step, id) => ({
+    id,
+    name: step.config.name,
+    description: step.config.description,
+    nodeComponentPath: getNodeComponentPath(step.filePath),
+    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
+});
+const createApiStepResponse = (step, id) => {
+    if (!(0, guards_1.isApiStep)(step)) {
+        throw new Error('Attempted to create API step response with non-API step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'api',
+        emits: step.config.emits,
+        virtualEmits: step.config.virtualEmits ?? [],
+        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,
+    };
+};
+const createEventStepResponse = (step, id) => {
+    if (!(0, guards_1.isEventStep)(step)) {
+        throw new Error('Attempted to create Event step response with non-Event step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'event',
+        emits: step.config.emits,
+        virtualEmits: step.config.virtualEmits ?? [],
+        subscribes: step.config.subscribes,
+    };
+};
+const createNoopStepResponse = (step, id) => {
+    if (!(0, guards_1.isNoopStep)(step)) {
+        throw new Error('Attempted to create Noop step response with non-Noop step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'noop',
+        emits: [],
+        virtualEmits: step.config.virtualEmits,
+        subscribes: step.config.virtualSubscribes,
+    };
+};
+const createStepResponse = (step) => {
+    const id = (0, crypto_1.randomUUID)();
+    if ((0, guards_1.isApiStep)(step))
+        return createApiStepResponse(step, id);
+    if ((0, guards_1.isEventStep)(step))
+        return createEventStepResponse(step, id);
+    if ((0, guards_1.isNoopStep)(step))
+        return createNoopStepResponse(step, id);
+    throw new Error(`Unknown step type for step: ${step.config.name}`);
+};
+const createEdgesForStep = (sourceStep, allSteps) => {
+    const regularEdges = createEdgesForEmits(sourceStep, allSteps, sourceStep.emits, 'event');
+    const virtualEdges = sourceStep.virtualEmits
+        ? createEdgesForEmits(sourceStep, allSteps, sourceStep.virtualEmits, 'virtual')
+        : [];
+    return [...regularEdges, ...virtualEdges];
+};
+const generateFlow = (flowId, flowSteps) => {
+    const steps = flowSteps.map(createStepResponse);
+    const edges = steps.flatMap((step) => createEdgesForStep(step, steps));
+    return { id: flowId, name: flowId, steps, edges };
+};

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeFileConfig = void 0;
+const get_module_export_1 = require("./get-module-export");
+const getNodeFileConfig = async (filePath) => {
+    try {
+        return await (0, get_module_export_1.getModuleExport)(filePath, 'config');
+    }
+    catch (error) {
+        console.error(`Failed to extract config from ${filePath}:`, error);
+        throw new Error(`No config found in step ${filePath}`);
+    }
+};
+exports.getNodeFileConfig = getNodeFileConfig;

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

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

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

@@ -0,0 +1,63 @@
+"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;
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs', baseUrl: absoluteBaseUrl, paths },
+});
+const getModuleExport = async (filePath, exportName) => {
+    try {
+        const resolvedFilePath = require.resolve(filePath);
+        const module = require(resolvedFilePath);
+        return module[exportName];
+    }
+    catch (error) {
+        console.error(`Failed to extract ${exportName} from ${filePath}:`, error);
+        throw new Error(`No ${exportName} found in step ${filePath}`);
+    }
+};
+exports.getModuleExport = getModuleExport;

package/dist/src/server.js

@@ -12,6 +12,7 @@ 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 createServer = async (options) => {
     const { flows, steps, eventManager, state } = options;
     const app = (0, express_1.default)();
@@ -22,8 +23,7 @@ const createServer = async (options) => {
             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 module = require(step.filePath);
-            const handler = module.handler;
+            const handler = (await (0, get_module_export_1.getModuleExport)(step.filePath, 'handler'));
             const request = {
                 body: req.body,
                 headers: req.headers,

package/dist/src/step-handlers.js

@@ -1,76 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStepHandlers = void 0;
-const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
 const guards_1 = require("./guards");
-const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
-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' };
-    }
-    else if (isRuby) {
-        return { runner: rubyRunner, command: 'ruby' };
-    }
-    else if (isNode) {
-        return { runner: nodeRunner, command: 'node' };
-    }
-    throw Error(`Unsupported file extension ${stepFilePath}`);
-};
-const callStepFile = (stepPath, step, event, eventManager, state) => {
-    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 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();
-            }
-        });
-    });
-};
+const call_step_file_1 = require("./call-step-file");
 const createStepHandlers = (steps, eventManager, state) => {
     logger_1.globalLogger.debug(`[step handler] creating step handlers for ${steps.length} steps`);
     steps.filter(guards_1.isEventStep).forEach((step) => {
@@ -82,7 +15,7 @@ const createStepHandlers = (steps, eventManager, state) => {
                 const { logger, ...rest } = event;
                 logger_1.globalLogger.debug('[step handler] received event', { event: rest, step: step.config.name });
                 try {
-                    await callStepFile(filePath, step.config.name, event, eventManager, state);
+                    await (0, call_step_file_1.callStepFile)(filePath, step.config.name, event, eventManager, state);
                 }
                 catch (error) {
                     logger_1.globalLogger.error(`[step handler] error calling step`, {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "dependencies": {
     "body-parser": "^1.20.3",
     "express": "^4.21.2",
@@ -9,6 +9,7 @@
     "pino": "^9.6.0",
     "socket.io": "^4.8.1",
     "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
     "yaml": "^2.7.0",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1"

package/tsconfig.json

@@ -12,9 +12,9 @@
     "outDir": "./dist",
     "rootDir": ".",
     "baseUrl": ".",
-    "declaration": true
+    "declaration": true,
+    "jsx": "react-jsx",
   },
   "include": ["**/*.ts", "**/*.js"],
-  "jsx": "react-jsx",
   "exclude": ["node_modules", "dist"]
 }