@motiadev/core 0.2.1-beta.55 → 0.2.1-beta.56

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export { getStepConfig, getStreamConfig } from './src/get-step-config';
 export { StateAdapter } from './src/state/state-adapter';
 export { createMermaidGenerator } from './src/mermaid-generator';
 export { StateStream } from './src/state-stream';
-export { StateStreamConfig, Stream } from './src/types-stream';
+export { StateStreamConfig, IStateStream } from './src/types-stream';

package/dist/src/call-step-file.js

@@ -44,9 +44,11 @@ const callStepFile = (options) => {
             command,
             args: [...args, runner, step.filePath, jsonData],
             logger,
-            context: 'StepExecution'
+            context: 'StepExecution',
         });
-        processManager.spawn().then(() => {
+        processManager
+            .spawn()
+            .then(() => {
             // Register all step handlers
             processManager.handler('close', async () => processManager.kill());
             processManager.handler('log', async (input) => logger.log(input));
@@ -54,6 +56,7 @@ const callStepFile = (options) => {
             processManager.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
             processManager.handler('state.delete', (input) => state.delete(input.traceId, input.key));
             processManager.handler('state.clear', (input) => state.clear(input.traceId));
+            processManager.handler(`state.getGroup`, (input) => state.getGroup(input.groupId));
             processManager.handler('result', async (input) => {
                 result = input;
             });
@@ -65,10 +68,10 @@ const callStepFile = (options) => {
             });
             Object.entries(streamConfig).forEach(([name, streamFactory]) => {
                 const stateStream = streamFactory();
-                processManager.handler(`streams.${name}.get`, (input) => stateStream.get(input.id));
-                processManager.handler(`streams.${name}.update`, (input) => stateStream.update(input.id, input.data));
-                processManager.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.id));
-                processManager.handler(`streams.${name}.create`, (input) => stateStream.create(input.id, input.data));
+                processManager.handler(`streams.${name}.get`, (input) => stateStream.get(input.groupId, input.id));
+                processManager.handler(`streams.${name}.set`, (input) => stateStream.set(input.groupId, input.id, input.data));
+                processManager.handler(`streams.${name}.delete`, (input) => stateStream.delete(input.groupId, input.id));
+                processManager.handler(`streams.${name}.getGroup`, (input) => stateStream.getGroup(input.groupId));
             });
             processManager.onStdout((data) => {
                 try {
@@ -101,7 +104,8 @@ const callStepFile = (options) => {
                     reject(error);
                 }
             });
-        }).catch((error) => {
+        })
+            .catch((error) => {
             reject(`Failed to spawn process: ${error}`);
         });
     });

package/dist/src/flows-endpoint.js

@@ -21,9 +21,9 @@ const flowsEndpoint = (lockedData, app) => {
             baseConfig: { storageType: 'custom', factory: () => new flows_stream_1.FlowsStream(lockedData) },
         },
     }, { disableTypeCreation: true })();
