@motiadev/core 0.0.1

package/dist/src/state/adapters/default-state-adapter.js

@@ -0,0 +1,102 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStateAdapter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+class FileStateAdapter {
+    constructor(config) {
+        this.filePath = path.join(config.filePath, 'motia-state.json');
+    }
+    async init() {
+        const dir = this.filePath.replace('motia-state.json', '');
+        try {
+            fs_1.default.realpathSync(dir);
+        }
+        catch (err) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        try {
+            fs_1.default.readFileSync(this.filePath, 'utf-8');
+        }
+        catch (err) {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify({}), 'utf-8');
+        }
+    }
+    async get(traceId, key) {
+        const data = await this._readFile();
+        const fullKey = this._makeKey(traceId, key);
+        return data[fullKey] ? JSON.parse(data[fullKey]) : null;
+    }
+    async set(traceId, key, value) {
+        const data = await this._readFile();
+        const fullKey = this._makeKey(traceId, key);
+        data[fullKey] = JSON.stringify(value);
+        await this._writeFile(data);
+    }
+    async delete(traceId, key) {
+        const data = await this._readFile();
+        const fullKey = this._makeKey(traceId, key);
+        delete data[fullKey];
+        await this._writeFile(data);
+    }
+    async clear(traceId) {
+        const data = await this._readFile();
+        const pattern = this._makeKey(traceId, '');
+        for (const key in data) {
+            if (key.startsWith(pattern)) {
+                delete data[key];
+            }
+        }
+        await this._writeFile(data);
+    }
+    async cleanup() {
+        // No cleanup needed for file system
+    }
+    _makeKey(traceId, key) {
+        return `${traceId}:${key}`;
+    }
+    async _readFile() {
+        const content = fs_1.default.readFileSync(this.filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    async _writeFile(data) {
+        fs_1.default.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+}
+exports.FileStateAdapter = FileStateAdapter;

package/dist/src/state/adapters/redis-state-adapter.d.ts

@@ -0,0 +1,19 @@
+import { StateAdapter } from '../state-adapter';
+export type RedisAdapterConfig = {
+    host: string;
+    port: number;
+    password?: string;
+    ttl?: number;
+};
+export declare class RedisStateAdapter implements StateAdapter {
+    private client;
+    private prefix;
+    private ttl;
+    constructor(config: RedisAdapterConfig);
+    get(traceId: string, key: string): Promise<any>;
+    set(traceId: string, key: string, value: any): Promise<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+    cleanup(): Promise<void>;
+    _makeKey(traceId: string, key: string): string;
+}

package/dist/src/state/adapters/redis-state-adapter.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 });
+exports.RedisStateAdapter = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisStateAdapter {
+    constructor(config) {
+        this.ttl = 3600;
+        this.client = new ioredis_1.default(config);
+        this.prefix = 'motia:state';
+        if (config.ttl) {
+            this.ttl = config.ttl;
+        }
+    }
+    async get(traceId, key) {
+        const fullKey = this._makeKey(traceId, key);
+        const value = await this.client.get(fullKey);
+        return value ? JSON.parse(value) : null;
+    }
+    async set(traceId, key, value) {
+        const fullKey = this._makeKey(traceId, key);
+        await this.client.set(fullKey, JSON.stringify(value), 'EX', this.ttl);
+    }
+    async delete(traceId, key) {
+        const fullKey = this._makeKey(traceId, key);
+        await this.client.del(fullKey);
+    }
+    async clear(traceId) {
+        const pattern = this._makeKey(traceId, '*');
+        const keys = await this.client.keys(pattern);
+        if (keys.length > 0) {
+            await this.client.del(keys);
+        }
+    }
+    async cleanup() {
+        await this.client.quit();
+    }
+    _makeKey(traceId, key) {
+        return `${this.prefix}:${traceId}:${key}`;
+    }
+}
+exports.RedisStateAdapter = RedisStateAdapter;

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

