@motiadev/core 0.2.1-beta.45 → 0.2.1-beta.46

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { createStateAdapter } from './src/state/create-state-adapter';
 export { setupCronHandlers, CronManager } from './src/cron-handler';
 export { isApiStep, isCronStep, isEventStep, isNoopStep } from './src/guards';
 export { LockedData } from './src/locked-data';
-export { getStepConfig } from './src/get-step-config';
+export { getStepConfig, getStreamConfig } from './src/get-step-config';
 export { StateAdapter } from './src/state/state-adapter';
 export { createMermaidGenerator } from './src/mermaid-generator';
+export { StateStream } from './src/state-stream';

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.createMermaidGenerator = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
+exports.StateStream = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
 var server_1 = require("./src/server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
@@ -38,5 +38,8 @@ var locked_data_1 = require("./src/locked-data");
 Object.defineProperty(exports, "LockedData", { enumerable: true, get: function () { return locked_data_1.LockedData; } });
 var get_step_config_1 = require("./src/get-step-config");
 Object.defineProperty(exports, "getStepConfig", { enumerable: true, get: function () { return get_step_config_1.getStepConfig; } });
+Object.defineProperty(exports, "getStreamConfig", { enumerable: true, get: function () { return get_step_config_1.getStreamConfig; } });
 var mermaid_generator_1 = require("./src/mermaid-generator");
 Object.defineProperty(exports, "createMermaidGenerator", { enumerable: true, get: function () { return mermaid_generator_1.createMermaidGenerator; } });
+var state_stream_1 = require("./src/state-stream");
+Object.defineProperty(exports, "StateStream", { enumerable: true, get: function () { return state_stream_1.StateStream; } });

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

@@ -1,12 +1,14 @@
-import { EventManager, InternalStateManager, Step } from './types';
 import { BaseLogger } from './logger';
 import { Printer } from './printer';
+import { EventManager, InternalStateManager, Step } from './types';
+import { LockedData } from './locked-data';
 type CallStepFileOptions = {
     step: Step;
     logger: BaseLogger;
     eventManager: EventManager;
     state: InternalStateManager;
     traceId: string;
+    lockedData: LockedData;
     printer: Printer;
     data?: any;
     contextInFirstArg: boolean;

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

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callStepFile = void 0;
-const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
+const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
 const utils_1 = require("./utils");
 const getLanguageBasedRunner = (stepFilePath = '') => {
     const isPython = stepFilePath.endsWith('.py');
@@ -31,17 +31,32 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
 const callStepFile = (options) => {
-    const { step, printer, eventManager, state, traceId, data, contextInFirstArg } = options;
+    const { step, printer, eventManager, state, traceId, data, contextInFirstArg, lockedData } = options;
     const logger = options.logger.child({ step: step.config.name });
     const flows = step.config.flows;
     return new Promise((resolve, reject) => {
-        const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg });
+        const streamConfig = lockedData.getStreams();
+        const streams = Object.keys(streamConfig).map((name) => ({ name }));
+        const jsonData = JSON.stringify({ data, flows, traceId, contextInFirstArg, streams });
         const { runner, command, args } = getLanguageBasedRunner(step.filePath);
         let result;
         const child = (0, child_process_1.spawn)(command, [...args, runner, step.filePath, jsonData], {
             stdio: [undefined, undefined, undefined, 'ipc'],
         });
+        const emit = async (input) => {
+            if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
+                return printer.printInvalidEmit(step, input.topic);
+            }
+            return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
+        };
         const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
+        Object.entries(streamConfig).forEach(([name, streamFactory]) => {
+            const stateStream = streamFactory(state);
+            rpcProcessor.handler(`streams.${name}.get`, (input) => stateStream.get(input.id));
+            rpcProcessor.handler(`streams.${name}.update`, (input) => stateStream.update(input.id, input.data));
+            rpcProcessor.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.id));
+            rpcProcessor.handler(`streams.${name}.create`, (input) => stateStream.create(input.id, input.data));
+        });
         rpcProcessor.handler('close', async () => child.kill());
         rpcProcessor.handler('log', async (input) => logger.log(input));
         rpcProcessor.handler('state.get', (input) => state.get(input.traceId, input.key));
@@ -51,12 +66,7 @@ const callStepFile = (options) => {
         rpcProcessor.handler('result', async (input) => {
             result = input;
         });
-        rpcProcessor.handler('emit', async (input) => {
-            if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
-                return printer.printInvalidEmit(step, input.topic);
-            }
-            return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
-        });
+        rpcProcessor.handler('emit', emit);
         rpcProcessor.init();
         child.stdout?.on('data', (data) => {
             try {

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

@@ -1,13 +1,12 @@
+import { LoggerFactory } from './logger-factory';
 import { LockedData } from './locked-data';
-import { StateAdapter } from './state/state-adapter';
-import { CronConfig, EventManager, Step } from './types';
-import { LoggerFactory } from './LoggerFactory';
+import { CronConfig, EventManager, InternalStateManager, Step } from './types';
 export type CronManager = {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;
 };
-export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, loggerFactory: LoggerFactory) => {
+export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, state: InternalStateManager, loggerFactory: LoggerFactory) => {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;

package/dist/src/cron-handler.js

@@ -36,8 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCronHandlers = void 0;
 const cron = __importStar(require("node-cron"));
 const call_step_file_1 = require("./call-step-file");
-const logger_1 = require("./logger");
 const generate_trace_id_1 = require("./generate-trace-id");
+const logger_1 = require("./logger");
 const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
     const cronJobs = new Map();
     const printer = lockedData.printer;
@@ -62,6 +62,7 @@ const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
             try {
                 await (0, call_step_file_1.callStepFile)({
                     contextInFirstArg: true,
+                    lockedData,
                     step,
                     eventManager,
                     printer,

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

@@ -1,6 +1,6 @@
 import { Express } from 'express';
-import { Emit } from './types';
 import { LockedData } from './locked-data';
+import { Emit, InternalStateManager, Step } from './types';
 type FlowListResponse = {
     id: string;
     name: string;
@@ -37,6 +37,6 @@ type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];
     edges: FlowEdge[];
 };
-export declare const flowsEndpoint: (lockedData: LockedData, app: Express) => void;
-export declare const generateFlowsList: (lockedData: LockedData) => FlowResponse[];
+export declare const flowsEndpoint: (lockedData: LockedData, app: Express, state: InternalStateManager) => void;
+export declare const generateFlow: (flowId: string, flowSteps: Step[]) => FlowResponse;
 export {};

package/dist/src/flows-endpoint.js

@@ -3,34 +3,39 @@ 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 path_1 = __importDefault(require("path"));
-const guards_1 = require("./guards");
+const zod_1 = require("zod");
 const get_step_language_1 = require("./get-step-language");
-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 })));
-    });
+const guards_1 = require("./guards");
+const flows_stream_1 = require("./streams/flows-stream");
+const flowsEndpoint = (lockedData, app, state) => {
+    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 })(state);
+    lockedData.on('flow-created', (flow) => flowsStream.create(flow, { id: flow, name: flow }));
+    lockedData.on('flow-updated', (flow) => flowsStream.update(flow, { id: flow, name: flow }));
+    lockedData.on('flow-removed', (flow) => flowsStream.delete(flow));
     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);
