@motiadev/core 0.2.2 → 0.3.0-beta.79

package/README.md

@@ -32,7 +32,7 @@ Create and manage an HTTP server for handling API requests:
 ```typescript
 import { createServer } from '@motiadev/core'
 
-const server = await createServer(lockedData, eventManager, stateAdapter, config)
+const server = createServer(lockedData, eventManager, stateAdapter, config)
 ```
 
 ### Event Management

package/dist/index.d.ts

@@ -12,3 +12,6 @@ export { StateAdapter } from './src/state/state-adapter';
 export { createMermaidGenerator } from './src/mermaid-generator';
 export { StreamConfig, MotiaStream } from './src/types-stream';
 export { getProjectIdentifier, getUserIdentifier, isAnalyticsEnabled, trackEvent } from './src/analytics/utils';
+export { Motia } from './src/motia';
+export { NoPrinter, Printer } from './src/printer';
+export { NoTracer } from './src/observability/no-tracer';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
+exports.NoTracer = exports.Printer = exports.NoPrinter = exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
 var server_1 = require("./src/server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
@@ -45,3 +45,8 @@ Object.defineProperty(exports, "getProjectIdentifier", { enumerable: true, get:
 Object.defineProperty(exports, "getUserIdentifier", { enumerable: true, get: function () { return utils_1.getUserIdentifier; } });
 Object.defineProperty(exports, "isAnalyticsEnabled", { enumerable: true, get: function () { return utils_1.isAnalyticsEnabled; } });
 Object.defineProperty(exports, "trackEvent", { enumerable: true, get: function () { return utils_1.trackEvent; } });
+var printer_1 = require("./src/printer");
+Object.defineProperty(exports, "NoPrinter", { enumerable: true, get: function () { return printer_1.NoPrinter; } });
+Object.defineProperty(exports, "Printer", { enumerable: true, get: function () { return printer_1.Printer; } });
+var no_tracer_1 = require("./src/observability/no-tracer");
+Object.defineProperty(exports, "NoTracer", { enumerable: true, get: function () { return no_tracer_1.NoTracer; } });

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

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

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

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callStepFile = void 0;
 const path_1 = __importDefault(require("path"));
-const utils_1 = require("./utils");
+const utils_1 = require("./analytics/utils");
 const process_manager_1 = require("./process-communication/process-manager");
-const utils_2 = require("./analytics/utils");
+const utils_2 = require("./utils");
 const getLanguageBasedRunner = (stepFilePath = '') => {
     const isPython = stepFilePath.endsWith('.py');
     const isRuby = stepFilePath.endsWith('.rb');
@@ -30,50 +30,96 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const callStepFile = (options) => {
-    const { step, printer, eventManager, state, traceId, data, contextInFirstArg, lockedData } = options;
-    const logger = options.logger.child({ step: step.config.name });
+const callStepFile = (options, motia) => {
+    const { step, traceId, data, tracer, logger, contextInFirstArg = false } = options;
     const flows = step.config.flows;
     return new Promise((resolve, reject) => {
-        const streamConfig = lockedData.getStreams();
+        const streamConfig = motia.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',
         });
-        (0, utils_2.trackEvent)('step_execution_started', { language: command, type: step.config.type, streams: streams.length });
+        (0, utils_1.trackEvent)('step_execution_started', { language: command, type: step.config.type, streams: streams.length });
         processManager
             .spawn()
             .then(() => {
-            // Register all step handlers
-            processManager.handler('close', async () => processManager.kill());
+            processManager.handler('close', async (err) => {
+                processManager.kill();
+                if (err) {
+                    (0, utils_1.trackEvent)('step_execution_error', {
+                        stepName: step.config.name,
+                        traceId,
+                        message: err.message,
+                    });
+                }
+                if (err) {
+                    tracer.end({
+                        message: err.message,
+                        code: err.code,
+                        stack: err.stack?.replace(new RegExp(`${motia.lockedData.baseDir}/`), ''),
+                    });
+                }
+                else {
+                    tracer.end();
+                }
+            });
             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('state.get', async (input) => {
+                tracer.stateOperation('get', input);
+                return motia.state.get(input.traceId, input.key);
+            });
+            processManager.handler('state.set', async (input) => {
+                tracer.stateOperation('set', { traceId: input.traceId, key: input.key, value: true });
+                return motia.state.set(input.traceId, input.key, input.value);
+            });
+            processManager.handler('state.delete', async (input) => {
+                tracer.stateOperation('delete', input);
+                return motia.state.delete(input.traceId, input.key);
+            });
+            processManager.handler('state.clear', async (input) => {
+                tracer.stateOperation('clear', input);
+                return motia.state.clear(input.traceId);
+            });
+            processManager.handler(`state.getGroup`, (input) => {
+                tracer.stateOperation('getGroup', input);
+                return motia.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);
+                const flows = step.config.flows;
+                if (!(0, utils_2.isAllowedToEmit)(step, input.topic)) {
+                    tracer.emitOperation(input.topic, input.data, false);
+                    return motia.printer.printInvalidEmit(step, input.topic);
                 }
-                return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
+                tracer.emitOperation(input.topic, input.data, true);
+                return motia.eventManager.emit({ ...input, traceId, flows, logger, tracer }, 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.handler(`streams.${name}.get`, async (input) => {
+                    tracer.streamOperation(name, 'get', input);
+                    return stateStream.get(input.groupId, input.id);
+                });
+                processManager.handler(`streams.${name}.set`, async (input) => {
+                    tracer.streamOperation(name, 'set', { groupId: input.groupId, id: input.id, data: true });
+                    return stateStream.set(input.groupId, input.id, input.data);
+                });
+                processManager.handler(`streams.${name}.delete`, async (input) => {
+                    tracer.streamOperation(name, 'delete', input);
+                    return stateStream.delete(input.groupId, input.id);
+                });
+                processManager.handler(`streams.${name}.getGroup`, async (input) => {
+                    tracer.streamOperation(name, 'getGroup', input);
+                    return stateStream.getGroup(input.groupId);
+                });
             });
             processManager.onStdout((data) => {
                 try {
@@ -84,24 +130,29 @@ const callStepFile = (options) => {
                     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) {
-                    (0, utils_2.trackEvent)('step_execution_error', { stepName: step.config.name, traceId, code });
+                    const error = { message: `Process exited with code ${code}`, code };
+                    tracer.end(error);
+                    (0, utils_1.trackEvent)('step_execution_error', { stepName: step.config.name, traceId, code });
                     reject(`Process exited with code ${code}`);
                 }
                 else {
+                    tracer.end();
                     resolve(result);
                 }
             });
-            // Handle process errors
             processManager.onProcessError((error) => {
                 processManager.close();
+                tracer.end({
+                    message: error.message,
+                    code: error.code,
+                    stack: error.stack,
+                });
                 if (error.code === 'ENOENT') {
-                    (0, utils_2.trackEvent)('step_execution_error', {
+                    (0, utils_1.trackEvent)('step_execution_error', {
                         stepName: step.config.name,
                         traceId,
                         code: error.code,
@@ -115,7 +166,12 @@ const callStepFile = (options) => {
             });
         })
             .catch((error) => {
-            (0, utils_2.trackEvent)('step_execution_error', {
+            tracer.end({
+                message: error.message,
+                code: error.code,
+                stack: error.stack,
+            });
+            (0, utils_1.trackEvent)('step_execution_error', {
                 stepName: step.config.name,
                 traceId,
                 code: error.code,

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

@@ -1,12 +1,11 @@
-import { LoggerFactory } from './logger-factory';
-import { LockedData } from './locked-data';
-import { CronConfig, EventManager, InternalStateManager, Step } from './types';
+import { Motia } from './motia';
+import { CronConfig, 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) => {
+export declare const setupCronHandlers: (motia: Motia) => {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;

package/dist/src/cron-handler.js

@@ -38,9 +38,8 @@ 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 setupCronHandlers = (motia) => {
     const cronJobs = new Map();
-    const printer = lockedData.printer;
     const createCronJob = (step) => {
         const { config, filePath } = step;
         const { cron: cronExpression, name: stepName, flows } = config;
@@ -58,18 +57,10 @@ const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
         });
         const task = cron.schedule(cronExpression, async () => {
             const traceId = (0, generate_trace_id_1.generateTraceId)();
-            const logger = loggerFactory.create({ traceId, flows, stepName });
+            const logger = motia.loggerFactory.create({ traceId, flows, stepName });
+            const tracer = motia.tracerFactory.createTracer(traceId, step, logger);
             try {
-                await (0, call_step_file_1.callStepFile)({
-                    contextInFirstArg: true,
-                    lockedData,
-                    step,
-                    eventManager,
-                    printer,
-                    state,
-                    traceId,
-                    logger,
-                });
+                await (0, call_step_file_1.callStepFile)({ contextInFirstArg: true, step, traceId, tracer, logger }, motia);
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
             catch (error) {
@@ -92,7 +83,7 @@ const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
         cronJobs.forEach((task) => task.stop());
         cronJobs.clear();
     };
-    lockedData.cronSteps().forEach(createCronJob);
+    motia.lockedData.cronSteps().forEach(createCronJob);
     return { createCronJob, removeCronJob, close };
 };
 exports.setupCronHandlers = setupCronHandlers;

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

@@ -1,2 +1,3 @@
 import { Express } from 'express';
-export declare const flowsConfigEndpoint: (app: Express, baseDir: string) => void;
+import { LockedData } from './locked-data';
+export declare const flowsConfigEndpoint: (app: Express, baseDir: string, lockedData: LockedData) => void;

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

@@ -4,30 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (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 zod_1 = require("zod");
+const flows_config_stream_1 = require("./streams/flows-config-stream");
+const flowsConfigEndpoint = (app, baseDir, lockedData) => {
     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 stream = new flows_config_stream_1.FlowsConfigStream(configPath);
+    lockedData.createStream({
+        filePath: '__motia.flowsConfig',
+        hidden: true,
+        config: {
+            name: '__motia.flowsConfig',
+            schema: zod_1.z.object({ name: zod_1.z.string(), steps: zod_1.z.any(), edges: zod_1.z.any() }),
+            baseConfig: { storageType: 'custom', factory: () => stream },
+        },
+    }, { disableTypeCreation: true })();
+    app.post('/flows/:id/config', async (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));
+            await stream.set('default', newFlowConfig.id, newFlowConfig);
             res.status(200).send({ message: 'Flow config saved successfully' });
         }
         catch (error) {
@@ -35,17 +30,5 @@ const flowsConfigEndpoint = (app, baseDir) => {
             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,42 +1,2 @@
-import { Express } from 'express';
 import { LockedData } from './locked-data';
-import { Emit, Step } from './types';
-type FlowListResponse = {
-    id: string;
-    name: string;
-};
-export type EdgeData = {
-    variant: 'event' | 'virtual';
-    topic: string;
-    label?: string;
-    labelVariant?: 'default' | 'conditional';
-};
-type FlowEdge = {
-    id: string;
-    source: string;
-    target: string;
-    data: EdgeData;
-};
-type FlowStepResponse = {
-    id: string;
-    name: string;
-    type: 'event' | 'api' | 'noop' | 'cron';
-    description?: string;
-    subscribes?: string[];
-    emits: Emit[];
-    virtualEmits?: Emit[];
-    action?: 'webhook';
-    webhookUrl?: string;
-    bodySchema?: unknown;
-    language?: string;
-    nodeComponentPath?: string;
-    filePath?: string;
-    cronExpression?: string;
-};
-type FlowResponse = FlowListResponse & {
-    steps: FlowStepResponse[];
-    edges: FlowEdge[];
-};
-export declare const flowsEndpoint: (lockedData: LockedData, app: Express) => void;
-export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;
-export {};
+export declare const flowsEndpoint: (lockedData: LockedData) => void;

package/dist/src/flows-endpoint.js

@@ -1,162 +1,29 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFlow = exports.flowsEndpoint = void 0;
-const crypto_1 = require("crypto");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+exports.flowsEndpoint = void 0;
 const zod_1 = require("zod");
-const get_step_language_1 = require("./get-step-language");
-const guards_1 = require("./guards");
 const flows_stream_1 = require("./streams/flows-stream");
-const flowsEndpoint = (lockedData, app) => {
+const flows_helper_1 = require("./helper/flows-helper");
+const flowsEndpoint = (lockedData) => {
     const flowsStream = lockedData.createStream({
         filePath: '__motia.flows',
         hidden: true,
         config: {
             name: '__motia.flows',
-            schema: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string() }),
+            schema: zod_1.z.object({ id: zod_1.z.string(), name: zod_1.z.string(), steps: zod_1.z.any(), edges: zod_1.z.any() }),
             baseConfig: { storageType: 'custom', factory: () => new flows_stream_1.FlowsStream(lockedData) },
         },
     }, { disableTypeCreation: true })();
-    lockedData.on('flow-created', (flow) => flowsStream.set('default', flow, { id: flow, name: flow }));
-    lockedData.on('flow-updated', (flow) => flowsStream.set('default', flow, { id: flow, name: flow }));
-    lockedData.on('flow-removed', (flow) => flowsStream.delete('default', flow));
-    app.get('/flows/:id', async (req, res) => {
-        const flowId = req.params.id;
+    lockedData.on('flow-created', (flowId) => {
         const flow = lockedData.flows[flowId];
-        if (!flow) {
-            res.status(404).send({ error: 'Flow not found' });
-        }
-        else {
-            res.status(200).send((0, exports.generateFlow)(flowId, flow.steps));
-        }
+        const response = (0, flows_helper_1.generateFlow)(flowId, flow.steps);
+        flowsStream.set('default', flowId, response);
     });
-};
-exports.flowsEndpoint = flowsEndpoint;
-// Helper functions
-const getNodeComponentPath = (filePath) => {
-    const filePathWithoutExtension = filePath.replace(/\.[^/.]+$/, '');
-    const tsxPath = filePathWithoutExtension + '.tsx';
-    return fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
-};
-const getRelativePath = (filePath) => {
-    const baseDir = process.cwd();
-    return path_1.default.relative(baseDir, filePath);
-};
-const createEdge = (sourceId, targetId, topic, label, variant, conditional) => ({
-    id: `${sourceId}-${targetId}`,
-    source: sourceId,
-    target: targetId,
-    data: {
-        variant,
-        label,
-        topic,
-        labelVariant: conditional ? 'conditional' : 'default',
-    },
-});
-const processEmit = (emit) => {
-    const isString = typeof emit === 'string';
-    return {
-        topic: isString ? emit : emit.topic,
-        label: isString ? undefined : emit.label,
-        conditional: isString ? undefined : emit.conditional,
-    };
-};
-const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
-    const edges = [];
-    emits.forEach((emit) => {
-        const { topic, label, conditional } = processEmit(emit);
-        targetSteps.forEach((targetStep) => {
-            if (targetStep.subscribes?.includes(topic)) {
-                edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
-            }
-        });
+    lockedData.on('flow-updated', (flowId) => {
+        const flow = lockedData.flows[flowId];
+        const response = (0, flows_helper_1.generateFlow)(flowId, flow.steps);
+        flowsStream.set('default', flowId, response);
     });
-    return edges;
-};
-const createBaseStepResponse = (step, id) => ({
-    id,
-    name: step.config.name,
-    description: step.config.description,
-    nodeComponentPath: getNodeComponentPath(step.filePath),
-    filePath: getRelativePath(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 ?? undefined,
-    };
+    lockedData.on('flow-removed', (flowId) => flowsStream.delete('default', flowId));
 };
-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 createCronStepResponse = (step, id) => {
-    if (!(0, guards_1.isCronStep)(step)) {
-        throw new Error('Attempted to create Cron step response with non-Cron step');
-    }
-    return {
-        ...createBaseStepResponse(step, id),
-        type: 'cron',
-        emits: step.config.emits,
-        cronExpression: step.config.cron,
-    };
-};
-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);
-    if ((0, guards_1.isCronStep)(step))
-        return createCronStepResponse(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 };
-};
-exports.generateFlow = generateFlow;
+exports.flowsEndpoint = flowsEndpoint;

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

@@ -0,0 +1,3 @@
+import { Step } from 'src/types';
+import { FlowResponse } from '../types/flows-types';
+export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;