@motiadev/core 0.13.2-beta.164-110989 → 0.14.0-beta.164

package/dist/src/server.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+const body_parser_1 = __importDefault(require("body-parser"));
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const utils_1 = require("./analytics/utils");
+const call_step_file_1 = require("./call-step-file");
+const cron_handler_1 = require("./cron-handler");
+const analytics_endpoint_1 = require("./endpoints/analytics-endpoint");
+const flows_config_endpoint_1 = require("./endpoints/flows-config-endpoint");
+const flows_endpoint_1 = require("./endpoints/flows-endpoint");
+const step_endpoint_1 = require("./endpoints/step-endpoint");
+const generate_trace_id_1 = require("./generate-trace-id");
+const guards_1 = require("./guards");
+const logger_1 = require("./logger");
+const logger_factory_1 = require("./logger-factory");
+const tracer_1 = require("./observability/tracer");
+const printer_1 = require("./printer");
+const run_stream_can_access_1 = require("./run-stream-can-access");
+const socket_server_1 = require("./socket-server");
+const step_handlers_1 = require("./step-handlers");
+const steps_1 = require("./steps");
+const redis_logs_stream_1 = require("./streams/redis-logs-stream");
+const createServer = (lockedData, state, config, adapters, configureApp) => {
+    const printer = config.printer ?? new printer_1.Printer(process.cwd());
+    const app = (0, express_1.default)();
+    if (configureApp) {
+        configureApp(app);
+    }
+    const server = http_1.default.createServer(app);
+    const streamAuth = lockedData.getStreamAuthConfig();
+    const authorizeSubscription = async (subscription, authContext) => {
+        const stream = lockedData.getStreamByName(subscription.streamName);
+        if (!stream) {
+            throw new Error(`Stream ${subscription.streamName} not found`);
+        }
+        const accessContext = { groupId: subscription.groupId, id: subscription.id };
+        if (typeof stream.config.canAccess === 'function') {
+            try {
+                const allowed = await stream.config.canAccess(accessContext, authContext);
+                return Boolean(allowed);
+            }
+            catch (error) {
+                logger_1.globalLogger.error('[Streams] Inline canAccess evaluation failed', {
+                    streamName: subscription.streamName,
+                    groupId: subscription.groupId,
+                    error,
+                });
+                return false;
+            }
+        }
+        // @ts-expect-error - internal property, not part of the public API
+        if (!stream.config.__motia_hasCanAccess) {
+            logger_1.globalLogger.debug('[Streams] No canAccess function found, allowing access', {
+                streamName: subscription.streamName,
+                groupId: subscription.groupId,
+            });
+            return true;
+        }
+        try {
+            const allowed = await (0, run_stream_can_access_1.runStreamCanAccess)({
+                file: stream.filePath,
+                subscription: accessContext,
+                authContext,
+                projectRoot: lockedData.baseDir,
+            });
+            return Boolean(allowed);
+        }
+        catch (error) {
+            logger_1.globalLogger.error('[Streams] canAccess evaluation failed', {
+                streamName: subscription.streamName,
+                groupId: subscription.groupId,
+                error,
+            });
+            return false;
+        }
+    };
+    const { pushEvent, socketServer } = (0, socket_server_1.createSocketServer)({
+        server,
+        authenticate: streamAuth?.authenticate,
+        authorize: authorizeSubscription,
+        onJoin: async (streamName, groupId, id) => {
+            const streams = lockedData.getStreams();
+            const stream = streams[streamName];
+            if (stream) {
+                const result = await stream().get(groupId, id);
+                delete result?.__motia; // deleting because we don't need it in the socket
+                return result;
+            }
+        },
+        onJoinGroup: async (streamName, groupId) => {
+            const streams = lockedData.getStreams();
+            const stream = streams[streamName];
+            if (stream) {
+                const result = stream ? await stream().getGroup(groupId) : [];
+                return result.map(({ __motia, ...rest }) => rest);
+            }
+        },
+    });
+    lockedData.applyStreamWrapper((streamName, stream) => {
+        return () => {
+            const main = stream();
+            const wrapObject = (groupId, id, object) => {
+                if (!object) {
+                    return null;
+                }
+                return {
+                    ...object,
+                    __motia: { type: 'state-stream', streamName, groupId, id },
+                };
+            };
+            const mainGetGroup = main.getGroup;
+            const mainGet = main.get;
+            const mainSet = main.set;
+            const mainDelete = main.delete;
+            main.send = async (channel, event) => {
+                pushEvent({ streamName, ...channel, event: { type: 'event', event } });
+            };
+            main.getGroup = async (groupId) => {
+                const result = await mainGetGroup.apply(main, [groupId]);
+                return result.map((object) => wrapObject(groupId, object.id, object));
+            };
+            main.get = async (groupId, id) => {
+                const result = await mainGet.apply(main, [groupId, id]);
+                return wrapObject(groupId, id, result);
+            };
+            main.set = async (groupId, id, data) => {
+                if (!data) {
+                    return null;
+                }
+                const exists = await main.get(groupId, id);
+                const updated = await mainSet.apply(main, [groupId, id, data]);
+                const result = updated ?? data;
+                const wrappedResult = wrapObject(groupId, id, result);
+                const type = exists ? 'update' : 'create';
+                pushEvent({ streamName, groupId, id, event: { type, data: result } });
+                return wrappedResult;
+            };
+            main.delete = async (groupId, id) => {
+                const result = await mainDelete.apply(main, [groupId, id]);
+                pushEvent({ streamName, groupId, id, event: { type: 'delete', data: result } });
+                return wrapObject(groupId, id, result);
+            };
+            return main;
+        };
+    });
+    const logStream = lockedData.createStream({
+        filePath: '__motia.logs',
+        hidden: true,
+        config: {
+            name: '__motia.logs',
+            baseConfig: {
+                storageType: 'custom',
+                factory: () => {
+                    if (!lockedData.redisClient) {
+                        throw new Error('Redis client is required for server operation. Please provide a redisClient when creating LockedData.');
+                    }
+                    return new redis_logs_stream_1.RedisLogsStream(lockedData.redisClient);
+                },
+            },
+            schema: null,
+        },
+    })();
+    const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
+    const loggerFactory = new logger_factory_1.BaseLoggerFactory(config.isVerbose, logStream);
+    const tracerFactory = (0, tracer_1.createTracerFactory)(lockedData);
+    const motia = {
+        loggerFactory,
+        eventAdapter: adapters.eventAdapter,
+        state,
+        lockedData,
+        printer,
+        tracerFactory,
+        app,
+        stateAdapter: state,
+    };
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(motia, adapters?.cronAdapter);
+    const motiaEventManager = (0, step_handlers_1.createStepHandlers)(motia, adapters.eventAdapter);
+    const asyncHandler = (step) => {
+        return async (req, res) => {
+            const traceId = (0, generate_trace_id_1.generateTraceId)();
+            const { name: stepName, flows } = step.config;
+            const logger = loggerFactory.create({ traceId, flows, stepName });
+            logger.debug('[API] Received request, processing step', { path: req.path });
+            const rawBody = req.rawBody || '';
+            const data = {
+                body: req.body,
+                headers: req.headers,
+                pathParams: req.params,
+                queryParams: req.query,
+                rawBody,
+            };
+            try {
+                let result;
+                if ('handler' in step && typeof step.handler === 'function') {
+                    const context = {
+                        traceId,
+                        flows,
+                        state: state,
+                        emit: async (event) => {
+                            const eventObj = {
+                                ...event,
+                                traceId,
+                                flows,
+                                logger,
+                                tracer: null,
+                            };
+                            await adapters.eventAdapter.emit(eventObj);
+                        },
+                        logger,
+                        streams: lockedData.getStreams(),
+                    };
+                    result = await step.handler(data, context);
+                }
+                else {
+                    const tracer = await motia.tracerFactory.createTracer(traceId, step, logger);
+                    result = await (0, call_step_file_1.callStepFile)({ data, step, logger, tracer, traceId }, motia);
+                }
+                (0, utils_1.trackEvent)('api_call_success', { stepName });
+                if (!result) {
+                    console.log('no result');
+                    res.status(500).json({ error: 'Internal server error' });
+                    return;
+                }
+                if (result.headers) {
+                    Object.entries(result.headers).forEach(([key, value]) => res.setHeader(key, value));
+                }
+                res.status(result.status);
+                // Handle different body types
+                if (Buffer.isBuffer(result.body) || typeof result.body === 'string') {
+                    res.send(result.body);
+                }
+                else {
+                    res.json(result.body);
+                }
+            }
+            catch (error) {
+                (0, utils_1.trackEvent)('api_call_error', {
+                    stepName,
+                    traceId,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+                logger.error('[API] Internal server error', { error });
+                console.log(error);
+                res.status(500).json({ error: 'Internal server error' });
+            }
+        };
+    };
+    app.use((req, _, next) => {
+        req.rawBody = '';
+        next();
+    });
+    app.use(body_parser_1.default.json({
+        limit: '1gb',
+        verify: (req, _, buf, encoding) => {
+            req.rawBody = buf.toString(encoding || 'utf8');
+        },
+    }));
+    app.use(body_parser_1.default.urlencoded({
+        extended: true,
+        limit: '1gb',
+        verify: (req, _, buf, encoding) => {
+            req.rawBody = buf.toString(encoding || 'utf8');
+        },
+    }));
+    app.use(body_parser_1.default.text({
+        limit: '1gb',
+        verify: (req, _, buf, encoding) => {
+            req.rawBody = buf.toString(encoding || 'utf8');
+        },
+    }));
+    const router = express_1.default.Router();
+    const addRoute = (step) => {
+        const { method, path } = step.config;
+        logger_1.globalLogger.debug('[API] Registering route', step.config);
+        const handler = asyncHandler(step);
+        const methods = {
+            GET: () => router.get(path, handler),
+            POST: () => router.post(path, handler),
+            PUT: () => router.put(path, handler),
+            DELETE: () => router.delete(path, handler),
+            PATCH: () => router.patch(path, handler),
+            OPTIONS: () => router.options(path, handler),
+            HEAD: () => router.head(path, handler),
+        };
+        const methodHandler = methods[method];
+        if (!methodHandler) {
+            throw new Error(`Unsupported method: ${method}`);
+        }
+        methodHandler();
+    };
+    const removeRoute = (step) => {
+        const { path, method } = step.config;
+        const routerStack = router.stack;
+        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.options('*', (_req, res) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Max-Age', '600');
+        res.header('Access-Control-Allow-Credentials', 'true');
+        res.header('Access-Control-Allow-Private-Network', 'true');
+        res.status(204).end();
+    });
+    app.use((_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', '*');
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Max-Age', '600');
+        res.header('Access-Control-Allow-Credentials', 'true');
+        res.header('Access-Control-Allow-Private-Network', 'true');
+        next();
+    });
+    app.use(router);
+    (0, flows_endpoint_1.flowsEndpoint)(lockedData);
+    (0, flows_config_endpoint_1.flowsConfigEndpoint)(app, process.cwd(), lockedData);
+    (0, analytics_endpoint_1.analyticsEndpoint)(app, process.cwd());
+    (0, step_endpoint_1.stepEndpoint)(app, lockedData);
+    server.on('error', (error) => {
+        console.error('Server error:', error);
+    });
+    const close = async () => {
+        await cronManager.close();
+        socketServer.close();
+        if (adapters?.eventAdapter) {
+            await adapters.eventAdapter.shutdown();
+        }
+    };
+    return { app, server, socketServer, close, removeRoute, addRoute, cronManager, motiaEventManager, motia, printer };
+};
+exports.createServer = createServer;

package/dist/src/socket-server/helpers.d.ts

@@ -0,0 +1,53 @@
+import type { WebSocket } from 'ws';
+export type BaseMessage = {
+    streamName: string;
+    groupId: string;
+    id?: string;
+};
+export type JoinMessage = BaseMessage & {
+    subscriptionId: string;
+};
+export type StreamEvent<TData> = {
+    type: 'sync';
+    data: TData;
+} | {
+    type: 'create';
+    data: TData;
+} | {
+    type: 'update';
+    data: TData;
+} | {
+    type: 'delete';
+    data: TData;
+} | {
+    type: 'event';
+    event: {
+        type: string;
+        data: unknown;
+    };
+};
+export type EventMessage<TData> = BaseMessage & {
+    timestamp: number;
+    event: StreamEvent<TData>;
+};
+export declare const ACCESS_DENIED_CODE = "STREAM_ACCESS_DENIED";
+export declare const getRoom: (message: BaseMessage) => string;
+export declare const createErrorMessage: (data: BaseMessage, error: Error) => {
+    timestamp: number;
+    streamName: string;
+    groupId: string;
+    id: string | undefined;
+    event: {
+        type: string;
+        event: {
+            type: string;
+            data: {
+                code: string;
+                message: string;
+            };
+        };
+    };
+};
+export declare const sendAccessDenied: (socket: WebSocket, data: BaseMessage) => void;
+export declare const sendError: (socket: WebSocket, data: BaseMessage, error: Error) => void;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/src/socket-server/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/socket-server/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAA;AAEnC,MAAM,MAAM,WAAW,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAC9E,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAAA;AAClE,MAAM,MAAM,WAAW,CAAC,KAAK,IACzB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC7B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,CAAA;AAC7D,MAAM,MAAM,YAAY,CAAC,KAAK,IAAI,WAAW,GAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,CAAA;CAAE,CAAA;AAEhG,eAAO,MAAM,kBAAkB,yBAAyB,CAAA;AAExD,eAAO,MAAM,OAAO,GAAI,SAAS,WAAW,KAAG,MAE9C,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,WAAW,EAAE,OAAO,KAAK;;;;;;;;;;;;;;;CAQjE,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,QAAQ,SAAS,EAAE,MAAM,WAAW,SAGpE,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,QAAQ,SAAS,EAAE,MAAM,WAAW,EAAE,OAAO,KAAK,SAG3E,CAAA"}

package/dist/src/socket-server/helpers.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendError = exports.sendAccessDenied = exports.createErrorMessage = exports.getRoom = exports.ACCESS_DENIED_CODE = void 0;
+exports.ACCESS_DENIED_CODE = 'STREAM_ACCESS_DENIED';
+const getRoom = (message) => {
+    return message.id ? `${message.streamName}:id:${message.id}` : `${message.streamName}:group-id:${message.groupId}`;
+};
+exports.getRoom = getRoom;
+const createErrorMessage = (data, error) => {
+    return {
+        timestamp: Date.now(),
+        streamName: data.streamName,
+        groupId: data.groupId,
+        id: data.id,
+        event: { type: 'event', event: { type: 'error', data: { code: exports.ACCESS_DENIED_CODE, message: error.message } } },
+    };
+};
+exports.createErrorMessage = createErrorMessage;
+const sendAccessDenied = (socket, data) => {
+    const resultMessage = (0, exports.createErrorMessage)(data, new Error('Access denied'));
+    socket.send(JSON.stringify(resultMessage));
+};
+exports.sendAccessDenied = sendAccessDenied;
+const sendError = (socket, data, error) => {
+    const resultMessage = (0, exports.createErrorMessage)(data, error);
+    socket.send(JSON.stringify(resultMessage));
+};
+exports.sendError = sendError;

package/dist/src/socket-server.d.ts

@@ -0,0 +1,21 @@
+import type { Server } from 'http';
+import { Server as WsServer } from 'ws';
+import { type EventMessage } from './socket-server/helpers';
+import type { StreamAuthRequest } from './types/app-config-types';
+type Props = {
+    server: Server;
+    onJoin: <TData>(streamName: string, groupId: string, id: string) => Promise<TData>;
+    onJoinGroup: <TData>(streamName: string, groupId: string) => Promise<TData[] | undefined>;
+    authenticate?: (request: StreamAuthRequest) => Promise<unknown | null> | unknown | null;
+    authorize?: (subscription: {
+        streamName: string;
+        groupId: string;
+        id?: string;
+    }, authContext?: unknown) => Promise<boolean> | boolean;
+};
+export declare const createSocketServer: ({ server, onJoin, onJoinGroup, authenticate, authorize }: Props) => {
+    pushEvent: <TData>(message: Omit<EventMessage<TData>, "timestamp">) => void;
+    socketServer: WsServer<typeof import("ws"), typeof import("http").IncomingMessage>;
+};
+export {};
+//# sourceMappingURL=socket-server.d.ts.map

package/dist/src/socket-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-server.d.ts","sourceRoot":"","sources":["../../src/socket-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAClC,OAAO,EAAkB,MAAM,IAAI,QAAQ,EAAE,MAAM,IAAI,CAAA;AAEvD,OAAO,EAEL,KAAK,YAAY,EAKlB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAIjE,KAAK,KAAK,GAAG;IACX,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAA;IAClF,WAAW,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,EAAE,GAAG,SAAS,CAAC,CAAA;IACzF,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,OAAO,GAAG,IAAI,CAAA;IACvF,SAAS,CAAC,EAAE,CACV,YAAY,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,EAClE,WAAW,CAAC,EAAE,OAAO,KAClB,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAA;CAChC,CAAA;AAGD,eAAO,MAAM,kBAAkB,GAAI,0DAA0D,KAAK;gBAgH7E,KAAK,WAAW,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;;CAuB1E,CAAA"}

package/dist/src/socket-server.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSocketServer = void 0;
+const ws_1 = require("ws");
+const logger_1 = require("./logger");
+const helpers_1 = require("./socket-server/helpers");
+const AUTH_ERROR_CODE = 401;
+const createSocketServer = ({ server, onJoin, onJoinGroup, authenticate, authorize }) => {
+    const socketServer = new ws_1.Server({
+        server,
+        verifyClient: async (info, callback) => {
+            if (authenticate) {
+                try {
+                    const authRequest = {
+                        headers: info.req.headers,
+                        url: info.req.url,
+                    };
+                    info.req.authContext = await authenticate(authRequest);
+                    callback(true);
+                }
+                catch {
+                    logger_1.globalLogger.debug('[Socket Server] Authentication failed');
+                    callback(false, AUTH_ERROR_CODE, 'Authentication failed');
+                }
+            }
+            else {
+                callback(true);
+            }
+        },
+    });
+    const rooms = {};
+    const subscriptions = new Map();
+    const authContexts = new Map();
+    const isAuthorized = async (socket, data) => {
+        if (!authorize) {
+            return true;
+        }
+        try {
+            const authContext = authContexts.get(socket);
+            const result = await authorize(data, authContext);
+            return result !== false;
+        }
+        catch (error) {
+            (0, helpers_1.sendError)(socket, data, error);
+            logger_1.globalLogger.error('[Socket Server] Failed to authorize stream subscription');
+            return false;
+        }
+    };
+    socketServer.on('connection', async (socket, request) => {
+        authContexts.set(socket, request.authContext);
+        subscriptions.set(socket, new Set());
+        socket.on('message', async (payload) => {
+            const message = JSON.parse(payload.toString());
+            if (message.type === 'join') {
+                const authorized = await isAuthorized(socket, message.data);
+                if (!authorized) {
+                    (0, helpers_1.sendAccessDenied)(socket, message.data);
+                    return;
+                }
+                const room = (0, helpers_1.getRoom)(message.data);
+                if (!rooms[room]) {
+                    rooms[room] = new Map();
+                }
+                if (message.data.id) {
+                    const item = await onJoin(message.data.streamName, message.data.groupId, message.data.id);
+                    if (item) {
+                        const resultMessage = {
+                            timestamp: Date.now(),
+                            streamName: message.data.streamName,
+                            groupId: message.data.groupId,
+                            id: message.data.id,
+                            event: { type: 'sync', data: item },
+                        };
+                        socket.send(JSON.stringify(resultMessage));
+                    }
+                }
+                else {
+                    const items = await onJoinGroup(message.data.streamName, message.data.groupId);
+                    if (items) {
+                        const resultMessage = {
+                            timestamp: Date.now(),
+                            streamName: message.data.streamName,
+                            groupId: message.data.groupId,
+                            event: { type: 'sync', data: items },
+                        };
+                        socket.send(JSON.stringify(resultMessage));
+                    }
+                }
+                rooms[room].set(message.data.subscriptionId, socket);
+                subscriptions.get(socket)?.add([room, message.data.subscriptionId]);
+            }
+            else if (message.type === 'leave') {
+                const room = (0, helpers_1.getRoom)(message.data);
+                if (rooms[room]) {
+                    rooms[room].delete(message.data.subscriptionId);
+                }
+            }
+        });
+        socket.on('close', () => {
+            subscriptions.get(socket)?.forEach(([room, subscriptionId]) => {
+                rooms[room]?.delete(subscriptionId);
+            });
+            subscriptions.delete(socket);
+            authContexts.delete(socket);
+        });
+    });
+    const pushEvent = (message) => {
+        const { groupId, streamName, id } = message;
+        const groupRoom = (0, helpers_1.getRoom)({ streamName, groupId });
+        const eventMessage = JSON.stringify({ timestamp: Date.now(), ...message });
+        if (rooms[groupRoom]) {
+            rooms[groupRoom].forEach((socket) => {
+                socket.send(eventMessage);
+            });
+        }
+        if (id) {
+            const itemRoom = (0, helpers_1.getRoom)({ groupId, streamName, id });
+            if (rooms[itemRoom]) {
+                rooms[itemRoom].forEach((socket) => {
+                    socket.send(eventMessage);
+                });
+            }
+        }
+    };
+    return { pushEvent, socketServer };
+};
+exports.createSocketServer = createSocketServer;

package/dist/src/state/create-state-adapter.d.ts

@@ -0,0 +1,8 @@
+import { type FileAdapterConfig as FileStateAdapterConfig } from '../adapters/defaults/state/file-state-adapter';
+import type { StateAdapter } from '../adapters/interfaces/state-adapter.interface';
+type AdapterConfig = FileStateAdapterConfig | {
+    adapter: 'memory';
+};
+export declare function createStateAdapter(config: AdapterConfig): StateAdapter;
+export {};
+//# sourceMappingURL=create-state-adapter.d.ts.map

package/dist/src/state/create-state-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-state-adapter.d.ts","sourceRoot":"","sources":["../../../src/state/create-state-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,IAAI,sBAAsB,EACjD,MAAM,+CAA+C,CAAA;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAA;AAElF,KAAK,aAAa,GAAG,sBAAsB,GAAG;IAAE,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEnE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY,CAEtE"}

package/dist/src/state/create-state-adapter.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateAdapter = createStateAdapter;
+const file_state_adapter_1 = require("../adapters/defaults/state/file-state-adapter");
+const memory_state_adapter_1 = require("../adapters/defaults/state/memory-state-adapter");
+function createStateAdapter(config) {
+    return config.adapter === 'default' ? new file_state_adapter_1.FileStateAdapter(config) : new memory_state_adapter_1.MemoryStateAdapter();
+}

package/dist/src/step-handler-rpc-processor.d.ts

@@ -0,0 +1,22 @@
+import type { ChildProcess } from 'child_process';
+import type { MessageCallback, RpcHandler, RpcProcessorInterface } from './process-communication/rpc-processor-interface';
+export type RpcMessage = {
+    type: 'rpc_request';
+    id: string | undefined;
+    method: string;
+    args: unknown;
+};
+export declare class RpcProcessor implements RpcProcessorInterface {
+    private child;
+    private handlers;
+    private messageCallback?;
+    private isClosed;
+    constructor(child: ChildProcess);
+    handler<TInput, TOutput = unknown>(method: string, handler: RpcHandler<TInput, TOutput>): void;
+    onMessage<T = unknown>(callback: MessageCallback<T>): void;
+    handle(method: string, input: unknown): Promise<any>;
+    private response;
+    init(): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=step-handler-rpc-processor.d.ts.map

package/dist/src/step-handler-rpc-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-handler-rpc-processor.d.ts","sourceRoot":"","sources":["../../src/step-handler-rpc-processor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,qBAAqB,EACtB,MAAM,iDAAiD,CAAA;AAExD,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,aAAa,CAAA;IACnB,EAAE,EAAE,MAAM,GAAG,SAAS,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,OAAO,CAAA;CACd,CAAA;AAED,qBAAa,YAAa,YAAW,qBAAqB;IAM5C,OAAO,CAAC,KAAK;IALzB,OAAO,CAAC,QAAQ,CAA2C;IAE3D,OAAO,CAAC,eAAe,CAAC,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAQ;gBAEJ,KAAK,EAAE,YAAY;IAEvC,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC;IAIvF,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IAIpD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAQ3C,OAAO,CAAC,QAAQ;IAYV,IAAI;IA2BV,KAAK;CAIN"}