@motiadev/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './src/types';
+export * from './src/server';
+export * from './src/step-handlers';
+export * from './src/event-manager';
+export * from './src/logger';
+export * from './src/state/create-state-adapter';
+export * from './src/python/get-python-config';
+export * from './src/ruby/get-ruby-config';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./src/types"), exports);
+__exportStar(require("./src/server"), exports);
+__exportStar(require("./src/step-handlers"), exports);
+__exportStar(require("./src/event-manager"), exports);
+__exportStar(require("./src/logger"), exports);
+__exportStar(require("./src/state/create-state-adapter"), exports);
+__exportStar(require("./src/python/get-python-config"), exports);
+__exportStar(require("./src/ruby/get-ruby-config"), exports);

package/dist/jest.config.d.ts

@@ -0,0 +1,6 @@
+export let roots: string[];
+export let transform: {
+    '^.+\\.ts$': string;
+};
+export let testRegex: string;
+export let moduleFileExtensions: string[];

package/dist/src/config.types.d.ts

@@ -0,0 +1,16 @@
+import { StepConfig } from './types';
+export type StateConfig = {
+    adapter: string;
+    host: string;
+    port: number;
+    password?: string;
+};
+export type Config = {
+    port: number;
+    state: StateConfig;
+};
+export type Step<TConfig extends StepConfig = StepConfig> = {
+    config: TConfig;
+    file: string;
+    filePath: string;
+};

package/dist/src/config.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/event-manager.d.ts

@@ -0,0 +1,2 @@
+import { EventManager } from './types';
+export declare const createEventManager: () => EventManager;

package/dist/src/event-manager.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventManager = void 0;
+const logger_1 = require("./logger");
+const createEventManager = () => {
+    const handlers = {};
+    const emit = async (event, file) => {
+        const eventHandlers = handlers[event.type] ?? [];
+        const { logger, ...rest } = event;
+        logger.debug('[Flow Emit] Event emitted', { handlers: eventHandlers.length, data: rest, file });
+        eventHandlers.map((handler) => handler(event));
+    };
+    const subscribe = (event, handlerName, handler) => {
+        if (!handlers[event]) {
+            handlers[event] = [];
+        }
+        logger_1.globalLogger.debug('[Flow Sub] Subscribing to event', { event, handlerName });
+        handlers[event].push(handler);
+    };
+    return { emit, subscribe };
+};
+exports.createEventManager = createEventManager;

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

@@ -0,0 +1,25 @@
+import { Express } from 'express';
+import { Emit, LockedData } from './types';
+type FlowListResponse = {
+    id: string;
+    name: string;
+};
+type FlowStepResponse = {
+    id: string;
+    name: string;
+    type: 'event' | 'api' | 'noop';
+    description?: string;
+    subscribes?: string[];
+    emits: Emit[];
+    action?: 'webhook';
+    webhookUrl?: string;
+    bodySchema?: any;
+    language?: string;
+    nodeComponentPath?: string;
+};
+type FlowResponse = FlowListResponse & {
+    steps: FlowStepResponse[];
+};
+export declare const generateFlowsList: (flows: LockedData["flows"]) => FlowResponse[];
+export declare const flowsEndpoint: (flows: LockedData["flows"], app: Express) => void;
+export {};