-    lockedData.on('flow-created', (flow) => flowsStream.create(flow, { id: flow, name: flow }));
-    lockedData.on('flow-updated', (flow) => flowsStream.update(flow, { id: flow, name: flow }));
-    lockedData.on('flow-removed', (flow) => flowsStream.delete(flow));
+    lockedData.on('flow-created', (flow) => flowsStream.set('default', flow, { id: flow, name: flow }));
+    lockedData.on('flow-updated', (flow) => flowsStream.set('default', flow, { id: flow, name: flow }));
+    lockedData.on('flow-removed', (flow) => flowsStream.delete('default', flow));
     app.get('/flows/:id', async (req, res) => {
         const flowId = req.params.id;
         const flow = lockedData.flows[flowId];

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

@@ -37,14 +37,16 @@ const getConfig = (file) => {
             command,
             args: [...args, runner, file],
             logger: logger_1.globalLogger,
-            context: 'Config'
+            context: 'Config',
         });
-        processManager.spawn().then(() => {
+        processManager
+            .spawn()
+            .then(() => {
             processManager.onMessage((message) => {
                 config = message;
                 logger_1.globalLogger.debug(`[Config] Read config via ${processManager.commType?.toUpperCase()}`, {
                     config,
-                    communicationType: processManager.commType
+                    communicationType: processManager.commType,
                 });
                 resolve(config);
                 processManager.kill();
@@ -70,7 +72,8 @@ const getConfig = (file) => {
                     reject(error);
                 }
             });
-        }).catch((error) => {
+        })
+            .catch((error) => {
             reject(`Failed to spawn process: ${error}`);
         });
     });

package/dist/src/locked-data.js

@@ -199,8 +199,7 @@ class LockedData {
         this.streamHandlers['stream-created'].forEach((handler) => handler(stream));
         let factory;
         if (stream.config.baseConfig.storageType === 'state') {
-            const property = stream.config.baseConfig.property;
-            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state, property));
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
         }
         else {
             factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
@@ -235,8 +234,7 @@ class LockedData {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let factory;
         if (stream.config.baseConfig.storageType === 'state') {
-            const property = stream.config.baseConfig.property;
-            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state, property));
+            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
         }
         else {
             factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);

package/dist/src/logger.js

