@motiadev/core 0.2.1-beta.73 → 0.2.1-beta.74

package/dist/src/locked-data.d.ts

@@ -32,6 +32,7 @@ export declare class LockedData {
     pythonSteps(): Step[];
     tsSteps(): Step[];
     getStreams(): Record<string, StateStreamFactory<any>>;
+    listStreams(): Stream[];
     findStream(path: string): Stream | undefined;
     updateStep(oldStep: Step, newStep: Step, options?: {
         disableTypeCreation?: boolean;
@@ -43,7 +44,7 @@ export declare class LockedData {
         disableTypeCreation?: boolean;
     }): void;
     private createFactoryWrapper;
-    createStream<TData>(stream: Stream, options?: {
+    createStream<TData>(baseStream: Omit<Stream, 'factory'>, options?: {
         disableTypeCreation?: boolean;
     }): StateStreamFactory<TData>;
     deleteStream(stream: Stream, options?: {

package/dist/src/locked-data.js

@@ -79,14 +79,13 @@ class LockedData {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const streams = {};
         for (const [key, value] of Object.entries(this.streams)) {
-            const baseConfig = value.config.baseConfig;
-            const streamFactory = baseConfig.storageType === 'custom' ? baseConfig.factory : null;
-            if (streamFactory) {
-                streams[key] = streamFactory;
-            }
+            streams[key] = value.factory;
         }
         return streams;
     }
+    listStreams() {
+        return Object.values(this.streams);
+    }
     findStream(path) {
         return Object.values(this.streams).find((stream) => stream.filePath === path);
     }
@@ -197,24 +196,23 @@ class LockedData {
             return streamFactory();
         };
     }
-    createStream(stream, options = {}) {
+    createStream(baseStream, options = {}) {
+        const stream = baseStream;
         this.streams[stream.config.name] = stream;
         this.streamHandlers['stream-created'].forEach((handler) => handler(stream));
-        let factory;
         if (stream.config.baseConfig.storageType === 'state') {
-            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+            stream.factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
         }
         else {
-            factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
+            stream.factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
         }
-        stream.config.baseConfig = { storageType: 'custom', factory };
         if (!stream.hidden) {
             this.printer.printStreamCreated(stream);
             if (!options.disableTypeCreation) {
                 this.saveTypes();
             }
         }
-        return factory;
+        return stream.factory;
     }
     deleteStream(stream, options = {}) {
         Object.entries(this.streams).forEach(([streamName, { filePath }]) => {
@@ -234,15 +232,12 @@ class LockedData {
         if (oldStream.config.name !== stream.config.name) {
             delete this.streams[oldStream.config.name];
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let factory;
         if (stream.config.baseConfig.storageType === 'state') {
-            factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+            stream.factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
         }
         else {
-            factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
+            stream.factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
         }
-        stream.config.baseConfig = { storageType: 'custom', factory };
         this.streams[stream.config.name] = stream;
         this.streamHandlers['stream-updated'].forEach((handler) => handler(stream));
         if (!stream.hidden) {

package/dist/src/python/context.py

@@ -3,6 +3,7 @@ from type_definitions import HandlerResult
 from rpc import RpcSender
 from rpc_state_manager import RpcStateManager
 from logger import Logger
+from dot_dict import DotDict
 
 class Context:
     def __init__(
@@ -10,11 +11,13 @@ class Context:
         trace_id: str,
         flows: List[str],
         rpc: RpcSender,
+        streams: DotDict,
     ):
         self.trace_id = trace_id
         self.flows = flows
         self.rpc = rpc
         self.state = RpcStateManager(rpc)
+        self.streams = streams
         self.logger = Logger(self.trace_id, self.flows, rpc)
 
     async def emit(self, event: Any) -> Optional[HandlerResult]:

package/dist/src/python/dot_dict.py

@@ -0,0 +1,16 @@
+class DotDict(dict):
+    def __getattr__(self, key):
+        try:
+            value = self[key]
+            return DotDict(value) if isinstance(value, dict) else value
+        except KeyError:
+            raise AttributeError(f"No such attribute: {key}")
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __delattr__(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"No such attribute: {key}")

package/dist/src/python/python-runner.py

@@ -5,12 +5,13 @@ import os
 import asyncio
 import traceback
 from typing import Optional, Any, Callable, List, Dict
-
 from rpc import RpcSender
 from type_definitions import FlowConfig, ApiResponse
 from context import Context
 from validation import validate_with_jsonschema
 from middleware import compose_middleware
+from rpc_stream_manager import RpcStreamManager
+from dot_dict import DotDict
 
 def parse_args(arg: str) -> Dict:
     """Parse command line arguments into HandlerArgs"""
@@ -84,7 +85,14 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
         flows = args.get("flows") or []
         data = args.get("data")
         context_in_first_arg = args.get("contextInFirstArg")
-        context = Context(trace_id, flows, rpc)
+        streams_config = args.get("streams") or []
+
+        streams = DotDict()
+        for item in streams_config:
+            name = item.get("name")
+            streams[name] = RpcStreamManager(name, rpc)
+        
+        context = Context(trace_id, flows, rpc, streams)
 
         validation_result = await validate_handler_input(module, args, context, is_api_handler)
         if validation_result:

package/dist/src/python/rpc_stream_manager.py

@@ -0,0 +1,50 @@
+from typing import Any
+import asyncio
+from rpc import RpcSender
+import functools
+import sys
+
+class RpcStreamManager:
+    def __init__(self, stream_name: str,rpc: RpcSender):
+        self.rpc = rpc
+        self.stream_name = stream_name
+        self._loop = asyncio.get_event_loop()
+
+    async def get(self, group_id: str, id: str) -> asyncio.Future[Any]:
+        result = await self.rpc.send(f'streams.{self.stream_name}.get', {'groupId': group_id, 'id': id})
+        return result
+
+    async def set(self, group_id: str, id: str, data: Any) -> asyncio.Future[None]:
+        future = await self.rpc.send(f'streams.{self.stream_name}.set', {'groupId': group_id, 'id': id, 'data': data})
+        return future
+
+    async def delete(self, group_id: str, id: str) -> asyncio.Future[None]:
+        return await self.rpc.send(f'streams.{self.stream_name}.delete', {'groupId': group_id, 'id': id})
+
+    async def getGroup(self, group_id: str) -> asyncio.Future[None]:
+        return await self.rpc.send(f'streams.{self.stream_name}.getGroup', {'groupId': group_id})
+
+    # Add wrappers to handle non-awaited coroutines
+    def __getattribute__(self, name):
+        attr = super().__getattribute__(name)
+        if name in ('get', 'set', 'delete', 'getGroup') and asyncio.iscoroutinefunction(attr):
+            @functools.wraps(attr)
+            def wrapper(*args, **kwargs):
+                coro = attr(*args, **kwargs)
+                # Check if this is being awaited
+                frame = sys._getframe(1)
+                if frame.f_code.co_name != '__await__':
+                    # Not being awaited, schedule in background
+                    # But we need to make sure this task completes before the handler returns
+                    # So we'll return the task for the caller to await if needed
+                    task = asyncio.create_task(coro)
+                    # Add error handling for the background task
+                    def handle_exception(t):
+                        if t.done() and not t.cancelled() and t.exception():
+                            print(f"Unhandled exception in background task: {t.exception()}", file=sys.stderr)
+                    task.add_done_callback(handle_exception)
+                    return task
+                # Being awaited, return coroutine as normal
+                return coro
+            return wrapper
+        return attr

package/dist/src/server.js

@@ -51,9 +51,9 @@ const createServer = async (lockedData, eventManager, state, config) => {
         return () => {
             const suuper = stream();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const wrapObject = (id, object) => ({
+            const wrapObject = (groupId, id, object) => ({
                 ...object,
-                __motia: { type: 'state-stream', streamName, id },
+                __motia: { type: 'state-stream', streamName, groupId, id },
             });
             const wrapper = {
                 ...suuper,
@@ -62,7 +62,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 },
                 async get(groupId, id) {
                     const result = await suuper.get.apply(wrapper, [groupId, id]);
-                    return wrapObject(id, result);
+                    return wrapObject(groupId, id, result);
                 },
                 async set(groupId, id, data) {
                     if (!data) {
@@ -71,7 +71,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
                     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 wrappedResult = wrapObject(groupId, id, result);
                     const type = exists ? 'update' : 'create';
                     pushEvent({ streamName, groupId, id, event: { type, data: result } });
                     return wrappedResult;
@@ -79,11 +79,11 @@ const createServer = async (lockedData, eventManager, state, config) => {
                 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);
+                    return wrapObject(groupId, id, result);
                 },
                 async getGroup(groupId) {
                     const list = await suuper.getGroup.apply(wrapper, [groupId]);
-                    return list.map((object) => wrapObject(object.id, object));
+                    return list.map((object) => wrapObject(groupId, object.id, object));
                 },
             };
             return wrapper;

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

@@ -25,6 +25,7 @@ type StreamEvent<TData> = {
     };
 };
 type EventMessage<TData> = BaseMessage & {
+    timestamp: number;
     event: StreamEvent<TData>;
 };
 type Props = {
@@ -33,7 +34,7 @@ type Props = {
     onJoinGroup: <TData>(streamName: string, groupId: string) => Promise<TData[] | undefined>;
 };
 export declare const createSocketServer: ({ server, onJoin, onJoinGroup }: Props) => {
-    pushEvent: <TData>(message: EventMessage<TData>) => void;
+    pushEvent: <TData>(message: Omit<EventMessage<TData>, "timestamp">) => void;
     socketServer: WsServer<typeof import("ws"), typeof http.IncomingMessage>;
 };
 export {};

package/dist/src/socket-server.js

@@ -22,6 +22,7 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
                     const item = await onJoin(message.data.streamName, message.data.groupId, message.data.id);
                     if (item) {
                         const resultMessage = {
+                            timestamp: Date.now(),
                             streamName: message.data.streamName,
                             groupId: message.data.groupId,
                             id: message.data.id,
@@ -34,6 +35,7 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
                     const items = await onJoinGroup(message.data.streamName, message.data.groupId);
                     if (items) {
                         const resultMessage = {
+                            timestamp: Date.now(),
                             streamName: message.data.streamName,
                             groupId: message.data.groupId,
                             event: { type: 'sync', data: items },
@@ -61,13 +63,14 @@ const createSocketServer = ({ server, onJoin, onJoinGroup }) => {
     const pushEvent = (message) => {
         const { groupId, streamName, id } = message;
         const groupRoom = getRoom({ streamName, groupId });
+        const eventMessage = JSON.stringify({ timestamp: Date.now(), ...message });
         if (rooms[groupRoom]) {
-            rooms[groupRoom].forEach((socket) => socket.send(JSON.stringify(message)));
+            rooms[groupRoom].forEach((socket) => socket.send(eventMessage));
         }
         if (id) {
             const itemRoom = getRoom({ groupId, streamName, id });
             if (rooms[itemRoom]) {
-                rooms[itemRoom].forEach((socket) => socket.send(JSON.stringify(message)));
+                rooms[itemRoom].forEach((socket) => socket.send(eventMessage));
             }
         }
     };

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

@@ -1,4 +1,5 @@
 import { ZodObject } from 'zod';
+import { StateStreamFactory } from './state-stream';
 export interface StateStreamConfig {
     name: string;
     schema: ZodObject<any>;
@@ -24,6 +25,7 @@ export type Stream<TConfig extends StateStreamConfig = StateStreamConfig> = {
     filePath: string;
     config: TConfig;
     hidden?: boolean;
+    factory: StateStreamFactory<unknown>;
 };
 export interface IStateStream<TData> {
     get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;

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.73",
+  "version": "0.2.1-beta.74",
   "dependencies": {
     "@amplitude/analytics-node": "^1.3.8",
     "body-parser": "^1.20.3",