package/dist/src/flows-endpoint.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flowsEndpoint = exports.generateFlowsList = 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 get_step_language_1 = require("./get-step-language");
+const generateFlowsList = (flows) => {
+    const list = [];
+    Object.keys(flows).forEach((flowId) => {
+        const steps = [];
+        const flowSteps = flows[flowId].steps;
+        flowSteps.forEach((step) => {
+            const filePathWithoutExtension = step.filePath.replace(/\.[^/.]+$/, '');
+            const tsxPath = filePathWithoutExtension + '.tsx';
+            const nodeComponentPath = fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
+            if ((0, guards_1.isApiStep)(step)) {
+                steps.push({
+                    id: (0, crypto_1.randomUUID)(),
+                    type: 'api',
+                    name: step.config.name,
+                    description: step.config.description,
+                    emits: [...step.config.emits, ...(step.config.virtualEmits ?? [])],
+                    subscribes: step.config.virtualSubscribes ?? undefined,
+                    action: 'webhook',
+                    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
+                    webhookUrl: `${step.config.method} ${step.config.path}`,
+                    bodySchema: step?.config.bodySchema ? (0, zod_to_json_schema_1.default)(step.config.bodySchema) : undefined,
+                    nodeComponentPath,
+                });
+            }
+            else if ((0, guards_1.isEventStep)(step)) {
+                steps.push({
+                    id: (0, crypto_1.randomUUID)(),
+                    type: 'event',
+                    name: step.config.name,
+                    description: step.config.description,
+                    emits: [...step.config.emits, ...(step.config.virtualEmits ?? [])],
+                    subscribes: step.config.subscribes,
+                    language: (0, get_step_language_1.getStepLanguage)(step.filePath),
+                    nodeComponentPath,
+                });
+            }
+            else if ((0, guards_1.isNoopStep)(step)) {
+                steps.push({
+                    id: (0, crypto_1.randomUUID)(),
+                    type: 'noop',
+                    name: step.config.name,
+                    description: step.config.description,
+                    emits: step.config.virtualEmits,
+                    subscribes: step.config.virtualSubscribes,
+                    nodeComponentPath,
+                });
+            }
+        });
+        list.push({ id: flowId, name: flowId, steps });
+    });
+    return list;
+};
+exports.generateFlowsList = generateFlowsList;
+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 })));
+    });
+    app.get('/flows/:id', async (req, res) => {
+        const { id } = req.params;
+        const flow = list.find((flow) => flow.id === id);
+        if (!flow) {
+            res.status(404).send({ error: 'Flow not found' });
+        }
+        else {
+            res.status(200).send(flow);
+        }
+    });
+};
+exports.flowsEndpoint = flowsEndpoint;

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

@@ -0,0 +1 @@
+export declare const getStepLanguage: (fileExtension?: string) => string | undefined;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStepLanguage = void 0;
+const getStepLanguage = (fileExtension) => {
+    if (!fileExtension)
+        return;
+    if (fileExtension.endsWith('.js')) {
+        return 'javascript';
+    }
+    if (fileExtension.endsWith('.ts')) {
+        return 'typescript';
+    }
+    if (fileExtension.endsWith('.py')) {
+        return 'python';
+    }
+    if (fileExtension.endsWith('.go')) {
+        return 'go';
+    }
+    if (fileExtension.endsWith('.rb')) {
+        return 'ruby';
+    }
+    if (fileExtension.endsWith('.php')) {
+        return 'php';
+    }
+    return;
+};
+exports.getStepLanguage = getStepLanguage;

package/dist/src/guards.d.ts

@@ -0,0 +1,4 @@
+import { ApiRouteConfig, EventConfig, NoopConfig, Step } 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 isNoopStep: (step: Step) => step is Step<NoopConfig>;

package/dist/src/guards.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;

package/dist/src/logger.d.ts

@@ -0,0 +1,23 @@
+import { Server } from 'socket.io';
+declare class BaseLogger {
+    private logger;
+    constructor(meta?: any);
+    info(message: string, args?: any): void;
+    error(message: string, args?: any): void;
+    debug(message: string, args?: any): void;
+    warn(message: string, args?: any): void;
+}
+export declare class Logger extends BaseLogger {
+    private readonly traceId;
+    private readonly flows;
+    private readonly file;
+    private emitLog;
+    constructor(traceId: string, flows: string[], file: string, socketServer?: Server);
+    log(message: any): void;
+    info: (message: string, args?: any) => void;
+    error: (message: string, args?: any) => void;
+    debug: (message: string, args?: any) => void;
+    warn: (message: string, args?: any) => void;
+}
+export declare const globalLogger: BaseLogger;
+export {};

