@motiadev/core 0.13.0-beta.162-846200 → 0.13.1-beta.162

package/dist/src/mermaid-generator.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMermaidGenerator = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const guards_1 = require("./guards");
+// Pure function to ensure diagrams directory exists
+const ensureDiagramsDirectory = (diagramsDir) => {
+    if (!fs_1.default.existsSync(diagramsDir)) {
+        fs_1.default.mkdirSync(diagramsDir, { recursive: true });
+    }
+};
+// Pure function to get node ID
+const getNodeId = (step, baseDir) => {
+    // Get relative path from the base directory
+    const relativePath = path_1.default.relative(baseDir, step.filePath);
+    // Remove common file extensions
+    const pathWithoutExtension = relativePath.replace(/\.(ts|js|tsx|jsx)$/, '');
+    // Replace slashes with underscores and dots with underscores
+    // Only keep alphanumeric characters and underscores
+    return pathWithoutExtension.replace(/[^a-zA-Z0-9]/g, '_');
+};
+// Pure function to get node label
+const getNodeLabel = (step) => {
+    // Get display name for node
+    const displayName = step.config.name || path_1.default.basename(step.filePath, path_1.default.extname(step.filePath));
+    // Add node type prefix to help distinguish types
+    let prefix = '';
+    if ((0, guards_1.isApiStep)(step))
+        prefix = '🌐 ';
+    else if ((0, guards_1.isEventStep)(step))
+        prefix = '⚡ ';
+    else if ((0, guards_1.isCronStep)(step))
+        prefix = '⏰ ';
+    else if ((0, guards_1.isNoopStep)(step))
+        prefix = '⚙️ ';
+    // Create a node label with the step name
+    return `["${prefix}${displayName}"]`;
+};
+// Pure function to get node style
+const getNodeStyle = (step) => {
+    // Apply style class based on step type
+    if ((0, guards_1.isApiStep)(step))
+        return ':::apiStyle';
+    if ((0, guards_1.isEventStep)(step))
+        return ':::eventStyle';
+    if ((0, guards_1.isCronStep)(step))
+        return ':::cronStyle';
+    if ((0, guards_1.isNoopStep)(step))
+        return ':::noopStyle';
+    return '';
+};
+// Pure function to generate connections
+const generateConnections = (emits, sourceStep, steps, sourceId, baseDir) => {
+    const connections = [];
+    if (!emits || !Array.isArray(emits) || emits.length === 0) {
+        return '';
+    }
+    // Helper function to check if a step subscribes to a topic
+    const stepSubscribesToTopic = (step, topic) => {
+        // Event steps use regular subscribes
+        if ((0, guards_1.isEventStep)(step) &&
+            step.config.subscribes &&
+            Array.isArray(step.config.subscribes) &&
+            step.config.subscribes.includes(topic)) {
+            return true;
+        }
+        // Noop and API steps use virtualSubscribes
+        if (((0, guards_1.isNoopStep)(step) || (0, guards_1.isApiStep)(step)) &&
+            step.config.virtualSubscribes &&
+            Array.isArray(step.config.virtualSubscribes) &&
+            step.config.virtualSubscribes.includes(topic)) {
+            return true;
+        }
+        return false;
+    };
+    emits.forEach((emit) => {
+        const topic = typeof emit === 'string' ? emit : emit.topic;
+        const label = typeof emit === 'string' ? topic : emit.label || topic;
+        steps.forEach((targetStep) => {
+            if (stepSubscribesToTopic(targetStep, topic)) {
+                const targetId = getNodeId(targetStep, baseDir);
+                connections.push(`    ${sourceId} -->|${label}| ${targetId}`);
+            }
+        });
+    });
+    return connections.join('\n');
+};
+// Pure function to generate flow diagram
+const generateFlowDiagram = (flowName, steps, baseDir) => {
+    // Start mermaid flowchart with top-down direction
+    let diagram = `flowchart TD\n`;
+    // Add class definitions for styling with explicit text color
+    const classDefinitions = [
+        `    classDef apiStyle fill:#f96,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef eventStyle fill:#69f,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef cronStyle fill:#9c6,stroke:#333,stroke-width:2px,color:#fff`,
+        `    classDef noopStyle fill:#3f3a50,stroke:#333,stroke-width:2px,color:#fff`,
+    ];
+    diagram += classDefinitions.join('\n') + '\n';
+    // Check if we have any steps
+    if (!steps || steps.length === 0) {
+        return diagram + '    empty[No steps in this flow]';
+    }
+    // Create node definitions with proper format
+    steps.forEach((step) => {
+        const nodeId = getNodeId(step, baseDir);
+        const nodeLabel = getNodeLabel(step);
+        const nodeStyle = getNodeStyle(step);
+        diagram += `    ${nodeId}${nodeLabel}${nodeStyle}\n`;
+    });
+    // Create connections between nodes
+    let connectionsStr = '';
+    steps.forEach((sourceStep) => {
+        const sourceId = getNodeId(sourceStep, baseDir);
+        // Helper function to process emissions if they exist
+        function processEmissions(emissionsArray, stepSource, stepsCollection, sourceIdentifier) {
+            if (emissionsArray && Array.isArray(emissionsArray)) {
+                return generateConnections(emissionsArray, stepSource, stepsCollection, sourceIdentifier, baseDir);
+            }
+            return '';
+        }
+        // Semantic variables to clarify which step types support which emission types
+        const supportsEmits = (0, guards_1.isApiStep)(sourceStep) || (0, guards_1.isEventStep)(sourceStep) || (0, guards_1.isCronStep)(sourceStep);
+        const supportsVirtualEmits = supportsEmits || (0, guards_1.isNoopStep)(sourceStep);
+        // Process regular emissions if supported
+        if (supportsEmits) {
+            const emitConnections = processEmissions(sourceStep.config.emits, sourceStep, steps, sourceId);
+            if (emitConnections) {
+                connectionsStr += emitConnections + '\n';
+            }
+        }
+        // Process virtual emissions if supported
+        if (supportsVirtualEmits) {
+            const virtualEmitConnections = processEmissions(sourceStep.config.virtualEmits, sourceStep, steps, sourceId);
+            if (virtualEmitConnections) {
+                connectionsStr += virtualEmitConnections + '\n';
+            }
+        }
+    });
+    // Add connections to the diagram
+    diagram += connectionsStr;
+    return diagram;
+};
+// Function to save a diagram to a file
+const saveDiagram = (diagramsDir, flowName, diagram) => {
+    const filePath = path_1.default.join(diagramsDir, `${flowName}.mmd`);
+    fs_1.default.writeFileSync(filePath, diagram);
+};
+// Function to remove a diagram file
+const removeDiagram = (diagramsDir, flowName) => {
+    const filePath = path_1.default.join(diagramsDir, `${flowName}.mmd`);
+    if (fs_1.default.existsSync(filePath)) {
+        fs_1.default.unlinkSync(filePath);
+    }
+};
+// Function to generate and save a diagram
+const generateAndSaveDiagram = (diagramsDir, flowName, flow, baseDir) => {
+    const diagram = generateFlowDiagram(flowName, flow.steps, baseDir);
+    saveDiagram(diagramsDir, flowName, diagram);
+};
+// Main exported function that creates the mermaid generator
+const createMermaidGenerator = (baseDir) => {
+    const diagramsDir = path_1.default.join(baseDir, '.mermaid');
+    ensureDiagramsDirectory(diagramsDir);
+    // Event handlers
+    const handleFlowCreated = (flowName, flow) => {
+        generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+    };
+    const handleFlowUpdated = (flowName, flow) => {
+        generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+    };
+    const handleFlowRemoved = (flowName) => {
+        removeDiagram(diagramsDir, flowName);
+    };
+    // Initialize function to hook into LockedData events
+    const initialize = (lockedData) => {
+        // Hook into flow events
+        lockedData.on('flow-created', (flowName) => {
+            handleFlowCreated(flowName, lockedData.flows[flowName]);
+        });
+        lockedData.on('flow-updated', (flowName) => {
+            handleFlowUpdated(flowName, lockedData.flows[flowName]);
+        });
+        lockedData.on('flow-removed', (flowName) => {
+            handleFlowRemoved(flowName);
+        });
+        // Generate diagrams for all existing flows
+        if (lockedData.flows && typeof lockedData.flows === 'object') {
+            Object.entries(lockedData.flows).forEach(([flowName, flow]) => {
+                generateAndSaveDiagram(diagramsDir, flowName, flow, baseDir);
+            });
+        }
+    };
+    // Return the public API
+    return {
+        initialize,
+    };
+};
+exports.createMermaidGenerator = createMermaidGenerator;