@@ -0,0 +1,8 @@
+import { FileStateAdapter } from './adapters/default-state-adapter';
+import { RedisAdapterConfig, RedisStateAdapter } from './adapters/redis-state-adapter';
+type BaseConfig = {
+    adapter: 'default' | 'redis';
+};
+export type AdapterConfig = (BaseConfig & RedisAdapterConfig) | Record<string, unknown>;
+export declare function createStateAdapter(config: Record<string, unknown>): FileStateAdapter | RedisStateAdapter;
+export {};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStateAdapter = createStateAdapter;
+const default_state_adapter_1 = require("./adapters/default-state-adapter");
+const redis_state_adapter_1 = require("./adapters/redis-state-adapter");
+function createStateAdapter(config) {
+    const { adapter = 'redis', ...adapterConfig } = config;
+    switch (adapter) {
+        case 'redis':
+            return new redis_state_adapter_1.RedisStateAdapter(adapterConfig);
+        case 'default':
+            return new default_state_adapter_1.FileStateAdapter(adapterConfig);
+        default:
+            throw new Error(`Unknown state adapter type: ${adapter}`);
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Interface for state management adapters
+ */
+export interface StateAdapter {
+    get<T>(traceId: string, key: string): Promise<T | null>;
+    set<T>(traceId: string, key: string, value: T): Promise<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+    cleanup(): Promise<void>;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { ChildProcess } from 'child_process';
+type RpcHandler<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
+export declare class RpcProcessor {
+    private child;
+    private handlers;
+    constructor(child: ChildProcess);
+    handler<TInput, TOutput = unknown>(method: string, handler: RpcHandler<TInput, TOutput>): void;
+    handle(method: string, input: any): Promise<any>;
+    private response;
+    init(): Promise<void>;
+}
+export {};

package/dist/src/step-handler-rpc-processor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcProcessor = void 0;
+class RpcProcessor {
+    constructor(child) {
+        this.child = child;
+        this.handlers = {};
+    }
+    handler(method, handler) {
+        this.handlers[method] = handler;
+    }
+    async handle(method, input) {
+        const handler = this.handlers[method];
+        if (!handler) {
+            throw new Error(`Handler for method ${method} not found`);
+        }
+        return handler(input);
+    }
+    response(id, result, error) {
+        if (id) {
+            this.child.send?.({ type: 'rpc_response', id, result, error });
+        }
+    }
+    async init() {
+        this.child.on('message', (msg) => {
+            if (msg.type === 'rpc_request') {
+                const { id, method, args } = msg;
+                this.handle(method, args)
+                    .then((result) => this.response(id, result, null))
+                    .catch((error) => this.response(id, null, error));
+            }
+        });
+    }
+}
+exports.RpcProcessor = RpcProcessor;

package/dist/src/step-handlers.d.ts

@@ -0,0 +1,2 @@
+import { EventManager, InternalStateManager, Step } from './types';
+export declare const createStepHandlers: (steps: Step[], eventManager: EventManager, state: InternalStateManager) => void;

package/dist/src/step-handlers.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStepHandlers = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const guards_1 = require("./guards");
+const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
+const nodeRunner = path_1.default.join(__dirname, 'node', 'node-runner.js');
+const pythonRunner = path_1.default.join(__dirname, 'python', 'python-runner.py');
+const rubyRunner = path_1.default.join(__dirname, 'ruby', 'ruby_runner.rb');
+const getLanguageBasedRunner = (stepFilePath = '') => {
+    const isPython = stepFilePath.endsWith('.py');
+    const isRuby = stepFilePath.endsWith('.rb');
+    const isNode = stepFilePath.endsWith('.js') || stepFilePath.endsWith('.ts');
+    if (isPython) {
+        return { runner: pythonRunner, command: 'python' };
+    }
+    else if (isRuby) {
+        return { runner: rubyRunner, command: 'ruby' };
+    }
+    else if (isNode) {
+        return { runner: nodeRunner, command: 'node' };
+    }
+    throw Error(`Unsupported file extension ${stepFilePath}`);
+};
+const callStepFile = (stepPath, step, event, eventManager, state) => {
+    return new Promise((resolve, reject) => {
+        const jsonData = JSON.stringify({ ...event });
+        const { runner, command } = getLanguageBasedRunner(stepPath);
+        const child = (0, child_process_1.spawn)(command, [runner, stepPath, jsonData], {
+            stdio: [undefined, undefined, undefined, 'ipc'],
+        });
+        const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
+        rpcProcessor.handler('log', async (input) => {
+            event.logger.log(input);
+        });
+        rpcProcessor.handler('state.get', (input) => state.get(input.traceId, input.key));
+        rpcProcessor.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
+        rpcProcessor.handler('state.delete', (input) => state.delete(input.traceId, input.key));
+        rpcProcessor.handler('state.clear', (input) => state.clear(input.traceId));
+        rpcProcessor.handler('emit', (input) => {
+            return eventManager.emit({
+                ...input,
+                traceId: event.traceId,
+                flows: event.flows,
+                logger: event.logger,
+            }, stepPath);
+        });
+        rpcProcessor.init();
+        child.stdout?.on('data', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                event.logger.log(message);
+            }
+            catch (error) {
+                event.logger.info(Buffer.from(data).toString(), { step });
+            }
+        });
+        child.stderr?.on('data', (data) => event.logger.error(Buffer.from(data).toString(), { step }));
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+};
+const createStepHandlers = (steps, eventManager, state) => {
+    logger_1.globalLogger.debug(`[step handler] creating step handlers for ${steps.length} steps`);
+    steps.filter(guards_1.isEventStep).forEach((step) => {
+        const { config, filePath } = step;
+        const { subscribes } = config;
+        logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
+        subscribes.forEach((subscribe) => {
+            eventManager.subscribe(subscribe, step.config.name, async (event) => {
+                const { logger, ...rest } = event;
+                logger_1.globalLogger.debug('[step handler] received event', { event: rest, step: step.config.name });
+                try {
+                    await callStepFile(filePath, step.config.name, event, eventManager, state);
+                }
+                catch (error) {
+                    logger_1.globalLogger.error(`[step handler] error calling step`, {
+                        error: error.message,
+                        filePath,
+                        step: step.config.name,
+                    });
+                }
+            });
+        });
+    });
+};
+exports.createStepHandlers = createStepHandlers;

package/dist/src/types.d.ts

@@ -0,0 +1,109 @@
+import { z, ZodObject } from 'zod';
+import { Server } from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+import { Logger } from './logger';
+export type InternalStateManager = {
+    get<T>(traceId: string, key: string): Promise<T | null>;
+    set<T>(traceId: string, key: string, value: T): Promise<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+};
+export type EmitData = {
+    type: string;
+    data: Record<string, unknown>;
+};
+export type Emitter = (event: EmitData) => Promise<void>;
+export type FlowContext = {
+    emit: Emitter;
+    traceId: string;
+    state: InternalStateManager;
+    logger: Logger;
+};
+export type EventHandler<TInput extends ZodObject<any>> = (input: z.infer<TInput>, ctx: FlowContext) => Promise<void>;
+export type Emit = string | {
+    type: string;
+    label?: string;
+    conditional?: boolean;
+};
+export type EventConfig<TInput extends ZodObject<any>> = {
+    type: 'event';
+    name: string;
+    description?: string;
+    subscribes: string[];
+    emits: Emit[];
+    virtualEmits?: Emit[];
+    input: TInput;
+    flows: string[];
+};
+export type NoopConfig = {
+    type: 'noop';
+    name: string;
+    description?: string;
+    virtualEmits: Emit[];
+    virtualSubscribes: string[];
+    flows: string[];
+};
+export type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type ApiRouteConfig = {
+    type: 'api';
+    name: string;
+    description?: string;
+    path: string;
+    method: ApiRouteMethod;
+    emits: string[];
+    virtualEmits?: Emit[];
+    virtualSubscribes?: string[];
+    flows: string[];
+    bodySchema?: ZodObject<any>;
+};
+export type ApiRequest = {
+    pathParams: Record<string, string>;
+    queryParams: Record<string, string | string[]>;
+    body: Record<string, any>;
+    headers: Record<string, string | string[]>;
+};
+export type ApiResponse = {
+    status: number;
+    headers?: Record<string, string>;
+    body: string | Buffer | Record<string, any>;
+};
+export type ApiRouteHandler = (req: ApiRequest, ctx: FlowContext) => Promise<ApiResponse>;
+export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : never;
+export type MotiaServer = Server<any>;
+export type MotiaSocketServer = SocketIOServer;
+export type Event<TData = unknown> = {
+    type: string;
+    data: TData;
+    traceId: string;
+    flows: string[];
+    logger: Logger;
+};
+export type Handler<TData = unknown> = (event: Event<TData>) => Promise<void>;
+export type EventManager = {
+    emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
+    subscribe: <TData>(event: string, handlerName: string, handler: Handler<TData>) => void;
+};
+export type StepConfig = EventConfig<ZodObject<any>> | NoopConfig | ApiRouteConfig;
+export type Step<TConfig extends StepConfig = StepConfig> = {
+    filePath: string;
+    version: string;
+    config: TConfig;
+};
+export type Flow = {
+    name: string;
+    description?: string;
+    steps: Step[];
+};
+export type LockedData = {
+    baseDir: string;
+    steps: {
+        active: Step[];
+        dev: Step[];
+    };
+    flows: Record<string, Flow>;
+    state: {
+        adapter: string;
+        host: string;
+        port: number;
+    };
+};

package/dist/src/types.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@motiadev/core",
+  "main": "dist/index.js",
+  "version": "0.0.1",
+  "dependencies": {
+    "body-parser": "^1.20.3",
+    "express": "^4.21.2",
+    "ioredis": "^5.4.2",
+    "pino": "^9.6.0",
+    "socket.io": "^4.8.1",
+    "ts-node": "^10.9.2",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/body-parser": "^1.19.5",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2"
+  },
+  "scripts": {
+    "move:python": "cp src/python/*.py dist/src/python",
+    "move:rb": "cp src/ruby/*.rb dist/src/ruby",
+    "build": "rm -rf dist && tsc && npm run move:python && npm run move:rb",
+    "watch": "tsc --watch",
+    "test": "jest"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "declaration": true
+  },
+  "include": ["**/*.ts", "**/*.js"],
+  "jsx": "react-jsx",
+  "exclude": ["node_modules", "dist"]
+}