package/dist/src/logger.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalLogger = exports.Logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const isDebugEnabled = () => process.env.LOG_LEVEL === 'debug';
+class BaseLogger {
+    constructor(meta = {}) {
+        this.logger = (0, pino_1.default)({
+            level: process.env.LOG_LEVEL || 'info',
+            formatters: { level: (level) => ({ level }) },
+            base: null,
+            mixin: () => meta,
+        });
+    }
+    info(message, args) {
+        this.logger.info(args, message);
+    }
+    error(message, args) {
+        this.logger.error(args, message);
+    }
+    debug(message, args) {
+        this.logger.debug(args, message);
+    }
+    warn(message, args) {
+        this.logger.warn(args, message);
+    }
+}
+class Logger extends BaseLogger {
+    constructor(traceId, flows, file, socketServer) {
+        super({ traceId, flows, file });
+        this.traceId = traceId;
+        this.flows = flows;
+        this.file = file;
+        this.info = (message, args) => {
+            super.info(message, args);
+            this.emitLog('info', message, args);
+        };
+        this.error = (message, args) => {
+            super.error(message, args);
+            this.emitLog('error', message, args);
+        };
+        this.debug = (message, args) => {
+            super.debug(message, args);
+            if (isDebugEnabled()) {
+                this.emitLog('debug', message, args);
+            }
+        };
+        this.warn = (message, args) => {
+            super.warn(message, args);
+            this.emitLog('warn', message, args);
+        };
+        this.emitLog = (level, msg, args) => {
+            if (!socketServer) {
+                return;
+            }
+            socketServer.emit('log', {
+                file: this.file,
+                ...(args ?? {}),
+                level,
+                time: Date.now(),
+                msg,
+                traceId: this.traceId,
+                flows: this.flows,
+            });
+        };
+    }
+    log(message) {
+        console.log(JSON.stringify(message));
+        this.emitLog(message.level, message.msg, message);
+    }
+}
+exports.Logger = Logger;
+exports.globalLogger = new BaseLogger();

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

@@ -0,0 +1,8 @@
+export declare class Logger {
+    private logger;
+    constructor(traceId: string, flows: string[], file?: string);
+    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;
+}

package/dist/src/node/logger.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+class Logger {
+    constructor(traceId, flows, file) {
+        this.info = (message, args) => this.logger.info(args, message);
+        this.error = (message, args) => this.logger.error(args, message);
+        this.debug = (message, args) => this.logger.debug(args, message);
+        this.warn = (message, args) => this.logger.warn(args, message);
+        this.logger = (0, pino_1.default)({
+            level: 'info',
+            formatters: { level: (level) => ({ level }) },
+            errorKey: 'error',
+            base: null,
+            mixin: () => ({ traceId, flows, file }),
+        });
+    }
+}
+exports.Logger = Logger;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,56 @@
+"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 rpc_state_manager_1 = require("./rpc-state-manager");
+const rpc_1 = require("./rpc");
+// 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, args) {
+    try {
+        // Remove pathToFileURL since we'll use require
+        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 { stateConfig, ...event } = args;
+        const { traceId, flows } = event;
+        const logger = new logger_1.Logger(traceId, flows, filePath.split('/').pop());
+        const sender = new rpc_1.RpcSender(process);
+        const state = new rpc_state_manager_1.RpcStateManager(sender);
+        const emit = async (data) => sender.send('emit', data);
+        const context = { traceId, flows, logger, state, emit };
+        sender.init();
+        // Call the function with provided arguments
+        await module.handler(event.data, context);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Error running TypeScript module:', error);
+        process.exit(1);
+    }
+}
+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,10 @@
+import { InternalStateManager } from '../types';
+import { 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<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+"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) {
+        await this.sender.send('state.set', { traceId, key, value });
+    }
+    async delete(traceId, key) {
+        await this.sender.send('state.delete', { traceId, key });
+    }
+    async clear(traceId) {
+        await this.sender.send('state.clear', { traceId });
+    }
+}
+exports.RpcStateManager = RpcStateManager;

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