package/dist/src/motia.d.ts

@@ -0,0 +1,32 @@
+import type { Express } from 'express';
+import type { EventAdapter } from './adapters/interfaces/event-adapter.interface';
+import type { StateAdapter } from './adapters/interfaces/state-adapter.interface';
+import type { LockedData } from './locked-data';
+import type { LoggerFactory } from './logger-factory';
+import type { TracerFactory } from './observability';
+import type { Printer } from './printer';
+import type { ApiResponse, ApiRouteConfig, ApiRouteHandler, InternalStateManager } from './types';
+export type Motia = {
+    loggerFactory: LoggerFactory;
+    eventAdapter: EventAdapter;
+    state: InternalStateManager;
+    lockedData: LockedData;
+    printer: Printer;
+    tracerFactory: TracerFactory;
+    app: Express;
+    stateAdapter: StateAdapter;
+};
+export type PluginApiConfig = {
+    method: ApiRouteConfig['method'];
+    path: string;
+};
+export type UnregisterMotiaPluginApi = () => void;
+export type MotiaPluginContext = {
+    printer: Printer;
+    state: StateAdapter;
+    lockedData: LockedData;
+    tracerFactory: TracerFactory;
+    registerApi: <TRequestBody = unknown, TResponseBody extends ApiResponse<number, unknown> = ApiResponse<number, unknown>, TEmitData = never>(config: PluginApiConfig, handler: ApiRouteHandler<TRequestBody, TResponseBody, TEmitData>) => UnregisterMotiaPluginApi;
+};
+export declare const PLUGIN_FLOW_ID = "_plugin";
+//# sourceMappingURL=motia.d.ts.map