@@ -71,7 +71,7 @@ class Logger extends BaseLogger {
         };
         this.emitLog = (level, msg, args) => {
             const id = (0, crypto_1.randomUUID)();
-            this.logStream?.create(id, {
+            this.logStream?.set('default', id, {
                 id,
                 step: this.step,
                 ...(args ?? {}),

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

@@ -40,12 +40,10 @@ async function runTypescriptModule(filePath, event) {
         const streamsConfig = event.streams;
         const streams = (streamsConfig ?? []).reduce((acc, streams) => {
             acc[streams.name] = {
-                get: (id) => sender.send(`streams.${streams.name}.get`, { id }),
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                update: (id, data) => sender.send(`streams.${streams.name}.update`, { id, data }),
-                delete: (id) => sender.send(`streams.${streams.name}.delete`, { id }),
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                create: (id, data) => sender.send(`streams.${streams.name}.create`, { id, data }),
+                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 }),
             };
             return acc;
         }, {});

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

@@ -7,4 +7,5 @@ export declare class RpcStateManager implements InternalStateManager {
     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[]>;
 }

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

@@ -17,5 +17,8 @@ class RpcStateManager {
     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/process-communication/communication-config.js

@@ -6,7 +6,7 @@ function createCommunicationConfig(command) {
     const spawnOptions = {
         stdio: type === 'rpc'
             ? ['pipe', 'pipe', 'inherit'] // RPC: capture stdout
-            : ['inherit', 'inherit', 'inherit', 'ipc'] // IPC: include IPC channel
+            : ['inherit', 'inherit', 'inherit', 'ipc'], // IPC: include IPC channel
     };
     return { type, spawnOptions };
 }

package/dist/src/process-communication/process-manager.js

@@ -17,14 +17,12 @@ class ProcessManager {
         logger.debug(`[${context}] Spawning process`, {
             command,
             args,
-            communicationType: this.communicationType
+            communicationType: this.communicationType,
         });
         // Spawn the process
         this.child = (0, child_process_1.spawn)(command, args, commConfig.spawnOptions);
         // Create appropriate processor based on communication type
-        this.processor = this.communicationType === 'rpc'
-            ? new step_handler_rpc_stdin_processor_1.RpcStdinProcessor(this.child)
-            : new step_handler_rpc_processor_1.RpcProcessor(this.child);
+        this.processor = this.communicationType === 'rpc' ? new step_handler_rpc_stdin_processor_1.RpcStdinProcessor(this.child) : new step_handler_rpc_processor_1.RpcProcessor(this.child);
         // Initialize the processor
         await this.processor.init();
         return this.child;

package/dist/src/server.js

@@ -8,7 +8,6 @@ const cron_handler_1 = require("./cron-handler");
 const body_parser_1 = __importDefault(require("body-parser"));
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
-const multer_1 = __importDefault(require("multer"));
 const cors_1 = __importDefault(require("cors"));
 const flows_endpoint_1 = require("./flows-endpoint");
 const guards_1 = require("./guards");
@@ -25,14 +24,13 @@ const createServer = async (lockedData, eventManager, state, config) => {
     const printer = lockedData.printer;
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
-    const upload = (0, multer_1.default)();
     const { pushEvent, socketServer } = (0, socket_server_1.createSocketServer)({
         server,
-        onJoin: async (streamName, id) => {
+        onJoin: async (streamName, groupId, id) => {
             const streams = lockedData.getStreams();
             const stream = streams[streamName];
             if (stream) {
-                const result = await stream().get(id);
+                const result = await stream().get(groupId, id);
                 delete result.__motia; // deleting because we don't need it in the socket
                 return result;
             }
@@ -41,7 +39,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
             const streams = lockedData.getStreams();
             const stream = streams[streamName];
             if (stream) {
-                const result = stream ? await stream().getList(groupId) : [];
+                const result = stream ? await stream().getGroup(groupId) : [];
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 return result.map(({ __motia, ...rest }) => rest);
             }
@@ -60,46 +58,29 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 async send(channel, event) {
                     pushEvent({ streamName, ...channel, event: { type: 'event', event } });
                 },
-                async get(id) {
-                    const result = await suuper.get.apply(wrapper, [id]);
+                async get(groupId, id) {
+                    const result = await suuper.get.apply(wrapper, [groupId, id]);
                     return wrapObject(id, result);
                 },
-                async update(id, data) {
+                async set(groupId, id, data) {
                     if (!data) {
                         return null;
                     }
-                    const updated = await suuper.update.apply(wrapper, [id, data]);
+                    const exists = await suuper.get(groupId, id);
+                    const updated = await suuper.set.apply(wrapper, [groupId, id, data]);
                     const result = updated ?? data;
                     const wrappedResult = wrapObject(id, result);
-                    const groupId = suuper.getGroupId(result);
-                    pushEvent({ streamName, id, event: { type: 'update', data: result } });
-                    if (groupId) {
-                        pushEvent({ streamName, groupId, event: { type: 'update', data: result } });
-                    }
+                    const type = exists ? 'update' : 'create';
+                    pushEvent({ streamName, groupId, id, event: { type, data: result } });
                     return wrappedResult;
                 },
-                async delete(id) {
-                    const result = await suuper.delete.apply(wrapper, [id]);
-                    const groupId = result && suuper.getGroupId(result);
-                    pushEvent({ streamName, id, event: { type: 'delete', data: result } });
-                    if (groupId) {
-                        pushEvent({ streamName, groupId, event: { type: 'delete', data: result } });
-                    }
+                async delete(groupId, id) {
+                    const result = await suuper.delete.apply(wrapper, [groupId, id]);
+                    pushEvent({ streamName, groupId, id, event: { type: 'delete', data: result } });
                     return wrapObject(id, result);
                 },
-                async create(id, data) {
-                    const created = await suuper.create.apply(wrapper, [id, data]);
-                    const result = created ?? data;
-                    const wrappedResult = wrapObject(id, result);
-                    const groupId = suuper.getGroupId(result);
-                    pushEvent({ streamName, id, event: { type: 'create', data: result } });
-                    if (groupId) {
-                        pushEvent({ streamName, groupId, event: { type: 'create', data: result } });
-                    }
-                    return wrappedResult;
-                },
-                getList: async (groupId) => {
-                    const list = await suuper.getList.apply(wrapper, [groupId]);
+                async getGroup(groupId) {
+                    const list = await suuper.getGroup.apply(wrapper, [groupId]);
                     return list.map((object) => wrapObject(object.id, object));
                 },
             };
@@ -129,7 +110,6 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 headers: req.headers,
                 pathParams: req.params,
                 queryParams: req.query,
-                files: req.files,
             };
             try {
                 const data = request;
@@ -170,10 +150,10 @@ const createServer = async (lockedData, eventManager, state, config) => {
         const handler = asyncHandler(step);
         const methods = {
             GET: () => router.get(path, handler),
-            POST: () => router.post(path, upload.any(), handler),
-            PUT: () => router.put(path, upload.any(), handler),
+            POST: () => router.post(path, handler),
+            PUT: () => router.put(path, handler),
             DELETE: () => router.delete(path, handler),
-            PATCH: () => router.patch(path, upload.any(), handler),
+            PATCH: () => router.patch(path, handler),
             OPTIONS: () => router.options(path, handler),
             HEAD: () => router.head(path, handler),
         };

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

@@ -2,11 +2,9 @@ import { Server as WsServer } from 'ws';
 import http from 'http';
 type BaseMessage = {
     streamName: string;
-} & ({
-    id: string;
-} | {
     groupId: string;
-});
+    id?: string;
+};
 type StreamEvent<TData> = {
     type: 'sync';
     data: TData;
@@ -31,7 +29,7 @@ type EventMessage<TData> = BaseMessage & {
 };
 type Props = {
     server: http.Server;
-    onJoin: <TData>(streamName: string, id: string) => Promise<TData>;
+    onJoin: <TData>(streamName: string, groupId: string, id: string) => Promise<TData>;
     onJoinGroup: <TData>(streamName: string, groupId: string) => Promise<TData[] | undefined>;
 };
 export declare const createSocketServer: ({ server, onJoin, onJoinGroup }: Props) => {

package/dist/src/socket-server.js

@@ -7,9 +7,7 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
     const rooms = {};
     const subscriptions = new Map();
     const getRoom = (message) => {
-        return 'id' in message
-            ? `${message.streamName}:id:${message.id}`
-            : `${message.streamName}:group-id:${message.groupId}`;
+        return message.id ? `${message.streamName}:id:${message.id}` : `${message.streamName}:group-id:${message.groupId}`;
     };
     socketServer.on('connection', (socket) => {
         subscriptions.set(socket, new Set());
@@ -20,11 +18,12 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
                 if (!rooms[room]) {
                     rooms[room] = new Map();
                 }
-                if ('id' in message.data) {
-                    const item = await onJoin(message.data.streamName, message.data.id);
+                if (message.data.id) {
+                    const item = await onJoin(message.data.streamName, message.data.groupId, message.data.id);
                     if (item) {
                         const resultMessage = {
                             streamName: message.data.streamName,
+                            groupId: message.data.groupId,
                             id: message.data.id,
                             event: { type: 'sync', data: item },
                         };
@@ -60,9 +59,16 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
         });
     });
     const pushEvent = (message) => {
-        const room = getRoom(message);
-        if (rooms[room]) {
-            rooms[room].forEach((socket) => socket.send(JSON.stringify(message)));
+        const { groupId, streamName, id } = message;
+        const groupRoom = getRoom({ streamName, groupId });
+        if (rooms[groupRoom]) {
+            rooms[groupRoom].forEach((socket) => socket.send(JSON.stringify(message)));
+        }
+        if (id) {
+            const itemRoom = getRoom({ groupId, streamName, id });
+            if (rooms[itemRoom]) {
+                rooms[itemRoom].forEach((socket) => socket.send(JSON.stringify(message)));
+            }
         }
     };
     return { pushEvent, socketServer };

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

@@ -7,6 +7,7 @@ export declare class FileStateAdapter implements StateAdapter {
     private filePath;
     constructor(config: FileAdapterConfig);
     init(): Promise<void>;
+    getGroup<T>(groupId: string): Promise<T[]>;
     get<T>(traceId: string, key: string): Promise<T | null>;
     set<T>(traceId: string, key: string, value: T): Promise<T>;
     delete<T>(traceId: string, key: string): Promise<T | null>;

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

@@ -58,6 +58,12 @@ class FileStateAdapter {
             fs_1.default.writeFileSync(this.filePath, JSON.stringify({}), 'utf-8');
         }
     }
+    async getGroup(groupId) {
+        const data = this._readFile();
+        return Object.entries(data)
+            .filter(([key]) => key.startsWith(groupId))
+            .map(([, value]) => JSON.parse(value));
+    }
     async get(traceId, key) {
         const data = this._readFile();
         const fullKey = this._makeKey(traceId, key);

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

@@ -2,6 +2,7 @@ import { StateAdapter } from '../state-adapter';
 export declare class MemoryStateAdapter implements StateAdapter {
     private state;
     init(): Promise<void>;
+    getGroup<T>(groupId: string): Promise<T[]>;
     get<T>(traceId: string, key: string): Promise<T | null>;
     set<T>(traceId: string, key: string, value: T): Promise<T>;
     delete<T>(traceId: string, key: string): Promise<T | null>;

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

@@ -8,6 +8,11 @@ class MemoryStateAdapter {
     async init() {
         this.state = {};
     }
+    async getGroup(groupId) {
+        return Object.entries(this.state)
+            .filter(([key]) => key.startsWith(groupId))
+            .map(([, value]) => value);
+    }
     async get(traceId, key) {
         const fullKey = this._makeKey(traceId, key);
         return this.state[fullKey] ? this.state[fullKey] : null;

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

@@ -3,9 +3,6 @@ import { InternalStateManager } from '../types';
  * Interface for state management adapters
  */
 export interface StateAdapter extends InternalStateManager {
-    get<T>(traceId: string, key: string): Promise<T | null>;
-    set<T>(traceId: string, key: string, value: T): Promise<T>;
-    delete<T>(traceId: string, key: string): Promise<T | null>;
     clear(traceId: string): Promise<void>;
     cleanup(): Promise<void>;
     keys(traceId: string): Promise<string[]>;

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

@@ -2,23 +2,18 @@ import type { InternalStateManager } from './types';
 import type { BaseStreamItem, IStateStream, StateStreamEvent, StateStreamEventChannel } from './types-stream';
 export type StateStreamFactory<TData> = () => IStateStream<TData>;
 export declare abstract class StateStream<TData> implements IStateStream<TData> {
-    abstract get(id: string): Promise<BaseStreamItem<TData> | null>;
-    abstract update(id: string, data: TData): Promise<BaseStreamItem<TData> | null>;
-    abstract delete(id: string): Promise<BaseStreamItem<TData> | null>;
-    abstract create(id: string, data: TData): Promise<BaseStreamItem<TData>>;
-    abstract getGroupId(data: TData): string | null;
-    abstract getList(groupId: string): Promise<BaseStreamItem<TData>[]>;
+    abstract get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    abstract set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData> | null>;
+    abstract delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    abstract getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
     send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;
 }
 export declare class InternalStateStream<TData> extends StateStream<TData> {
     private readonly state;
-    private readonly propertyName;
-    constructor(state: InternalStateManager, propertyName: string);
-    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(): null;
-    getList(): Promise<never[]>;
+    constructor(state: InternalStateManager);
+    get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData> | null>;
+    delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
     send(): Promise<void>;
 }

package/dist/src/state-stream.js

@@ -7,29 +7,21 @@ class StateStream {
 }
 exports.StateStream = StateStream;
 class InternalStateStream extends StateStream {
-    constructor(state, propertyName) {
+    constructor(state) {
         super();
         this.state = state;
-        this.propertyName = propertyName;
     }
-    async get(id) {
-        return this.state.get(id, this.propertyName);
+    async get(groupId, id) {
+        return this.state.get(groupId, id);
     }
-    async update(id, data) {
-        return this.state.set(id, this.propertyName, { ...data, id });
+    async set(groupId, id, data) {
+        return this.state.set(groupId, id, { id, ...data });
     }
-    async delete(id) {
-        const data = await this.state.delete(id, this.propertyName);
-        return data;
+    async delete(groupId, id) {
+        return this.state.delete(groupId, id);
     }
-    async create(id, data) {
-        return this.state.set(id, this.propertyName, { ...data, id });
-    }
-    getGroupId() {
-        return null;
-    }
-    async getList() {
-        return [];
+    async getGroup(groupId) {
+        return this.state.getGroup(groupId);
     }
     async send() { }
 }

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

@@ -4,6 +4,7 @@ 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;
     }
@@ -26,12 +27,13 @@ class RpcProcessor {
                 type: 'rpc_response',
                 id,
                 result: error ? undefined : result,
-                error: error ? String(error) : undefined
+                error: error ? String(error) : undefined,
             };
             this.child.send(responseMessage);
         }
     }
     async init() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.child.on('message', (msg) => {
             // Call generic message callback if registered
             if (this.messageCallback) {

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

@@ -8,6 +8,7 @@ const readline_1 = __importDefault(require("readline"));
 class RpcStdinProcessor {
     constructor(child) {
         this.child = child;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.handlers = {};
         this.isClosed = false;
     }
@@ -30,7 +31,7 @@ class RpcStdinProcessor {
                 type: 'rpc_response',
                 id,
                 result: error ? undefined : result,
-                error: error ? String(error) : undefined
+                error: error ? String(error) : undefined,
             };
             const messageStr = JSON.stringify(responseMessage);
             this.child.stdin.write(messageStr + '\n');
@@ -40,7 +41,7 @@ class RpcStdinProcessor {
         if (this.child.stdout) {
             this.rl = readline_1.default.createInterface({
                 input: this.child.stdout,
-                crlfDelay: Infinity
+                crlfDelay: Infinity,
             });
             this.rl.on('line', (line) => {
                 try {

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

@@ -23,26 +23,15 @@ class ApiEndpointsStream extends state_stream_1.StateStream {
         const endpoint = this.lockedData.apiSteps().find((step) => step.config.path === id);
         return endpoint ? mapEndpoint(endpoint) : null;
     }
-    async update(_, data) {
-        return data;
-    }
     async delete(id) {
         return { id };
     }
-    async create(_, data) {
+    async set(_, __, data) {
         return data;
     }
-    async getList() {
+    async getGroup() {
         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';
-    }
 }
 const apiEndpoints = (lockedData) => {
     const stream = lockedData.createStream({
@@ -56,7 +45,7 @@ const apiEndpoints = (lockedData) => {
     })();
     const apiStepCreated = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            stream.create(step.filePath, {
+            stream.set('default', step.filePath, {
                 id: step.filePath,
                 method: step.config.method,
                 path: step.config.path,
@@ -67,12 +56,12 @@ const apiEndpoints = (lockedData) => {
     };
     const apiStepUpdated = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            stream.update(step.filePath, mapEndpoint(step));
+            stream.set('default', step.filePath, mapEndpoint(step));
         }
     };
     const apiStepRemoved = (step) => {
         if ((0, guards_1.isApiStep)(step)) {
-            stream.delete(step.filePath);
+            stream.delete('default', step.filePath);
         }
     };
     lockedData.onStep('step-created', apiStepCreated);

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

@@ -8,9 +8,7 @@ export declare class FlowsStream extends StateStream<Flow> {
     private readonly lockedData;
     constructor(lockedData: LockedData);
     get(id: string): Promise<Flow | null>;
-    update(id: string, data: Flow): Promise<Flow | null>;
     delete(id: string): Promise<Flow | null>;
-    create(_: string, data: Flow): Promise<Flow>;
-    getList(): Promise<Flow[]>;
-    getGroupId(): string;
+    set(_: string, __: string, data: Flow): Promise<Flow>;
+    getGroup(): Promise<Flow[]>;
 }