@motiadev/core 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -4,8 +4,7 @@ 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 * from './src/cron-handler';
 export * from './src/guards';
+export * from './src/locked-data';
+export * from './src/get-step-config';

package/dist/index.js

@@ -20,8 +20,7 @@ __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);
 __exportStar(require("./src/cron-handler"), exports);
 __exportStar(require("./src/guards"), exports);
+__exportStar(require("./src/locked-data"), exports);
+__exportStar(require("./src/get-step-config"), exports);

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

@@ -1,2 +1,3 @@
-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 { 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>;

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

@@ -7,6 +7,7 @@ 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 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');
@@ -25,11 +26,11 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const callStepFile = (stepPath, step, event, eventManager, state) => {
+const callStepFile = (step, lockedData, 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], {
+        const { runner, command } = getLanguageBasedRunner(step.filePath);
+        const child = (0, child_process_1.spawn)(command, [runner, step.filePath, jsonData], {
             stdio: [undefined, undefined, undefined, 'ipc'],
         });
         const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
@@ -39,13 +40,17 @@ const callStepFile = (stepPath, step, event, eventManager, state) => {
         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) => {
+        rpcProcessor.handler('emit', async (input) => {
+            if (!(0, utils_1.isAllowedToEmit)(step, input.type)) {
+                lockedData.printer.printInvalidEmit(step, input.type);
+                return;
+            }
             return eventManager.emit({
                 ...input,
                 traceId: event.traceId,
                 flows: event.flows,
                 logger: event.logger,
-            }, stepPath);
+            }, step.filePath);
         });
         rpcProcessor.init();
         child.stdout?.on('data', (data) => {

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

@@ -1,3 +1,13 @@
-import { EventManager, Step } from './types';
 import { Server } from 'socket.io';
-export declare const setupCronHandlers: (steps: Step[], eventManager: EventManager, socketServer?: Server) => () => void;
+import { LockedData } from './locked-data';
+import { EventManager, Step, CronConfig } 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) => {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => void;
+};

package/dist/src/cron-handler.js

@@ -34,13 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCronHandlers = void 0;
-const logger_1 = require("./logger");
 const cron = __importStar(require("node-cron"));
-const guards_1 = require("./guards");
+const logger_1 = require("./logger");
 const get_module_export_1 = require("./node/get-module-export");
-const cronJobs = new Map();
-const setupCronHandlers = (steps, eventManager, socketServer) => {
-    steps.filter(guards_1.isCronStep).forEach(async (step) => {
+const setupCronHandlers = (lockedData, eventManager, socketServer) => {
+    const cronJobs = new Map();
+    const createCronJob = (step) => {
         const { config, filePath } = step;
         const { cron: cronExpression } = config;
         if (!cron.validate(cronExpression)) {
@@ -58,24 +57,21 @@ const setupCronHandlers = (steps, eventManager, socketServer) => {
         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;
             try {
                 const handler = await (0, get_module_export_1.getModuleExport)(filePath, 'handler');
                 const emit = async (event) => {
-                    await eventManager.emit({
-                        ...event,
-                        traceId,
-                        flows: config.flows,
-                        logger,
-                    }, filePath);
+                    await eventManager.emit({ ...event, traceId, flows, logger }, filePath);
                 };
                 if (handler) {
                     await handler({ emit, logger, traceId });
                 }
                 else {
-                    await emit({
-                        type: config.emits[0],
-                        data: { timestamp: Date.now() },
-                    });
+                    const data = { timestamp: Date.now() };
+                    await Promise.all(config.emits.map((item) => {
+                        const type = typeof item === 'string' ? item : item.type;
+                        emit({ type, data });
+                    }));
                 }
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
@@ -86,11 +82,20 @@ const setupCronHandlers = (steps, eventManager, socketServer) => {
                 });
             }
         });
-        cronJobs.set(step.config.name, task);
-    });
-    return () => {
+        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

@@ -8,15 +8,20 @@ const createEventManager = () => {
         const eventHandlers = handlers[event.type] ?? [];
         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-endpoint.d.ts

@@ -1,5 +1,6 @@
 import { Express } from 'express';
-import { Emit, LockedData } from './types';
+import { Emit } from './types';
+import { LockedData } from './locked-data';
 type FlowListResponse = {
     id: string;
     name: string;
@@ -34,6 +35,6 @@ 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 generateFlowsList: (lockedData: LockedData) => FlowResponse[];
 export {};

package/dist/src/flows-endpoint.js

@@ -9,12 +9,13 @@ 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 = (flows, app) => {
-    const list = (0, exports.generateFlowsList)(flows);
+const flowsEndpoint = (lockedData, app) => {
     app.get('/flows', async (_, res) => {
+        const list = (0, exports.generateFlowsList)(lockedData);
         res.status(200).send(list.map(({ id, name }) => ({ id, name })));
     });
     app.get('/flows/:id', async (req, res) => {
+        const list = (0, exports.generateFlowsList)(lockedData);
         const { id } = req.params;
         const flow = list.find((flow) => flow.id === id);
         if (!flow) {
@@ -26,8 +27,8 @@ const flowsEndpoint = (flows, app) => {
     });
 };
 exports.flowsEndpoint = flowsEndpoint;
-const generateFlowsList = (flows) => {
-    return Object.entries(flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
+const generateFlowsList = (lockedData) => {
+    return Object.entries(lockedData.flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
 };
 exports.generateFlowsList = generateFlowsList;
 // Helper functions

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

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

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

@@ -0,0 +1,22 @@
+"use strict";
+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);
+    }
+    else if (isPython) {
+        return (0, get_python_config_1.getPythonConfig)(filePath);
+    }
+    else if (isNode) {
+        return (0, get_config_1.getNodeFileConfig)(filePath);
+    }
+    return null;
+};
+exports.getStepConfig = getStepConfig;

package/dist/src/guards.d.ts

@@ -1,5 +1,5 @@
 import { ApiRouteConfig, EventConfig, NoopConfig, Step, CronConfig } from './types';
 export declare const isApiStep: (step: Step) => step is Step<ApiRouteConfig>;
-export declare const isEventStep: (step: Step) => step is Step<EventConfig<any>>;
+export declare const isEventStep: (step: Step) => step is Step<EventConfig>;
 export declare const isNoopStep: (step: Step) => step is Step<NoopConfig>;
 export declare const isCronStep: (step: Step) => step is Step<CronConfig>;

package/dist/src/guards.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCronStep = exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
 const isApiStep = (step) => step.config.type === 'api';
 exports.isApiStep = isApiStep;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const isEventStep = (step) => step.config.type === 'event';
 exports.isEventStep = isEventStep;
 const isNoopStep = (step) => step.config.type === 'noop';

package/dist/src/locked-data.d.ts

@@ -0,0 +1,26 @@
+import { ZodObject } from 'zod';
+import { ApiRouteConfig, CronConfig, EventConfig, Flow, Step } from './types';
+import { Printer } from './printer';
+type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
+export declare class LockedData {
+    readonly baseDir: string;
+    flows: Record<string, Flow>;
+    activeSteps: Step[];
+    devSteps: Step[];
+    readonly printer: Printer;
+    private stepsMap;
+    private handlers;
+    constructor(baseDir: string);
+    on(event: FlowEvent, handler: (flowName: string) => void): void;
+    eventSteps(): Step<EventConfig<ZodObject<any>>>[];
+    apiSteps(): Step<ApiRouteConfig>[];
+    cronSteps(): Step<CronConfig>[];
+    updateStep(oldStep: Step, newStep: Step): boolean;
+    createStep(step: Step): boolean;
+    deleteStep(step: Step): void;
+    private createFlow;
+    private removeFlow;
+    private onFlowUpdated;
+    private isValidStep;
+}
+export {};

package/dist/src/locked-data.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockedData = void 0;
+const guards_1 = require("./guards");
+const step_validator_1 = require("./step-validator");
+const printer_1 = require("./printer");
+class LockedData {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.flows = {};
+        this.activeSteps = [];
+        this.devSteps = [];
+        this.stepsMap = {};
+        this.printer = new printer_1.Printer(baseDir);
+        this.handlers = {
+            'flow-created': [],
+            'flow-removed': [],
+            'flow-updated': [],
+        };
+    }
+    on(event, handler) {
+        this.handlers[event].push(handler);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    eventSteps() {
+        return this.activeSteps.filter(guards_1.isEventStep);
+    }
+    apiSteps() {
+        return this.activeSteps.filter(guards_1.isApiStep);
+    }
+    cronSteps() {
+        return this.activeSteps.filter(guards_1.isCronStep);
+    }
+    updateStep(oldStep, newStep) {
+        if (!this.isValidStep(newStep)) {
+            this.deleteStep(oldStep);
+            return false;
+        }
+        if (oldStep.config.type !== newStep.config.type) {
+            this.activeSteps = this.activeSteps.filter((s) => s.filePath !== oldStep.filePath);
+            this.devSteps = this.devSteps.filter((s) => s.filePath !== oldStep.filePath);
+            if (newStep.config.virtualEmits) {
+                this.devSteps.push(newStep);
+            }
+            else {
+                this.activeSteps.push(newStep);
+            }
+        }
+        const savedStep = this.stepsMap[newStep.filePath];
+        const addedFlows = newStep.config.flows?.filter((flowName) => !oldStep.config.flows?.includes(flowName)) ?? [];
+        const removedFlows = oldStep.config.flows?.filter((flowName) => !newStep.config.flows?.includes(flowName)) ?? [];
+        const untouchedFlows = oldStep.config.flows?.filter((flowName) => newStep.config.flows?.includes(flowName)) ?? [];
+        untouchedFlows.forEach((flowName) => this.onFlowUpdated(flowName));
+        for (const flowName of addedFlows) {
+            if (!this.flows[flowName]) {
+                const flow = this.createFlow(flowName);
+                flow.steps.push(savedStep);
+            }
+            else {
+                this.flows[flowName].steps.push(savedStep);
+                this.onFlowUpdated(flowName);
+            }
+        }
+        for (const flowName of removedFlows) {
+            const flowSteps = this.flows[flowName].steps;
+            this.flows[flowName].steps = flowSteps.filter(({ filePath }) => filePath !== newStep.filePath);
+            if (this.flows[flowName].steps.length === 0) {
+                this.removeFlow(flowName);
+            }
+            else {
+                this.onFlowUpdated(flowName);
+            }
+        }
+        savedStep.config = newStep.config;
+        this.printer.printStepUpdated(newStep);
+        return true;
+    }
+    createStep(step) {
+        if (!this.isValidStep(step)) {
+            return false;
+        }
+        this.stepsMap[step.filePath] = step;
+        if (step.config.virtualEmits) {
+            this.devSteps.push(step);
+        }
+        else {
+            this.activeSteps.push(step);
+        }
+        for (const flowName of step.config.flows ?? []) {
+            if (!this.flows[flowName]) {
+                const flow = this.createFlow(flowName);
+                flow.steps.push(step);
+            }
+            else {
+                this.flows[flowName].steps.push(step);
+                this.onFlowUpdated(flowName);
+            }
+        }
+        this.printer.printStepCreated(step);
+        return true;
+    }
+    deleteStep(step) {
+        // Remove step from active and dev steps
+        this.activeSteps = this.activeSteps.filter(({ filePath }) => filePath !== step.filePath);
+        this.devSteps = this.devSteps.filter(({ filePath }) => filePath !== step.filePath);
+        delete this.stepsMap[step.filePath];
+        for (const flowName of step.config.flows ?? []) {
+            const stepFlows = this.flows[flowName]?.steps;
+            if (stepFlows) {
+                this.flows[flowName].steps = stepFlows.filter(({ filePath }) => filePath !== step.filePath);
+            }
+            if (this.flows[flowName].steps.length === 0) {
+                this.removeFlow(flowName);
+            }
+            else {
+                this.onFlowUpdated(flowName);
+            }
+        }
+        this.printer.printStepRemoved(step);
+    }
+    createFlow(flowName) {
+        const flow = { name: flowName, description: '', steps: [] };
+        this.flows[flowName] = flow;
+        this.handlers['flow-created'].forEach((handler) => handler(flowName));
+        this.printer.printFlowCreated(flowName);
+        return flow;
+    }
+    removeFlow(flowName) {
+        delete this.flows[flowName];
+        this.handlers['flow-removed'].forEach((handler) => handler(flowName));
+        this.printer.printFlowRemoved(flowName);
+    }
+    onFlowUpdated(flowName) {
+        this.handlers['flow-updated'].forEach((handler) => handler(flowName));
+    }
+    isValidStep(step) {
+        const validationResult = (0, step_validator_1.validateStep)(step);
+        if (!validationResult.success) {
+            this.printer.printValidationError(step.filePath, validationResult);
+        }
+        return validationResult.success;
+    }
+}
+exports.LockedData = LockedData;

package/dist/src/logger.d.ts

@@ -1,18 +1,19 @@
 import { Server } from 'socket.io';
-declare class BaseLogger {
+export declare class BaseLogger {
     private logger;
     constructor(meta?: Record<string, unknown>);
     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 emitLog;
-    constructor(traceId: string, flows: string[], file: string, socketServer?: Server);
+    constructor(traceId: string, flows: string[] | undefined, file: string, socketServer?: Server);
     log(message: any): void;
     info: (message: string, args?: unknown) => void;
     error: (message: string, args?: unknown) => void;
@@ -20,4 +21,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,7 +3,7 @@ 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 {
@@ -27,7 +27,11 @@ 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 });

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

@@ -53,13 +53,16 @@ require('ts-node').register({
 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 ${filePath}:`, error);
-        throw new Error(`No ${exportName} found in step ${filePath}`);
+        console.error(`Failed to extract ${exportName} from`, error);
+        return undefined;
     }
 };
 exports.getModuleExport = getModuleExport;

package/dist/src/printer.d.ts

@@ -0,0 +1,17 @@
+import { ValidationError } from './step-validator';
+import { Step } from './types';
+export declare class Printer {
+    private readonly baseDir;
+    constructor(baseDir: string);
+    printInvalidEmit(step: Step, emit: string): void;
+    printStepCreated(step: Step): void;
+    printStepUpdated(step: Step): void;
+    printStepRemoved(step: Step): void;
+    printFlowCreated(flowName: string): void;
+    printFlowUpdated(flowName: string): void;
+    printFlowRemoved(flowName: string): void;
+    printValidationError(stepPath: string, validationError: ValidationError): void;
+    private getRelativePath;
+    private getStepType;
+    private getStepPath;
+}

package/dist/src/printer.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Printer = void 0;
+const colors_1 = __importDefault(require("colors"));
+const path_1 = __importDefault(require("path"));
+const guards_1 = require("./guards");
+const stepTag = colors_1.default.bold(colors_1.default.magenta('Step'));
+const flowTag = colors_1.default.bold(colors_1.default.blue('Flow'));
+const created = colors_1.default.green('➜ [CREATED]');
+const updated = colors_1.default.yellow('➜ [UPDATED]');
+const removed = colors_1.default.red('➜ [REMOVED]');
+const invalidEmit = colors_1.default.red('➜ [INVALID EMIT]');
+const error = colors_1.default.red('[ERROR]');
+class Printer {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    printInvalidEmit(step, emit) {
+        console.log(`${invalidEmit} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} tried to emit an event not defined in the step config: ${colors_1.default.yellow(emit)}`);
+    }
+    printStepCreated(step) {
+        console.log(`${created} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} created`);
+    }
+    printStepUpdated(step) {
+        console.log(`${updated} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} updated`);
+    }
+    printStepRemoved(step) {
+        console.log(`${removed} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} removed`);
+    }
+    printFlowCreated(flowName) {
+        console.log(`${created} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} created`);
+    }
+    printFlowUpdated(flowName) {
+        console.log(`${updated} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} updated`);
+    }
+    printFlowRemoved(flowName) {
+        console.log(`${removed} ${flowTag} ${colors_1.default.bold(colors_1.default.cyan(flowName))} removed`);
+    }
+    printValidationError(stepPath, validationError) {
+        const relativePath = this.getRelativePath(stepPath);
+        console.log(`${error} ${colors_1.default.bold(colors_1.default.cyan(relativePath))}`);
+        validationError.errors?.forEach((error) => {
+            if (error.path) {
+                console.log(`${colors_1.default.red('│')} ${colors_1.default.yellow(`✖ ${error.path}`)}: ${error.message}`);
+            }
+            else {
+                console.log(`${colors_1.default.red('│')} ${colors_1.default.yellow('✖')} ${error.message}`);
+            }
+        });
+        console.log(`${colors_1.default.red('└─')} ${colors_1.default.red(validationError.error)}  `);
+    }
+    getRelativePath(filePath) {
+        return path_1.default.relative(this.baseDir, filePath);
+    }
+    getStepType(step) {
+        if ((0, guards_1.isApiStep)(step))
+            return colors_1.default.gray('(API)');
+        if ((0, guards_1.isEventStep)(step))
+            return colors_1.default.gray('(Event)');
+        if ((0, guards_1.isCronStep)(step))
+            return colors_1.default.gray('(Cron)');
+        if ((0, guards_1.isNoopStep)(step))
+            return colors_1.default.gray('(Noop)');
+        return colors_1.default.gray('(Unknown)');
+    }
+    getStepPath(step) {
+        const stepPath = this.getRelativePath(step.filePath);
+        return colors_1.default.bold(colors_1.default.cyan(stepPath));
+    }
+}
+exports.Printer = Printer;

package/dist/src/server.d.ts

@@ -1,19 +1,17 @@
+import { CronManager } from './cron-handler';
 import { Express } from 'express';
 import http from 'http';
 import { Server as SocketIOServer } from 'socket.io';
 import { StateAdapter } from './state/state-adapter';
-import { EventManager, LockedData, Step } from './types';
-type ServerOptions = {
-    steps: Step[];
-    flows: LockedData['flows'];
-    eventManager: EventManager;
-    state: StateAdapter;
-};
-type ServerOutput = {
+import { ApiRouteConfig, EventManager, Step } from './types';
+import { LockedData } from './locked-data';
+export type MotiaServer = {
     app: Express;
     server: http.Server;
     socketServer: SocketIOServer;
     close: () => Promise<void>;
+    removeRoute: (step: Step<ApiRouteConfig>) => void;
+    addRoute: (step: Step<ApiRouteConfig>) => void;
+    cronManager: CronManager;
 };
-export declare const createServer: (options: ServerOptions) => Promise<ServerOutput>;
-export {};
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => Promise<MotiaServer>;

package/dist/src/server.js

@@ -15,13 +15,13 @@ 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 createServer = async (options) => {
-    const { flows, steps, eventManager, state } = options;
+const utils_1 = require("./utils");
+const createServer = async (lockedData, eventManager, state) => {
     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, ...steps];
-    const cleanupCronJobs = (0, cron_handler_1.setupCronHandlers)(allSteps, eventManager, io);
+    const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, io);
     const asyncHandler = (step, flows) => {
         return async (req, res) => {
             const traceId = (0, crypto_1.randomUUID)();
@@ -35,6 +35,10 @@ const createServer = async (options) => {
                 queryParams: req.query,
             };
             const emit = async ({ data, type }) => {
+                if (!(0, utils_1.isAllowedToEmit)(step, type)) {
+                    lockedData.printer.printInvalidEmit(step, type);
+                    return;
+                }
                 await eventManager.emit({ data, type, traceId, flows, logger }, step.filePath);
             };
             try {
@@ -54,30 +58,44 @@ const createServer = async (options) => {
     };
     app.use(body_parser_1.default.json());
     app.use(body_parser_1.default.urlencoded({ extended: true }));
-    const apiSteps = allSteps.filter(guards_1.isApiStep);
-    for (const step of apiSteps) {
+    const router = express_1.default.Router();
+    const addRoute = (step) => {
         const { method, flows, path } = step.config;
         logger_1.globalLogger.debug('[API] Registering route', step.config);
         if (method === 'POST') {
-            app.post(path, asyncHandler(step, flows));
+            router.post(path, asyncHandler(step, flows));
         }
         else if (method === 'GET') {
-            app.get(path, asyncHandler(step, flows));
+            router.get(path, asyncHandler(step, flows));
         }
         else {
             throw new Error(`Unsupported method: ${method}`);
         }
-    }
-    (0, flows_endpoint_1.flowsEndpoint)(flows, app);
+    };
+    const removeRoute = (step) => {
+        const { path, method } = step.config;
+        const routerStack = router.stack;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filteredStack = routerStack.filter((layer) => {
+            if (layer.route) {
+                const match = layer.route.path === path && layer.route.methods[method.toLowerCase()];
+                return !match;
+            }
+            return true;
+        });
+        router.stack = filteredStack;
+    };
+    allSteps.filter(guards_1.isApiStep).forEach(addRoute);
+    app.use(router);
+    (0, flows_endpoint_1.flowsEndpoint)(lockedData, app);
     server.on('error', (error) => {
         console.error('Server error:', error);
-        cleanupCronJobs();
     });
     const close = async () => {
-        cleanupCronJobs();
+        cronManager.close();
         await io.close();
         server.close();
     };
-    return { app, server, socketServer: io, close };
+    return { app, server, socketServer: io, close, removeRoute, addRoute, cronManager };
 };
 exports.createServer = createServer;

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.d.ts

@@ -1,2 +1,8 @@
-import { EventManager, InternalStateManager, Step } from './types';
-export declare const createStepHandlers: (steps: Step[], eventManager: EventManager, state: InternalStateManager) => void;
+import { EventConfig, EventManager, Step } from './types';
+import { LockedData } from './locked-data';
+import { StateAdapter } from './state/state-adapter';
+export type MotiaEventManager = {
+    createHandler: (step: Step<EventConfig>) => void;
+    removeHandler: (step: Step<EventConfig>) => void;
+};
+export declare const createStepHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => MotiaEventManager;

package/dist/src/step-handlers.js

@@ -2,32 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStepHandlers = void 0;
 const logger_1 = require("./logger");
-const guards_1 = require("./guards");
 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) => {
+const createStepHandlers = (lockedData, eventManager, state) => {
+    const eventSteps = lockedData.eventSteps();
+    logger_1.globalLogger.debug(`[step handler] creating step handlers for ${eventSteps.length} steps`);
+    const createHandler = (step) => {
         const { config, filePath } = step;
         const { subscribes } = config;
         logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
         subscribes.forEach((subscribe) => {
-            eventManager.subscribe(subscribe, step.config.name, 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 });
-                try {
-                    await (0, call_step_file_1.callStepFile)(filePath, step.config.name, event, eventManager, state);
-                    // 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,
-                    });
-                }
+            eventManager.subscribe({
+                filePath,
+                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 });
+                    try {
+                        await (0, call_step_file_1.callStepFile)(step, lockedData, event, eventManager, state);
+                        // 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,
+                        });
+                    }
+                },
             });
         });
-    });
+    };
+    const removeHandler = (step) => {
+        const { config, filePath } = step;
+        const { subscribes } = config;
+        subscribes.forEach((subscribe) => {
+            eventManager.unsubscribe({ filePath, event: subscribe });
+        });
+    };
+    eventSteps.forEach(createHandler);
+    return { removeHandler, createHandler };
 };
 exports.createStepHandlers = createStepHandlers;

package/dist/src/step-validator.d.ts

@@ -0,0 +1,14 @@
+import { Step } from './types';
+export type ValidationSuccess = {
+    success: true;
+};
+export type ValidationError = {
+    success: false;
+    error: string;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export type ValidationResult = ValidationSuccess | ValidationError;
+export declare const validateStep: (step: Step) => ValidationResult;

package/dist/src/step-validator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStep = void 0;
+const zod_1 = require("zod");
+const emits = zod_1.z.array(zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z
+        .object({
+        type: zod_1.z.string(),
+        label: zod_1.z.string().optional(),
+        conditional: zod_1.z.boolean().optional(),
+    })
+        .strict(),
+]));
+const noopSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('noop'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    virtualEmits: emits,
+    virtualSubscribes: zod_1.z.array(zod_1.z.string()),
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const eventSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('event'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    subscribes: zod_1.z.array(zod_1.z.string()),
+    emits: emits,
+    virtualEmits: emits.optional(),
+    input: zod_1.z.any(),
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const apiSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('api'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    path: zod_1.z.string(),
+    method: zod_1.z.string(),
+    emits: emits,
+    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(),
+})
+    .strict();
+const cronSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('cron'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    cron: zod_1.z.string(),
+    virtualEmits: emits.optional(),
+    emits: emits,
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const validateStep = (step) => {
+    try {
+        if (step.config.type === 'noop') {
+            noopSchema.parse(step.config);
+        }
+        else if (step.config.type === 'event') {
+            eventSchema.parse(step.config);
+        }
+        else if (step.config.type === 'api') {
+            apiSchema.parse(step.config);
+        }
+        else if (step.config.type === 'cron') {
+            cronSchema.parse(step.config);
+        }
+        else {
+            return {
+                success: false,
+                error: 'Invalid step type',
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            return {
+                success: false,
+                error: 'Invalid step configuration',
+                errors: error.errors.map((err) => ({ path: err.path.join('.'), message: err.message })),
+            };
+        }
+        // Handle unexpected errors
+        return {
+            success: false,
+            error: 'Unexpected validation error occurred',
+        };
+    }
+};
+exports.validateStep = validateStep;

package/dist/src/types.d.ts

@@ -1,7 +1,5 @@
 import { z, ZodObject } from 'zod';
-import { Server } from 'http';
-import { Server as SocketIOServer } from 'socket.io';
-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>;
@@ -25,7 +23,7 @@ export type Emit = string | {
     label?: string;
     conditional?: boolean;
 };
-export type EventConfig<TInput extends ZodObject<any>> = {
+export type EventConfig<TInput extends ZodObject<any> = any> = {
     type: 'event';
     name: string;
     description?: string;
@@ -33,7 +31,7 @@ export type EventConfig<TInput extends ZodObject<any>> = {
     emits: Emit[];
     virtualEmits?: Emit[];
     input: TInput;
-    flows: string[];
+    flows?: string[];
 };
 export type NoopConfig = {
     type: 'noop';
@@ -41,7 +39,7 @@ export type NoopConfig = {
     description?: string;
     virtualEmits: Emit[];
     virtualSubscribes: string[];
-    flows: string[];
+    flows?: string[];
 };
 export type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
 export type ApiRouteConfig = {
@@ -50,10 +48,10 @@ export type ApiRouteConfig = {
     description?: string;
     path: string;
     method: ApiRouteMethod;
-    emits: string[];
+    emits: Emit[];
     virtualEmits?: Emit[];
     virtualSubscribes?: string[];
-    flows: string[];
+    flows?: string[];
     bodySchema?: ZodObject<any>;
 };
 export type ApiRequest = {
@@ -74,23 +72,32 @@ export type CronConfig = {
     description?: string;
     cron: string;
     virtualEmits?: Emit[];
-    emits: string[];
-    flows: string[];
+    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 MotiaServer = Server;
-export type MotiaSocketServer = SocketIOServer;
 export type Event<TData = unknown> = {
     type: string;
     data: TData;
     traceId: string;
-    flows: string[];
-    logger: Logger;
+    flows?: string[];
+    logger: BaseLogger;
 };
 export type Handler<TData = unknown> = (event: Event<TData>) => Promise<void>;
+export type SubscribeConfig<TData> = {
+    event: string;
+    handlerName: string;
+    filePath: string;
+    handler: Handler<TData>;
+};
+export type UnsubscribeConfig = {
+    filePath: string;
+    event: string;
+};
 export type EventManager = {
     emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
-    subscribe: <TData>(event: string, handlerName: string, handler: Handler<TData>) => void;
+    subscribe: <TData>(config: SubscribeConfig<TData>) => void;
+    unsubscribe: (config: UnsubscribeConfig) => void;
 };
 export type StepConfig = EventConfig<ZodObject<any>> | NoopConfig | ApiRouteConfig | CronConfig;
 export type Step<TConfig extends StepConfig = StepConfig> = {
@@ -103,16 +110,3 @@ export type Flow = {
     description?: string;
     steps: Step[];
 };
-export type LockedData = {
-    baseDir: string;
-    steps: {
-        active: Step[];
-        dev: Step[];
-    };
-    flows: Record<string, Flow>;
-    state: {
-        adapter: string;
-        host: string;
-        port: number;
-    };
-};

package/dist/src/utils.d.ts

@@ -0,0 +1,2 @@
+import { Step } from './types';
+export declare const isAllowedToEmit: (step: Step, emit: string) => boolean;

package/dist/src/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedToEmit = void 0;
+const guards_1 = require("./guards");
+const toType = (emit) => (typeof emit === 'string' ? emit : emit.type);
+const isAllowedToEmit = (step, emit) => {
+    if ((0, guards_1.isApiStep)(step)) {
+        return step.config.emits.map(toType).includes(emit);
+    }
+    if ((0, guards_1.isEventStep)(step)) {
+        return step.config.emits.map(toType).includes(emit);
+    }
+    return false;
+};
+exports.isAllowedToEmit = isAllowedToEmit;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "dependencies": {
     "body-parser": "^1.20.3",
+    "colors": "^1.4.0",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
     "node-cron": "^3.0.3",
@@ -19,7 +20,9 @@
     "@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"
   },