package/dist/src/motia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motia.d.ts","sourceRoot":"","sources":["../../src/motia.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAEjG,MAAM,MAAM,KAAK,GAAG;IAClB,aAAa,EAAE,aAAa,CAAA;IAC5B,YAAY,EAAE,YAAY,CAAA;IAC1B,KAAK,EAAE,oBAAoB,CAAA;IAC3B,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,aAAa,CAAA;IAE5B,GAAG,EAAE,OAAO,CAAA;IACZ,YAAY,EAAE,YAAY,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAA;IAChC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,MAAM,IAAI,CAAA;AAEjD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,UAAU,EAAE,UAAU,CAAA;IACtB,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,CACX,YAAY,GAAG,OAAO,EACtB,aAAa,SAAS,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACjF,SAAS,GAAG,KAAK,EAEjB,MAAM,EAAE,eAAe,EACvB,OAAO,EAAE,eAAe,CAAC,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC,KAC7D,wBAAwB,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,cAAc,YAAY,CAAA"}

package/dist/src/motia.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_FLOW_ID = void 0;
+exports.PLUGIN_FLOW_ID = '_plugin';

package/dist/src/node/can-access.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=can-access.d.ts.map

package/dist/src/node/can-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"can-access.d.ts","sourceRoot":"","sources":["../../../src/node/can-access.ts"],"names":[],"mappings":""}