+        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 = (lockedData) => {
-    return Object.entries(lockedData.flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
-};
-exports.generateFlowsList = generateFlowsList;
 // Helper functions
 const getNodeComponentPath = (filePath) => {
     const filePathWithoutExtension = filePath.replace(/\.[^/.]+$/, '');
@@ -154,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/get-step-config.d.ts

@@ -1,2 +1,3 @@
-import { StepConfig } from './types';
+import { StateStreamConfig, StepConfig } from './types';
 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

@@ -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.getStepConfig = void 0;
+exports.getStreamConfig = exports.getStepConfig = void 0;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
@@ -31,25 +31,11 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
 };
 const getStepConfig = (file) => {
     const { runner, command, args } = getLanguageBasedRunner(file);
-    const isWindows = process.platform === 'win32';
     return new Promise((resolve, reject) => {
         let config = null;
         const child = (0, child_process_1.spawn)(command, [...args, runner, file], {
-            stdio: isWindows
-                ? ['inherit', 'pipe', 'inherit', 'ipc'] // On Windows, capture stdout
-                : ['inherit', 'inherit', 'inherit', 'ipc'] // Original config for Unix
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
         });
-        // On Windows, we need to listen for stdout data
-        if (isWindows) {
-            child.stdout?.on('data', (data) => {
-                const message = JSON.parse(data.toString());
-                logger_1.globalLogger.debug('[Config] Read config', { config: message });
-                config = message;
-                resolve(config);
-                child.kill();
-            });
-        }
-        // Original IPC message handler
         child.on('message', (message) => {
             logger_1.globalLogger.debug('[Config] Read config', { config: message });
             config = message;
@@ -78,3 +64,38 @@ const getStepConfig = (file) => {
     });
 };
 exports.getStepConfig = getStepConfig;
+const getStreamConfig = (file) => {
+    const { runner, command, args } = getLanguageBasedRunner(file);
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const child = (0, child_process_1.spawn)(command, [...args, runner, file], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        });
+        child.on('message', (message) => {
+            logger_1.globalLogger.debug('[Config] Read config', { config: message });
+            config = message;
+            resolve(config);
+            child.kill(); // we can kill the child process since we already received the message
+        });
+        child.on('close', (code) => {
+            if (config) {
+                return; // Config was already resolved
+            }
+            else if (code !== 0) {
+                reject(`Process exited with code ${code}`);
+            }
+            else if (!config) {
+                reject(`No config found for file ${file}`);
+            }
+        });
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(`Executable ${command} not found`);
+            }
+            else {
+                reject(error);
+            }
+        });
+    });
+};
+exports.getStreamConfig = getStreamConfig;

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

