@motiadev/core 0.2.1-beta.47 → 0.2.1-beta.49

package/dist/src/state-stream.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StateStream = void 0;
+exports.InternalStateStream = exports.StateStream = void 0;
 class StateStream {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async send(channel, event) { }
+}
+exports.StateStream = StateStream;
+class InternalStateStream extends StateStream {
     constructor(state, propertyName) {
+        super();
         this.state = state;
         this.propertyName = propertyName;
     }
@@ -27,4 +33,4 @@ class StateStream {
     }
     async send() { }
 }
-exports.StateStream = StateStream;
+exports.InternalStateStream = InternalStateStream;

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

@@ -1,19 +1,21 @@
 import { ChildProcess } from 'child_process';
-type RpcHandler<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
+import { RpcProcessorInterface, RpcHandler, MessageCallback } from './process-communication/rpc-processor-interface';
 export type RpcMessage = {
     type: 'rpc_request';
     id: string | undefined;
     method: string;
     args: unknown;
 };
-export declare class RpcProcessor {
+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;
 }
-export {};

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

@@ -4,13 +4,15 @@ exports.RpcProcessor = void 0;
 class RpcProcessor {
     constructor(child) {
         this.child = child;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.handlers = {};
         this.isClosed = false;
     }
     handler(method, handler) {
         this.handlers[method] = handler;
     }
+    onMessage(callback) {
+        this.messageCallback = callback;
+    }
     async handle(method, input) {
         const handler = this.handlers[method];
         if (!handler) {
@@ -19,13 +21,24 @@ class RpcProcessor {
         return handler(input);
     }
     response(id, result, error) {
-        if (id && !this.isClosed && this.child.connected && !this.child.killed) {
-            this.child.send?.({ type: 'rpc_response', id, result, error });
+        if (id && !this.isClosed && this.child.send && this.child.connected) {
+            const responseMessage = {
+                type: 'rpc_response',
+                id,
+                result: error ? undefined : result,
+                error: error ? String(error) : undefined
+            };
+            this.child.send(responseMessage);
         }
     }
     async init() {
         this.child.on('message', (msg) => {
-            if (msg.type === 'rpc_request') {
+            // Call generic message callback if registered
+            if (this.messageCallback) {
+                this.messageCallback(msg);
+            }
+            // Handle RPC requests specifically
+            if (msg && msg.type === 'rpc_request') {
                 const { id, method, args } = msg;
                 this.handle(method, args)
                     .then((result) => this.response(id, result, null))
@@ -42,5 +55,9 @@ class RpcProcessor {
             this.isClosed = true;
         });
     }
+    close() {
+        this.isClosed = true;
+        this.messageCallback = undefined;
+    }
 }
 exports.RpcProcessor = RpcProcessor;

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

@@ -0,0 +1,22 @@
+import { ChildProcess } from 'child_process';
+import { RpcProcessorInterface, RpcHandler, MessageCallback } from './process-communication/rpc-processor-interface';
+export type RpcMessage = {
+    type: 'rpc_request';
+    id: string | undefined;
+    method: string;
+    args: unknown;
+};
+export declare class RpcStdinProcessor implements RpcProcessorInterface {
+    private child;
+    private handlers;
+    private messageCallback?;
+    private isClosed;
+    private rl?;
+    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;
+}

package/dist/src/step-handler-rpc-stdin-processor.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 });
+exports.RpcStdinProcessor = void 0;
+const readline_1 = __importDefault(require("readline"));
+class RpcStdinProcessor {
+    constructor(child) {
+        this.child = child;
+        this.handlers = {};
+        this.isClosed = false;
+    }
+    handler(method, handler) {
+        this.handlers[method] = handler;
+    }
+    onMessage(callback) {
+        this.messageCallback = callback;
+    }
+    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.isClosed && this.child.stdin && !this.child.killed) {
+            const responseMessage = {
+                type: 'rpc_response',
+                id,
+                result: error ? undefined : result,
+                error: error ? String(error) : undefined
+            };
+            const messageStr = JSON.stringify(responseMessage);
+            this.child.stdin.write(messageStr + '\n');
+        }
+    }
+    async init() {
+        if (this.child.stdout) {
+            this.rl = readline_1.default.createInterface({
+                input: this.child.stdout,
+                crlfDelay: Infinity
+            });
+            this.rl.on('line', (line) => {
+                try {
+                    const msg = JSON.parse(line.trim());
+                    // Call generic message callback if registered
+                    if (this.messageCallback) {
+                        this.messageCallback(msg);
+                    }
+                    // Handle RPC requests specifically
+                    if (msg && 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));
+                    }
+                }
+                catch (error) {
+                    console.error('Failed to parse RPC message:', error, 'Raw line:', line);
+                }
+            });
+            this.rl.on('close', () => {
+                this.isClosed = true;
+            });
+        }
+        this.child.on('exit', () => {
+            this.isClosed = true;
+        });
+        this.child.on('close', () => {
+            this.isClosed = true;
+        });
+    }
+    close() {
+        this.isClosed = true;
+        this.messageCallback = undefined;
+        if (this.rl) {
+            this.rl.close();
+        }
+    }
+}
+exports.RpcStdinProcessor = RpcStdinProcessor;