package/dist/src/node/can-access.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+require('dotenv').config();
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+function parsePayload(arg) {
+    try {
+        return JSON.parse(arg);
+    }
+    catch {
+        throw new Error('Invalid payload for canAccess evaluation');
+    }
+}
+async function runCanAccess(filePath, payload) {
+    const module = require(node_path_1.default.resolve(filePath));
+    if (!module?.config) {
+        throw new Error(`Config not found in module ${filePath}`);
+    }
+    const canAccess = module.config.canAccess;
+    if (typeof canAccess !== 'function') {
+        process.send?.(true);
+        process.exit(0);
+    }
+    const result = await canAccess(payload.subscription, payload.authContext);
+    process.send?.(Boolean(result));
+    process.exit(0);
+}
+const [, , filePath, payloadArg] = process.argv;
+if (!filePath || !payloadArg) {
+    console.error('Usage: node can-access.js <file-path> <payload>');
+    process.exit(1);
+}
+runCanAccess(filePath, parsePayload(payloadArg))
+    .then(() => process.exit(0))
+    .catch((error) => {
+    console.error('Error evaluating canAccess:', error);
+    process.exit(1);
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-config.d.ts.map

package/dist/src/node/get-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-config.d.ts","sourceRoot":"","sources":["../../../src/node/get-config.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const schema_utils_1 = require("../schema-utils");
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+async function getConfig(filePath) {
+    try {
+        const module = require(node_path_1.default.resolve(filePath));
+        if (!module.config) {
+            throw new Error(`Config not found in module ${filePath}`);
+        }
+        if (module.config.input) {
+            const converted = (0, schema_utils_1.schemaToJsonSchema)(module.config.input);
+            if (converted) {
+                module.config.input = converted;
+            }
+        }
+        if (module.config.bodySchema) {
+            const converted = (0, schema_utils_1.schemaToJsonSchema)(module.config.bodySchema);
+            if (converted) {
+                module.config.bodySchema = converted;
+            }
+        }
+        if (module.config.responseSchema) {
+            for (const [status, schema] of Object.entries(module.config.responseSchema)) {
+                const converted = (0, schema_utils_1.schemaToJsonSchema)(schema);
+                if (converted) {
+                    module.config.responseSchema[status] = converted;
+                }
+            }
+        }
+        if (module.config.schema) {
+            const converted = (0, schema_utils_1.schemaToJsonSchema)(module.config.schema);
+            if (converted) {
+                module.config.schema = converted;
+            }
+        }
+        if (typeof module.config.canAccess === 'function') {
+            module.config.__motia_hasCanAccess = !!module.config.canAccess;
+            delete module.config.canAccess;
+        }
+        process.send?.(module.config);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Error running TypeScript module:', error);
+        process.exit(1);
+    }
+}
+const [, , filePath] = process.argv;
+if (!filePath) {
+    console.error('Usage: node get-config.js <file-path>');
+    process.exit(1);
+}
+getConfig(filePath).catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/dist/src/node/logger.d.ts

@@ -0,0 +1,16 @@
+import type { RpcSender } from './rpc';
+export type LogListener = (level: string, message: string, args?: unknown) => void;
+export declare class Logger {
+    private readonly traceId;
+    private readonly flows;
+    private readonly sender;
+    private readonly listeners;
+    constructor(traceId: string, flows: string[], sender: RpcSender);
+    private _log;
+    info(message: string, args?: Record<string, unknown>): void;
+    error(message: string, args?: Record<string, unknown>): void;
+    debug(message: string, args?: Record<string, unknown>): void;
+    warn(message: string, args?: Record<string, unknown>): void;
+    addListener(listener: LogListener): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/node/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/node/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,MAAM,MAAM,WAAW,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;AAElF,qBAAa,MAAM;IAIf,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;gBAG3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,SAAS;IAGpC,OAAO,CAAC,IAAI;IA0BZ,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,WAAW,CAAC,QAAQ,EAAE,WAAW;CAGlC"}

package/dist/src/node/logger.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(traceId, flows, sender) {
+        this.traceId = traceId;
+        this.flows = flows;
+        this.sender = sender;
+        this.listeners = [];
+    }
+    _log(level, message, args) {
+        const argsCopy = args ? { ...args } : {};
+        if (argsCopy.error && argsCopy.error instanceof Error) {
+            argsCopy.error = {
+                ...argsCopy.error,
+                message: argsCopy.error.message,
+                stack: argsCopy.error.stack,
+                name: argsCopy.error.name,
+            };
+        }
+        const logEntry = {
+            ...argsCopy,
+            level,
+            time: Date.now(),
+            traceId: this.traceId,
+            flows: this.flows,
+            msg: message,
+        };
+        this.sender.sendNoWait('log', logEntry);
+        this.listeners.forEach((listener) => listener(level, message, args));
+    }
+    info(message, args) {
+        this._log('info', message, args);
+    }
+    error(message, args) {
+        this._log('error', message, args);
+    }
+    debug(message, args) {
+        this._log('debug', message, args);
+    }
+    warn(message, args) {
+        this._log('warn', message, args);
+    }
+    addListener(listener) {
+        this.listeners.push(listener);
+    }
+}
+exports.Logger = Logger;

package/dist/src/node/middleware-compose.d.ts

@@ -0,0 +1,2 @@
+export declare const composeMiddleware: (...middlewares: any[]) => (req: any, ctx: any, handler: () => Promise<any>) => Promise<any>;
+//# sourceMappingURL=middleware-compose.d.ts.map

package/dist/src/node/middleware-compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-compose.d.ts","sourceRoot":"","sources":["../../../src/node/middleware-compose.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,GAAI,GAAG,aAAa,GAAG,EAAE,MACvC,KAAK,GAAG,EAAE,KAAK,GAAG,EAAE,SAAS,MAAM,OAAO,CAAC,GAAG,CAAC,KAAG,OAAO,CAAC,GAAG,CAQ5E,CAAA"}

package/dist/src/node/middleware-compose.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeMiddleware = void 0;
+const composeMiddleware = (...middlewares) => {
+    return async (req, ctx, handler) => {
+        const composedHandler = middlewares.reduceRight((nextHandler, middleware) => () => middleware(req, ctx, nextHandler), handler);
+        return composedHandler();
+    };
+};
+exports.composeMiddleware = composeMiddleware;

package/dist/src/node/node-runner.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=node-runner.d.ts.map

package/dist/src/node/node-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-runner.d.ts","sourceRoot":"","sources":["../../../src/node/node-runner.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const middleware_compose_1 = require("./middleware-compose");
+const rpc_1 = require("./rpc");
+const rpc_state_manager_1 = require("./rpc-state-manager");
+require('dotenv').config();
+// Add ts-node registration before dynamic imports
+require('ts-node').register({
+    transpileOnly: true,
+    compilerOptions: { module: 'commonjs' },
+});
+function parseArgs(arg) {
+    try {
+        return JSON.parse(arg);
+    }
+    catch {
+        return arg;
+    }
+}
+async function runTypescriptModule(filePath, event) {
+    const sender = new rpc_1.RpcSender(process);
+    try {
+        const module = require(path_1.default.resolve(filePath));
+        // Check if the specified function exists in the module
+        if (typeof module.handler !== 'function') {
+            throw new Error(`Function handler not found in module ${filePath}`);
+        }
+        const { traceId, flows, contextInFirstArg } = 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 streamsConfig = event.streams;
+        const streams = (streamsConfig ?? []).reduce((acc, streams) => {
+            acc[streams.name] = {
+                get: (groupId, id) => sender.send(`streams.${streams.name}.get`, { groupId, id }),
+                set: (groupId, id, data) => sender.send(`streams.${streams.name}.set`, { groupId, id, data }),
+                delete: (groupId, id) => sender.send(`streams.${streams.name}.delete`, { groupId, id }),
+                getGroup: (groupId) => sender.send(`streams.${streams.name}.getGroup`, { groupId }),
+                send: (channel, event) => sender.send(`streams.${streams.name}.send`, { channel, event }),
+            };
+            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);
+        const handlerFn = () => {
+            return contextInFirstArg ? module.handler(context) : module.handler(event.data, context);
+        };
+        const result = await composedMiddleware(event.data, context, handlerFn);
+        await sender.send('result', result);
+        await sender.close();
+        process.exit(0);
+    }
+    catch (err) {
+        const stack = err.stack?.split('\n') ?? [];
+        if (stack) {
+            const index = stack.findIndex((line) => line.includes('src/node/node-runner'));
+            stack.splice(index, stack.length - index);
+            stack.splice(0, 1); // remove first line which has the error message
+        }
+        const error = {
+            message: err.message || '',
+            code: err.code || null,
+            stack: stack.join('\n'),
+        };
+        sender.sendNoWait('close', error);
+    }
+}
+const [, , filePath, arg] = process.argv;
+if (!filePath) {
+    console.error('Usage: node nodeRunner.js <file-path> <arg>');
+    process.exit(1);
+}
+runTypescriptModule(filePath, parseArgs(arg)).catch((err) => {
+    console.error('Error:', err);
+    process.exit(1);
+});

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

@@ -0,0 +1,12 @@
+import type { InternalStateManager } from '../types';
+import type { RpcSender } from './rpc';
+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<T>;
+    delete<T>(traceId: string, key: string): Promise<T | null>;
+    clear(traceId: string): Promise<void>;
+    getGroup<T>(groupId: string): Promise<T[]>;
+}
+//# sourceMappingURL=rpc-state-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-state-manager.d.ts","sourceRoot":"","sources":["../../../src/node/rpc-state-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC,qBAAa,eAAgB,YAAW,oBAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS;IAExC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAInC,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAI7C,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAI1D,KAAK,CAAC,OAAO,EAAE,MAAM;IAIrB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;CAGjD"}

package/dist/src/node/rpc-state-manager.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcStateManager = void 0;
+class RpcStateManager {
+    constructor(sender) {
+        this.sender = sender;
+    }
+    async get(traceId, key) {
+        return this.sender.send('state.get', { traceId, key });
+    }
+    async set(traceId, key, value) {
+        return this.sender.send('state.set', { traceId, key, value });
+    }
+    async delete(traceId, key) {
+        return this.sender.send('state.delete', { traceId, key });
+    }
+    async clear(traceId) {
+        await this.sender.send('state.clear', { traceId });
+    }
+    async getGroup(groupId) {
+        return this.sender.send('state.getGroup', { groupId });
+    }
+}
+exports.RpcStateManager = RpcStateManager;

package/dist/src/node/rpc.d.ts

@@ -0,0 +1,10 @@
+export declare class RpcSender {
+    private readonly process;
+    private readonly pendingRequests;
+    constructor(process: NodeJS.Process);
+    close(): Promise<void>;
+    send<T>(method: string, args: unknown): Promise<T>;
+    sendNoWait(method: string, args: unknown): void;
+    init(): void;
+}
+//# sourceMappingURL=rpc.d.ts.map

package/dist/src/node/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/node/rpc.ts"],"names":[],"mappings":"AAUA,qBAAa,SAAS;IAMR,OAAO,CAAC,QAAQ,CAAC,OAAO;IALpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAG1B;gBAEuB,OAAO,EAAE,MAAM,CAAC,OAAO;IAE9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC;IASlD,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAIxC,IAAI;CAkBL"}

package/dist/src/node/rpc.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcSender = void 0;
+/// <reference types="node" />
+const crypto_1 = __importDefault(require("crypto"));
+class RpcSender {
+    constructor(process) {
+        this.process = process;
+        this.pendingRequests = {};
+    }
+    async close() {
+        const outstandingRequests = Object.values(this.pendingRequests);
+        if (outstandingRequests.length > 0) {
+            console.error('Process ended while there are some promises outstanding');
+            this.process.exit(1);
+        }
+    }
+    send(method, args) {
+        return new Promise((resolve, reject) => {
+            const id = crypto_1.default.randomUUID();
+            this.pendingRequests[id] = { resolve, reject, method, args };
+            this.process.send?.({ type: 'rpc_request', id, method, args });
+        });
+    }
+    sendNoWait(method, args) {
+        this.process.send?.({ type: 'rpc_request', method, args });
+    }
+    init() {
+        this.process.on('message', (msg) => {
+            if (msg.type === 'rpc_response') {
+                const { id, result, error } = msg;
+                const callbacks = this.pendingRequests[id];
+                if (!callbacks) {
+                    return;
+                }
+                else if (error) {
+                    callbacks.reject(error);
+                }
+                else {
+                    callbacks.resolve(result);
+                }
+                delete this.pendingRequests[id];
+            }
+        });
+    }
+}
+exports.RpcSender = RpcSender;