@@ -0,0 +1,7 @@
+export declare class RpcSender {
+    private readonly process;
+    private readonly pendingRequests;
+    constructor(process: NodeJS.Process);
+    send<T>(method: string, args: any): Promise<T>;
+    init(): void;
+}

package/dist/src/node/rpc.js

@@ -0,0 +1,32 @@
+"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;
+const crypto_1 = __importDefault(require("crypto"));
+class RpcSender {
+    constructor(process) {
+        this.process = process;
+        this.pendingRequests = {};
+    }
+    send(method, args) {
+        return new Promise((resolve, reject) => {
+            const id = crypto_1.default.randomUUID();
+            this.pendingRequests[id] = { resolve, reject, method, args };
+            process.send?.({ type: 'rpc_request', id, method, args });
+        });
+    }
+    init() {
+        this.process.on('message', (msg) => {
+            if (msg.type === 'rpc_response') {
+                const { id, result, error } = msg;
+                const callbacks = this.pendingRequests[id];
+                const callback = error ? callbacks.reject : callbacks.resolve;
+                callback(result);
+                delete this.pendingRequests[id];
+            }
+        });
+    }
+}
+exports.RpcSender = RpcSender;

package/dist/src/python/get-config.py

@@ -0,0 +1,42 @@
+import sys
+import json
+import importlib.util
+import os
+from typing import Any, Callable
+
+# get the FD from ENV
+NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
+
+def sendMessage(text):
+  'sends a Node IPC message to parent proccess'
+  # encode message as json string + newline in bytes
+  bytesMessage = (json.dumps(text) + "\n").encode('utf-8')
+  # send message
+  os.write(NODEIPCFD, bytesMessage)
+
+async def run_python_module(file_path: str) -> None:
+    try:
+        # Load the module dynamically
+        spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load module from {file_path}")
+            
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Print the config if it exists
+        if hasattr(module, 'config'):
+            sendMessage(module.config)
+
+    except Exception as error:
+        print('Error running Python module:', str(error), file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+
+    import asyncio
+    asyncio.run(run_python_module(file_path))

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPythonConfig = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const getPythonConfig = (file) => {
+    const getConfig = path_1.default.join(__dirname, 'get-config.py');
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const child = (0, child_process_1.spawn)('python', [getConfig, file], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        });
+        child.on('message', (message) => {
+            logger_1.globalLogger.debug('[Python Config] Read config', { config: message });
+            config = message;
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+            else if (!config) {
+                reject(new Error(`No config found for file ${file}`));
+            }
+            else {
+                resolve(config);
+            }
+        });
+    });
+};
+exports.getPythonConfig = getPythonConfig;

package/dist/src/python/logger.py

@@ -0,0 +1,42 @@
+import time
+from typing import Any, Dict, Optional
+from rpc import RpcSender
+
+class Logger:
+    def __init__(self, trace_id: str, flows: list[str], file_path: str, sender: RpcSender):
+        self.trace_id = trace_id
+        self.flows = flows
+        self.file_name = file_path.split('/')[-1]
+        self.sender = sender
+
+    def _log(self, level: str, message: str, args: Optional[Dict[str, Any]] = None) -> None:
+        log_entry = {
+            "level": level,
+            "time": int(time.time() * 1000),
+            "traceId": self.trace_id,
+            "flows": self.flows,
+            "file": self.file_name,
+            "msg": message
+        }
+
+        if args:
+            # Convert SimpleNamespace to dict if needed
+            if hasattr(args, '__dict__'):
+                args = vars(args)
+            elif not isinstance(args, dict):
+                args = {"data": args}
+            log_entry.update(args)
+
+        self.sender.send_no_wait('log', log_entry)
+
+    def info(self, message: str, args: Optional[Any] = None) -> None:
+        self._log("info", message, args)
+
+    def error(self, message: str, args: Optional[Any] = None) -> None:
+        self._log("error", message, args)
+
+    def debug(self, message: str, args: Optional[Any] = None) -> None:
+        self._log("debug", message, args)
+
+    def warn(self, message: str, args: Optional[Any] = None) -> None:
+        self._log("warn", message, args)