@motiadev/core 0.0.6 → 0.0.7-build.20250529215343

package/dist/src/flows-endpoint.js

@@ -3,59 +3,75 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFlowsList = exports.flowsEndpoint = void 0;
+exports.generateFlow = 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 path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
 const get_step_language_1 = require("./get-step-language");
-const flowsEndpoint = (flows, app) => {
-    const list = (0, exports.generateFlowsList)(flows);
-    app.get('/flows', async (_, res) => {
-        res.status(200).send(list.map(({ id, name }) => ({ id, name })));
-    });
+const guards_1 = require("./guards");
+const flows_stream_1 = require("./streams/flows-stream");
+const flowsEndpoint = (lockedData, app) => {
+    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() }),
+            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 { id } = req.params;
-        const flow = list.find((flow) => flow.id === id);
+        const flowId = req.params.id;
+        const flow = lockedData.flows[flowId];
         if (!flow) {
             res.status(404).send({ error: 'Flow not found' });
         }
         else {
-            res.status(200).send(flow);
+            res.status(200).send((0, exports.generateFlow)(flowId, flow.steps));
         }
     });
 };
 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) => ({
+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, emitType },
+    data: {
+        variant,
+        label,
+        topic,
+        labelVariant: conditional ? 'conditional' : 'default',
+    },
 });
 const processEmit = (emit) => {
     const isString = typeof emit === 'string';
     return {
-        type: isString ? emit : emit.type,
+        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 { type: emitType, label } = processEmit(emit);
+        const { topic, label, conditional } = processEmit(emit);
         targetSteps.forEach((targetStep) => {
-            if (targetStep.subscribes?.includes(emitType)) {
-                edges.push(createEdge(sourceStep.id, targetStep.id, emitType, label, variant));
+            if (targetStep.subscribes?.includes(topic)) {
+                edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
             }
         });
     });
@@ -66,6 +82,7 @@ const createBaseStepResponse = (step, 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) => {
@@ -80,7 +97,7 @@ const createApiStepResponse = (step, id) => {
         subscribes: step.config.virtualSubscribes ?? undefined,
         action: 'webhook',
         webhookUrl: `${step.config.method} ${step.config.path}`,
-        bodySchema: step.config.bodySchema ? (0, zod_to_json_schema_1.default)(step.config.bodySchema) : undefined,
+        bodySchema: step.config.bodySchema ?? undefined,
     };
 };
 const createEventStepResponse = (step, id) => {
@@ -107,6 +124,17 @@ const createNoopStepResponse = (step, id) => {
         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))
@@ -115,6 +143,8 @@ const createStepResponse = (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) => {
@@ -129,3 +159,4 @@ const generateFlow = (flowId, flowSteps) => {
     const edges = steps.flatMap((step) => createEdgesForStep(step, steps));
     return { id: flowId, name: flowId, steps, edges };
 };
+exports.generateFlow = generateFlow;

package/dist/src/generate-trace-id.d.ts

@@ -0,0 +1,2 @@
+export declare const generateCode: (length?: number) => string;
+export declare const generateTraceId: () => string;

package/dist/src/generate-trace-id.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTraceId = exports.generateCode = void 0;
+const generateCode = (length = 6) => {
+    const chars = 'ABCDEFGHJKMNPQRSTUVWXYZ123456789';
+    return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+};
+exports.generateCode = generateCode;
+const generateTraceId = () => {
+    const datePart = String(Date.now()).slice(6);
+    const randomPart = (0, exports.generateCode)(5);
+    return `${randomPart}-${datePart}`;
+};
+exports.generateTraceId = generateTraceId;

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

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

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

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStreamConfig = exports.getStepConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const process_manager_1 = require("./process-communication/process-manager");
+const getLanguageBasedRunner = (stepFilePath = '') => {
+    const isPython = stepFilePath.endsWith('.py');
+    const isRuby = stepFilePath.endsWith('.rb');
+    const isNode = stepFilePath.endsWith('.js') || stepFilePath.endsWith('.ts');
+    if (isPython) {
+        const pythonRunner = path_1.default.join(__dirname, 'python', 'get-config.py');
+        return { runner: pythonRunner, command: 'python', args: [] };
+    }
+    else if (isRuby) {
+        const rubyRunner = path_1.default.join(__dirname, 'ruby', 'get-config.rb');
+        return { runner: rubyRunner, command: 'ruby', args: [] };
+    }
+    else if (isNode) {
+        if (process.env._MOTIA_TEST_MODE === 'true') {
+            const nodeRunner = path_1.default.join(__dirname, 'node', 'get-config.ts');
+            return { runner: nodeRunner, command: 'node', args: ['-r', 'ts-node/register'] };
+        }
+        const nodeRunner = path_1.default.join(__dirname, 'node', 'get-config.js');
+        return { runner: nodeRunner, command: 'node', args: [] };
+    }
+    throw Error(`Unsupported file extension ${stepFilePath}`);
+};
+const getConfig = (file) => {
+    const { runner, command, args } = getLanguageBasedRunner(file);
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const processManager = new process_manager_1.ProcessManager({
+            command,
+            args: [...args, runner, file],
+            logger: logger_1.globalLogger,
+            context: 'Config',
+        });
+        processManager
+            .spawn()
+            .then(() => {
+            processManager.onMessage((message) => {
+                config = message;
+                logger_1.globalLogger.debug(`[Config] Read config via ${processManager.commType?.toUpperCase()}`, {
+                    config,
+                    communicationType: processManager.commType,
+                });
+                resolve(config);
+                processManager.kill();
+            });
+            processManager.onProcessClose((code) => {
+                processManager.close();
+                if (config) {
+                    return;
+                }
+                else if (code !== 0) {
+                    reject(`Process exited with code ${code}`);
+                }
+                else if (!config) {
+                    reject(`No config found for file ${file}`);
+                }
+            });
+            processManager.onProcessError((error) => {
+                processManager.close();
+                if (error.code === 'ENOENT') {
+                    reject(`Executable ${command} not found`);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        })
+            .catch((error) => {
+            reject(`Failed to spawn process: ${error}`);
+        });
+    });
+};
+const getStepConfig = (file) => {
+    return getConfig(file);
+};
+exports.getStepConfig = getStepConfig;
+const getStreamConfig = (file) => {
+    return getConfig(file);
+};
+exports.getStreamConfig = getStreamConfig;

package/dist/src/guards.d.ts

@@ -1,4 +1,5 @@
-import { ApiRouteConfig, EventConfig, NoopConfig, Step } from './types';
+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

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
+exports.isCronStep = exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
 const isApiStep = (step) => step.config.type === 'api';
 exports.isApiStep = isApiStep;
 const isEventStep = (step) => step.config.type === 'event';
 exports.isEventStep = isEventStep;
 const isNoopStep = (step) => step.config.type === 'noop';
 exports.isNoopStep = isNoopStep;
+const isCronStep = (step) => step.config.type === 'cron';
+exports.isCronStep = isCronStep;

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

@@ -0,0 +1,60 @@
+import { Printer } from './printer';
+import { StateStreamFactory } from './state-stream';
+import { ApiRouteConfig, CronConfig, EventConfig, Flow, InternalStateManager, Step } from './types';
+import { Stream } from './types-stream';
+type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
+type StepEvent = 'step-created' | 'step-removed' | 'step-updated';
+type StreamEvent = 'stream-created' | 'stream-removed' | 'stream-updated';
+type StreamWrapper<TData> = (streamName: string, factory: StateStreamFactory<TData>) => StateStreamFactory<TData>;
+export declare class LockedData {
+    readonly baseDir: string;
+    flows: Record<string, Flow>;
+    activeSteps: Step[];
+    devSteps: Step[];
+    printer: Printer;
+    private stepsMap;
+    private handlers;
+    private stepHandlers;
+    private streamHandlers;
+    private streams;
+    private state;
+    private streamWrapper?;
+    constructor(baseDir: string);
+    disablePrinter(): void;
+    applyStreamWrapper<TData>(state: InternalStateManager, streamWrapper: StreamWrapper<TData>): void;
+    saveTypes(): void;
+    on(event: FlowEvent, handler: (flowName: string) => void): void;
+    onStep(event: StepEvent, handler: (step: Step) => void): void;
+    onStream(event: StreamEvent, handler: (stream: Stream) => void): void;
+    eventSteps(): Step<EventConfig>[];
+    apiSteps(): Step<ApiRouteConfig>[];
+    cronSteps(): Step<CronConfig>[];
+    pythonSteps(): Step[];
+    tsSteps(): Step[];
+    getStreams(): Record<string, StateStreamFactory<any>>;
+    findStream(path: string): Stream | undefined;
+    updateStep(oldStep: Step, newStep: Step, options?: {
+        disableTypeCreation?: boolean;
+    }): boolean;
+    createStep(step: Step, options?: {
+        disableTypeCreation?: boolean;
+    }): boolean;
+    deleteStep(step: Step, options?: {
+        disableTypeCreation?: boolean;
+    }): void;
+    private createFactoryWrapper;
+    createStream<TData>(stream: Stream, options?: {
+        disableTypeCreation?: boolean;
+    }): StateStreamFactory<TData>;
+    deleteStream(stream: Stream, options?: {
+        disableTypeCreation?: boolean;
+    }): void;
+    updateStream(oldStream: Stream, stream: Stream, options?: {
+        disableTypeCreation?: boolean;
+    }): void;
+    private createFlow;
+    private removeFlow;
+    private onFlowUpdated;
+    private isValidStep;
+}
+export {};

package/dist/src/locked-data.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockedData = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const guards_1 = require("./guards");
+const printer_1 = require("./printer");
+const state_stream_1 = require("./state-stream");
+const step_validator_1 = require("./step-validator");
+const generate_types_1 = require("./types/generate-types");
+class LockedData {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.state = null;
+        this.flows = {};
+        this.activeSteps = [];
+        this.devSteps = [];
+        this.stepsMap = {};
+        this.printer = new printer_1.Printer(baseDir);
+        this.handlers = {
+            'flow-created': [],
+            'flow-removed': [],
+            'flow-updated': [],
+        };
+        this.stepHandlers = {
+            'step-created': [],
+            'step-removed': [],
+            'step-updated': [],
+        };
+        this.streamHandlers = {
+            'stream-created': [],
+            'stream-removed': [],
+            'stream-updated': [],
+        };
+        this.streams = {};
+    }
+    disablePrinter() {
+        this.printer = new printer_1.NoPrinter(this.baseDir);
+    }
+    applyStreamWrapper(state, streamWrapper) {
+        this.streamWrapper = streamWrapper;
+        this.state = state;
+    }
+    saveTypes() {
+        const types = (0, generate_types_1.generateTypesFromSteps)(this.activeSteps, this.printer);
+        const streams = (0, generate_types_1.generateTypesFromStreams)(this.streams);
+        const typesString = (0, generate_types_1.generateTypesString)(types, streams);
+        fs_1.default.writeFileSync(path_1.default.join(this.baseDir, 'types.d.ts'), typesString);
+    }
+    on(event, handler) {
+        this.handlers[event].push(handler);
+    }
+    onStep(event, handler) {
+        this.stepHandlers[event].push(handler);
+    }
+    onStream(event, handler) {
+        this.streamHandlers[event].push(handler);
+    }
+    eventSteps() {
+        return this.activeSteps.filter(guards_1.isEventStep);
+    }
+    apiSteps() {
+        return this.activeSteps.filter(guards_1.isApiStep);
+    }
+    cronSteps() {
+        return this.activeSteps.filter(guards_1.isCronStep);
+    }
+    pythonSteps() {
+        return this.activeSteps.filter((step) => step.filePath.endsWith('.py'));
+    }
+    tsSteps() {
+        return this.activeSteps.filter((step) => step.filePath.endsWith('.ts'));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getStreams() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const streams = {};
+        for (const [key, value] of Object.entries(this.streams)) {
+            const baseConfig = value.config.baseConfig;
+            const streamFactory = baseConfig.storageType === 'custom' ? baseConfig.factory : null;
+            if (streamFactory) {
+                streams[key] = streamFactory;
+            }
+        }
+        return streams;
+    }
+    findStream(path) {
+        return Object.values(this.streams).find((stream) => stream.filePath === path);
+    }
+    updateStep(oldStep, newStep, options = {}) {
+        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.type === 'noop') {
+                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;
+        if (!options.disableTypeCreation) {
+            this.saveTypes();
+        }
+        this.stepHandlers['step-updated'].forEach((handler) => handler(newStep));
+        this.printer.printStepUpdated(newStep);
+        return true;
+    }
+    createStep(step, options = {}) {
+        if (!this.isValidStep(step)) {
+            return false;
+        }
+        this.stepsMap[step.filePath] = step;
+        if (step.config.type === 'noop') {
+            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);
+            }
+        }
+        if (!options.disableTypeCreation) {
+            this.saveTypes();
+        }
+        this.stepHandlers['step-created'].forEach((handler) => handler(step));
+        this.printer.printStepCreated(step);
+        return true;
+    }
+    deleteStep(step, options = {}) {
+        // 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);
+            }
+        }
+        if (!options.disableTypeCreation) {
+            this.saveTypes();
+        }
+        this.stepHandlers['step-removed'].forEach((handler) => handler(step));
+        this.printer.printStepRemoved(step);
+    }
+    createFactoryWrapper(stream, factory) {
+        return () => {
+            const streamFactory = this.streamWrapper //
+                ? this.streamWrapper(stream.config.name, factory)
+                : factory;
+            return streamFactory();
+        };
+    }
+    createStream(stream, options = {}) {
+        this.streams[stream.config.name] = stream;
+        this.streamHandlers['stream-created'].forEach((handler) => handler(stream));
+        let factory;
+        if (stream.config.baseConfig.storageType === 'state') {
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+        }
+        else {
+            factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
+        }
+        stream.config.baseConfig = { storageType: 'custom', factory };
+        if (!stream.hidden) {
+            this.printer.printStreamCreated(stream);
+            if (!options.disableTypeCreation) {
+                this.saveTypes();
+            }
+        }
+        return factory;
+    }
+    deleteStream(stream, options = {}) {
+        Object.entries(this.streams).forEach(([streamName, { filePath }]) => {
+            if (stream.filePath === filePath) {
+                delete this.streams[streamName];
+            }
+        });
+        this.streamHandlers['stream-removed'].forEach((handler) => handler(stream));
+        if (!stream.hidden) {
+            this.printer.printStreamRemoved(stream);
+            if (!options.disableTypeCreation) {
+                this.saveTypes();
+            }
+        }
+    }
+    updateStream(oldStream, stream, options = {}) {
+        if (oldStream.config.name !== stream.config.name) {
+            delete this.streams[oldStream.config.name];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let factory;
+        if (stream.config.baseConfig.storageType === 'state') {
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+        }
+        else {
+            factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
+        }
+        stream.config.baseConfig = { storageType: 'custom', factory };
+        this.streams[stream.config.name] = stream;
+        this.streamHandlers['stream-updated'].forEach((handler) => handler(stream));
+        if (!stream.hidden) {
+            this.printer.printStreamUpdated(stream);
+            if (!options.disableTypeCreation) {
+                this.saveTypes();
+            }
+        }
+    }
+    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-factory.d.ts

@@ -0,0 +1,15 @@
+import { Logger } from './logger';
+import { StateStream } from './state-stream';
+import { Log } from './streams/logs-stream';
+type CreateLogger = {
+    traceId: string;
+    flows?: string[];
+    stepName: string;
+};
+export declare class LoggerFactory {
+    private readonly isVerbose;
+    private readonly logStream;
+    constructor(isVerbose: boolean, logStream: StateStream<Log>);
+    create({ stepName, traceId, flows }: CreateLogger): Logger;
+}
+export {};

package/dist/src/logger-factory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const logger_1 = require("./logger");
+class LoggerFactory {
+    constructor(isVerbose, logStream) {
+        this.isVerbose = isVerbose;
+        this.logStream = logStream;
+    }
+    create({ stepName, traceId, flows }) {
+        return new logger_1.Logger(traceId, flows, stepName, this.isVerbose, this.logStream);
+    }
+}
+exports.LoggerFactory = LoggerFactory;