package/dist/src/streams/api-endpoints.d.ts

@@ -1,3 +1,2 @@
 import { LockedData } from '../locked-data';
-import { InternalStateManager } from '../types';
-export declare const apiEndpoints: (lockedData: LockedData, state: InternalStateManager) => void;
+export declare const apiEndpoints: (lockedData: LockedData) => void;

package/dist/src/streams/api-endpoints.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiEndpoints = void 0;
 const guards_1 = require("../guards");
+const state_stream_1 = require("../state-stream");
 const mapEndpoint = (step) => {
     return {
         id: step.filePath,
@@ -13,8 +14,9 @@ const mapEndpoint = (step) => {
         bodySchema: step.config.bodySchema,
     };
 };
-class ApiEndpointsStream {
+class ApiEndpointsStream extends state_stream_1.StateStream {
     constructor(lockedData) {
+        super();
         this.lockedData = lockedData;
     }
     async get(id) {
@@ -34,12 +36,16 @@ class ApiEndpointsStream {
         return this.lockedData.apiSteps().map(mapEndpoint);
     }
     getGroupId() {
+        /**
+         * We're making it static to default because we only have one group of api endpoints
+         *
+         * In the future, we might want to have group of endpoints by Flows
+         */
         return 'default';
     }
-    async send() { }
 }
-const apiEndpoints = (lockedData, state) => {
-    const streamFactory = lockedData.createStream({
+const apiEndpoints = (lockedData) => {
+    const stream = lockedData.createStream({
         filePath: '__motia.api-endpoints.ts',
         hidden: true,
         config: {
@@ -47,10 +53,10 @@ const apiEndpoints = (lockedData, state) => {
             baseConfig: { storageType: 'custom', factory: () => new ApiEndpointsStream(lockedData) },
             schema: null,
         },
-    });
+    })();
     const apiStepCreated = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            streamFactory(state).create(step.filePath, {
+            stream.create(step.filePath, {
                 id: step.filePath,
                 method: step.config.method,
                 path: step.config.path,
@@ -61,12 +67,12 @@ const apiEndpoints = (lockedData, state) => {
     };
     const apiStepUpdated = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            streamFactory(state).update(step.filePath, mapEndpoint(step));
+            stream.update(step.filePath, mapEndpoint(step));
         }
     };
     const apiStepRemoved = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            streamFactory(state).delete(step.filePath);
+            stream.delete(step.filePath);
         }
     };
     lockedData.onStep('step-created', apiStepCreated);

package/dist/src/streams/flows-stream.d.ts

@@ -1,10 +1,10 @@
 import { LockedData } from '../locked-data';
-import { IStateStream } from '../types';
+import { StateStream } from '../state-stream';
 export type Flow = {
     id: string;
     name: string;
 };
-export declare class FlowsStream implements IStateStream<Flow> {
+export declare class FlowsStream extends StateStream<Flow> {
     private readonly lockedData;
     constructor(lockedData: LockedData);
     get(id: string): Promise<Flow | null>;
@@ -13,5 +13,4 @@ export declare class FlowsStream implements IStateStream<Flow> {
     create(_: string, data: Flow): Promise<Flow>;
     getList(): Promise<Flow[]>;
     getGroupId(): string;
-    send(): Promise<void>;
 }

package/dist/src/streams/flows-stream.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsStream = void 0;
-class FlowsStream {
+const state_stream_1 = require("../state-stream");
+class FlowsStream extends state_stream_1.StateStream {
     constructor(lockedData) {
+        super();
         this.lockedData = lockedData;
     }
     async get(id) {
@@ -20,11 +22,17 @@ class FlowsStream {
         return data;
     }
     async getList() {
+        /**
+         * Get list should receive a groupId argument but that's irrelevant for this stream
+         * since we only have one group of flows.
+         */
         return Object.entries(this.lockedData.flows).map(([id, flow]) => ({ id, name: flow.name }));
     }
     getGroupId() {
+        /**
+         * We're making it static to default because we only have one group of flows
+         */
         return 'default';
     }
-    async send() { }
 }
 exports.FlowsStream = FlowsStream;

package/dist/src/streams/logs-stream.d.ts

@@ -1,4 +1,4 @@
-import { IStateStream, StateStreamEvent, StateStreamEventChannel } from '../types';
+import { StateStream } from '../state-stream';
 export type Log = {
     id: string;
     level: string;
@@ -8,12 +8,11 @@ export type Log = {
     flows: string[];
     [key: string]: any;
 };
-export declare class LogsStream implements IStateStream<Log> {
+export declare class LogsStream extends StateStream<Log> {
     get: () => Promise<null>;
     update: () => Promise<null>;
     delete: () => Promise<null>;
+    getList: () => Promise<never[]>;
+    getGroupId: () => null;
     create(_: string, data: Log): Promise<Log>;
-    getList(): Promise<Log[]>;
-    getGroupId(data: Log): string;
-    send<T>(_: StateStreamEventChannel, __: StateStreamEvent<T>): Promise<void>;
 }

package/dist/src/streams/logs-stream.js

@@ -1,23 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogsStream = void 0;
-class LogsStream {
+const state_stream_1 = require("../state-stream");
+/*
+ * We're not storing logs in the state because of size of data
+ * if process stays for to long it would consume too much memory
+ * in this case, we're just streaming through events.
+ */
+class LogsStream extends state_stream_1.StateStream {
     constructor() {
+        super(...arguments);
         this.get = async () => null;
         this.update = async () => null;
         this.delete = async () => null;
+        this.getList = async () => [];
+        this.getGroupId = () => null;
     }
     async create(_, data) {
         await this.send({ groupId: 'default' }, { type: 'log', data });
         return data;
     }
-    async getList() {
-        return [];
-    }
-    getGroupId(data) {
-        return data.traceId;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async send(_, __) { }
 }
 exports.LogsStream = LogsStream;

package/dist/src/types/generate-types.d.ts

@@ -1,5 +1,6 @@
 import { Printer } from '../printer';
-import { Step, Stream } from '../types';
+import { Step } from '../types';
+import { Stream } from '../types-stream';
 type HandlersMap = Record<string, {
     type: string;
     generics: string[];

package/dist/src/types-stream.d.ts

@@ -0,0 +1,38 @@
+import { ZodObject } from 'zod';
+export interface StateStreamConfig {
+    name: string;
+    schema: ZodObject<any>;
+    baseConfig: {
+        storageType: 'state';
+        property: string;
+    } | {
+        storageType: 'custom';
+        factory: () => IStateStream<any>;
+    };
+}
+export type StateStreamEventChannel = {
+    id: string;
+} | {
+    groupId: string;
+};
+export type StateStreamEvent<TData> = {
+    type: string;
+    data: TData;
+};
+export type BaseStreamItem<TData = unknown> = TData & {
+    id: string;
+};
+export type Stream<TConfig extends StateStreamConfig = StateStreamConfig> = {
+    filePath: string;
+    config: TConfig;
+    hidden?: boolean;
+};
+export interface IStateStream<TData> {
+    get(id: string): Promise<BaseStreamItem<TData> | null>;
+    update(id: string, data: TData): Promise<BaseStreamItem<TData> | null>;
+    delete(id: string): Promise<BaseStreamItem<TData> | null>;
+    create(id: string, data: TData): Promise<BaseStreamItem<TData>>;
+    getGroupId(data: TData): string | null;
+    getList(groupId: string): Promise<BaseStreamItem<TData>[]>;
+    send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;
+}

package/dist/src/types-stream.js

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

package/dist/src/types.d.ts

@@ -13,38 +13,6 @@ export type EmitData = {
 export type Emitter<TData> = (event: TData) => Promise<void>;
 export interface FlowContextStateStreams {
 }
-export interface StateStreamConfig {
-    name: string;
-    schema: ZodObject<any>;
-    baseConfig: {
-        storageType: 'state';
-        property: string;
-    } | {
-        storageType: 'custom';
-        factory: (state: InternalStateManager) => IStateStream<any>;
-    };
-}
-export type BaseStateStreamData = {
-    id: string;
-};
-export type StateStreamEventChannel = {
-    id: string;
-} | {
-    groupId: string;
-};
-export type StateStreamEvent<TData> = {
-    type: string;
-    data: TData;
-};
-export interface IStateStream<TData extends BaseStateStreamData> {
-    get(id: string): Promise<TData | null>;
-    update(id: string, data: Omit<TData, 'id'>): Promise<TData | null>;
-    delete(id: string): Promise<TData | null>;
-    create(id: string, data: Omit<TData, 'id'>): Promise<TData>;
-    getGroupId(data: TData): string | null;
-    getList(groupId: string): Promise<TData[]>;
-    send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;
-}
 export interface FlowContext<TEmitData = never> {
     emit: Emitter<TEmitData>;
     traceId: string;
@@ -179,11 +147,6 @@ export type Step<TConfig extends StepConfig = StepConfig> = {
     version: string;
     config: TConfig;
 };
-export type Stream<TConfig extends StateStreamConfig = StateStreamConfig> = {
-    filePath: string;
-    config: TConfig;
-    hidden?: boolean;
-};
 export type Flow = {
     name: string;
     description?: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@motiadev/core",
   "description": "Core functionality for the Motia framework, providing the foundation for building event-driven workflows.",
   "main": "dist/index.js",
-  "version": "0.2.1-beta.47",
+  "version": "0.2.1-beta.49",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",