@@ -1,7 +1,10 @@
-import { ApiRouteConfig, CronConfig, EventConfig, Flow, Step } from './types';
 import { Printer } from './printer';
+import { StateStreamFactory } from './state-stream';
+import { ApiRouteConfig, BaseStateStreamData, CronConfig, EventConfig, Flow, Step, Stream } from './types';
 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 extends BaseStateStreamData> = (streamName: string, factory: StateStreamFactory<TData>) => StateStreamFactory<TData>;
 export declare class LockedData {
     readonly baseDir: string;
     flows: Record<string, Flow>;
@@ -11,15 +14,22 @@ export declare class LockedData {
     private stepsMap;
     private handlers;
     private stepHandlers;
+    private streamHandlers;
+    private streams;
+    private streamWrapper?;
     constructor(baseDir: string);
+    applyStreamWrapper<TData extends BaseStateStreamData>(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;
@@ -29,6 +39,16 @@ export declare class LockedData {
     deleteStep(step: Step, options?: {
         disableTypeCreation?: boolean;
     }): void;
+    private createFactoryWrapper;
+    createStream<TData extends BaseStateStreamData>(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;

package/dist/src/locked-data.js

@@ -8,6 +8,7 @@ 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 {
@@ -28,10 +29,20 @@ class LockedData {
             'step-removed': [],
             'step-updated': [],
         };
+        this.streamHandlers = {
+            'stream-created': [],
+            'stream-removed': [],
+            'stream-updated': [],
+        };
+        this.streams = {};
+    }
+    applyStreamWrapper(streamWrapper) {
+        this.streamWrapper = streamWrapper;
     }
     saveTypes() {
         const types = (0, generate_types_1.generateTypesFromSteps)(this.activeSteps, this.printer);
-        const typesString = (0, generate_types_1.generateTypesString)(types);
+        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) {
@@ -40,6 +51,9 @@ class LockedData {
     onStep(event, handler) {
         this.stepHandlers[event].push(handler);
     }
+    onStream(event, handler) {
+        this.streamHandlers[event].push(handler);
+    }
     eventSteps() {
         return this.activeSteps.filter(guards_1.isEventStep);
     }
@@ -55,6 +69,22 @@ class LockedData {
     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);
@@ -154,6 +184,71 @@ class LockedData {
         this.stepHandlers['step-removed'].forEach((handler) => handler(step));
         this.printer.printStepRemoved(step);
     }
+    createFactoryWrapper(stream, factory) {
+        return (state) => {
+            const streamFactory = this.streamWrapper //
+                ? this.streamWrapper(stream.config.name, factory)
+                : factory;
+            return streamFactory(state);
+        };
+    }
+    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') {
+            const property = stream.config.baseConfig.property;
+            factory = this.createFactoryWrapper(stream, (state) => new state_stream_1.StateStream(state, property));
+        }
+        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, stream]) => {
+            if (stream.filePath === stream.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') {
+            const property = stream.config.baseConfig.property;
+            factory = this.createFactoryWrapper(stream, (state) => new state_stream_1.StateStream(state, property));
+        }
+        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;

package/dist/src/{LoggerFactory.d.ts → logger-factory.d.ts}

@@ -1,5 +1,6 @@
-import { Server } from 'socket.io';
 import { Logger } from './logger';
+import { Log } from './streams/logs-stream';
+import { IStateStream } from './types';
 type CreateLogger = {
     traceId: string;
     flows?: string[];
@@ -7,8 +8,8 @@ type CreateLogger = {
 };
 export declare class LoggerFactory {
     private readonly isVerbose;
-    private readonly socketServer;
-    constructor(isVerbose: boolean, socketServer: Server);
+    private readonly logStream;
+    constructor(isVerbose: boolean, logStream: IStateStream<Log>);
     create({ stepName, traceId, flows }: CreateLogger): Logger;
 }
 export {};

package/dist/src/{LoggerFactory.js → logger-factory.js}

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

package/dist/src/logger.d.ts

@@ -1,4 +1,5 @@
-import { Server } from 'socket.io';
+import { Log } from './streams/logs-stream';
+import { IStateStream } from './types';
 export declare class BaseLogger {
     readonly isVerbose: boolean;
     private readonly meta;
@@ -15,9 +16,9 @@ export declare class Logger extends BaseLogger {
     private readonly traceId;
     private readonly flows;
     private readonly step;
-    private readonly socketServer?;
+    private readonly logStream?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, socketServer?: Server | undefined);
+    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: IStateStream<Log> | undefined);
     child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;

package/dist/src/logger.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalLogger = exports.Logger = exports.BaseLogger = void 0;
+const crypto_1 = require("crypto");
 const pretty_print_1 = require("./pretty-print");
 const logLevel = process.env.LOG_LEVEL ?? 'info';
 const isDebugEnabled = logLevel === 'debug';
@@ -44,12 +45,12 @@ class BaseLogger {
 }
 exports.BaseLogger = BaseLogger;
 class Logger extends BaseLogger {
-    constructor(traceId, flows, step, isVerbose, socketServer) {
+    constructor(traceId, flows, step, isVerbose, logStream) {
         super(isVerbose, { traceId, flows, step });
         this.traceId = traceId;
         this.flows = flows;
         this.step = step;
-        this.socketServer = socketServer;
+        this.logStream = logStream;
         this.info = (message, args) => {
             super.info(message, args);
             this.emitLog('info', message, args);
@@ -69,19 +70,21 @@ class Logger extends BaseLogger {
             this.emitLog('warn', message, args);
         };
         this.emitLog = (level, msg, args) => {
-            socketServer?.emit('log', {
+            const id = (0, crypto_1.randomUUID)();
+            this.logStream?.create(id, {
+                id,
                 step: this.step,
                 ...(args ?? {}),
                 level,
                 time: Date.now(),
                 msg,
                 traceId: this.traceId,
-                flows: this.flows,
+                flows: this.flows ?? [],
             });
         };
     }
     child(meta = {}) {
-        return new Logger(this.traceId, this.flows, meta.step, this.isVerbose, this.socketServer);
+        return new Logger(this.traceId, this.flows, meta.step, this.isVerbose, this.logStream);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(message) {

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

@@ -35,6 +35,9 @@ async function getConfig(filePath) {
                 }
             }
         }
+        if (isZodSchema(module.config.schema)) {
+            module.config.schema = (0, zod_to_json_schema_1.default)(module.config.schema);
+        }
         process.send?.(module.config);
         process.exit(0);
     }

package/dist/src/node/node-runner.js

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("./logger");
-const rpc_state_manager_1 = require("./rpc-state-manager");
-const rpc_1 = require("./rpc");
 const middleware_compose_1 = require("./middleware-compose");
+const rpc_1 = require("./rpc");
+const rpc_state_manager_1 = require("./rpc-state-manager");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 require('dotenv').config();
 // Add ts-node registration before dynamic imports
@@ -37,7 +37,19 @@ async function runTypescriptModule(filePath, event) {
         const logger = new logger_1.Logger(traceId, flows, sender);
         const state = new rpc_state_manager_1.RpcStateManager(sender);
         const emit = async (data) => sender.send('emit', data);
-        const context = { traceId, flows, logger, state, emit };
+        const streamsConfig = event.streams;
+        const streams = (streamsConfig ?? []).reduce((acc, streams) => {
+            acc[streams.name] = {
+                get: (id) => sender.send(`streams.${streams.name}.get`, { id }),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                update: (id, data) => sender.send(`streams.${streams.name}.update`, { id, data }),
+                delete: (id) => sender.send(`streams.${streams.name}.delete`, { id }),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                create: (id, data) => sender.send(`streams.${streams.name}.create`, { id, data }),
+            };
+            return acc;
+        }, {});
+        const context = { traceId, flows, logger, state, emit, streams };
         sender.init();
         const middlewares = Array.isArray(module.config.middleware) ? module.config.middleware : [];
         const composedMiddleware = (0, middleware_compose_1.composeMiddleware)(...middlewares);

package/dist/src/node/rpc-state-manager.d.ts

@@ -4,7 +4,7 @@ export declare class RpcStateManager implements InternalStateManager {
     private readonly sender;
     constructor(sender: RpcSender);
     get<T>(traceId: string, key: string): Promise<T>;
-    set<T>(traceId: string, key: string, value: T): Promise<void>;
-    delete(traceId: string, key: string): Promise<void>;
+    set<T>(traceId: string, key: string, value: T): Promise<T>;
+    delete<T>(traceId: string, key: string): Promise<T | null>;
     clear(traceId: string): Promise<void>;
 }