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

package/README.md

@@ -51,7 +51,7 @@ eventManager.subscribe({
   filePath: '/path/to/handler.ts',
   handler: (event) => {
     // Handle the event
-  }
+  },
 })
 
 // Emit events
@@ -59,7 +59,7 @@ eventManager.emit({
   topic: 'user.created',
   data: { userId: '123' },
   traceId: 'trace-123',
-  logger: logger
+  logger: logger,
 })
 ```
 
@@ -83,7 +83,7 @@ import { createStateAdapter } from '@motiadev/core'
 const stateAdapter = createStateAdapter({
   adapter: 'redis',
   host: 'localhost',
-  port: 6379
+  port: 6379,
 })
 
 // Use state in your handlers
@@ -101,17 +101,6 @@ import { setupCronHandlers } from '@motiadev/core'
 const cronManager = setupCronHandlers(lockedData, eventManager, state, loggerFactory)
 ```
 
-### Logging
-
-Use the built-in logging system:
-
-```typescript
-import { globalLogger } from '@motiadev/core'
-
-globalLogger.info('Application started')
-globalLogger.error('Something went wrong', { error: err })
-```
-
 ## Multi-language Support
 
 Motia supports writing step handlers in multiple languages:
@@ -127,16 +116,9 @@ Each language has its own runner that communicates with the core framework.
 The package exports TypeScript types for all components:
 
 ```typescript
-import { 
-  Event, 
-  FlowContext, 
-  ApiRouteConfig, 
-  EventConfig, 
-  CronConfig 
-} from '@motiadev/core'
+import { Event, FlowContext, ApiRouteConfig, EventConfig, CronConfig } from '@motiadev/core'
 ```
 
 ## License
 
 This package is part of the Motia framework and is licensed under the same terms.
-```

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export * from './src/types';
 export { createServer, MotiaServer } from './src/server';
 export { createStepHandlers, MotiaEventManager } from './src/step-handlers';
 export { createEventManager } from './src/event-manager';
-export { globalLogger, Logger } from './src/logger';
+export { Logger } from './src/logger';
 export { createStateAdapter } from './src/state/create-state-adapter';
 export { setupCronHandlers, CronManager } from './src/cron-handler';
 export { isApiStep, isCronStep, isEventStep, isNoopStep } from './src/guards';
@@ -10,6 +10,5 @@ export { LockedData } from './src/locked-data';
 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, IStateStream } from './src/types-stream';
+export { StreamConfig, MotiaStream } from './src/types-stream';
 export { getProjectIdentifier, getUserIdentifier, isAnalyticsEnabled, trackEvent } from './src/analytics/utils';

package/dist/index.js

@@ -14,7 +14,7 @@ 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 });
-exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.StateStream = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
+exports.trackEvent = exports.isAnalyticsEnabled = exports.getUserIdentifier = exports.getProjectIdentifier = exports.createMermaidGenerator = exports.getStreamConfig = exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
 var server_1 = require("./src/server");
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
@@ -23,7 +23,6 @@ Object.defineProperty(exports, "createStepHandlers", { enumerable: true, get: fu
 var event_manager_1 = require("./src/event-manager");
 Object.defineProperty(exports, "createEventManager", { enumerable: true, get: function () { return event_manager_1.createEventManager; } });
 var logger_1 = require("./src/logger");
-Object.defineProperty(exports, "globalLogger", { enumerable: true, get: function () { return logger_1.globalLogger; } });
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
 var create_state_adapter_1 = require("./src/state/create-state-adapter");
 Object.defineProperty(exports, "createStateAdapter", { enumerable: true, get: function () { return create_state_adapter_1.createStateAdapter; } });
@@ -41,8 +40,6 @@ Object.defineProperty(exports, "getStepConfig", { enumerable: true, get: functio
 Object.defineProperty(exports, "getStreamConfig", { enumerable: true, get: function () { return get_step_config_1.getStreamConfig; } });
 var mermaid_generator_1 = require("./src/mermaid-generator");
 Object.defineProperty(exports, "createMermaidGenerator", { enumerable: true, get: function () { return mermaid_generator_1.createMermaidGenerator; } });
-var state_stream_1 = require("./src/state-stream");
-Object.defineProperty(exports, "StateStream", { enumerable: true, get: function () { return state_stream_1.StateStream; } });
 var utils_1 = require("./src/analytics/utils");
 Object.defineProperty(exports, "getProjectIdentifier", { enumerable: true, get: function () { return utils_1.getProjectIdentifier; } });
 Object.defineProperty(exports, "getUserIdentifier", { enumerable: true, get: function () { return utils_1.getUserIdentifier; } });

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

@@ -1,4 +1,4 @@
 import { StepConfig } from './types';
-import { StateStreamConfig } from './types-stream';
+import { StreamConfig } from './types-stream';
 export declare const getStepConfig: (file: string) => Promise<StepConfig | null>;
-export declare const getStreamConfig: (file: string) => Promise<StateStreamConfig | null>;
+export declare const getStreamConfig: (file: string) => Promise<StreamConfig | null>;

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

@@ -1,13 +1,14 @@
 import { Printer } from './printer';
-import { StateStreamFactory } from './state-stream';
-import { ApiRouteConfig, CronConfig, EventConfig, Flow, InternalStateManager, Step } from './types';
+import { StreamFactory } from './streams/stream-factory';
+import { ApiRouteConfig, CronConfig, EventConfig, Flow, Step } from './types';
 import { Stream } from './types-stream';
 type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
 type StepEvent = 'step-created' | 'step-removed' | 'step-updated';
 type StreamEvent = 'stream-created' | 'stream-removed' | 'stream-updated';
-type StreamWrapper<TData> = (streamName: string, factory: StateStreamFactory<TData>) => StateStreamFactory<TData>;
+type StreamWrapper<TData> = (streamName: string, factory: StreamFactory<TData>) => StreamFactory<TData>;
 export declare class LockedData {
     readonly baseDir: string;
+    private readonly streamAdapter;
     flows: Record<string, Flow>;
     activeSteps: Step[];
     devSteps: Step[];
@@ -17,11 +18,10 @@ export declare class LockedData {
     private stepHandlers;
     private streamHandlers;
     private streams;
-    private state;
     private streamWrapper?;
-    constructor(baseDir: string);
+    constructor(baseDir: string, streamAdapter?: 'file' | 'memory');
     disablePrinter(): void;
-    applyStreamWrapper<TData>(state: InternalStateManager, streamWrapper: StreamWrapper<TData>): void;
+    applyStreamWrapper<TData>(streamWrapper: StreamWrapper<TData>): void;
     saveTypes(): void;
     on(event: FlowEvent, handler: (flowName: string) => void): void;
     onStep(event: StepEvent, handler: (step: Step) => void): void;
@@ -31,7 +31,7 @@ export declare class LockedData {
     cronSteps(): Step<CronConfig>[];
     pythonSteps(): Step[];
     tsSteps(): Step[];
-    getStreams(): Record<string, StateStreamFactory<any>>;
+    getStreams(): Record<string, StreamFactory<any>>;
     listStreams(): Stream[];
     findStream(path: string): Stream | undefined;
     updateStep(oldStep: Step, newStep: Step, options?: {
@@ -46,7 +46,7 @@ export declare class LockedData {
     private createFactoryWrapper;
     createStream<TData>(baseStream: Omit<Stream, 'factory'>, options?: {
         disableTypeCreation?: boolean;
-    }): StateStreamFactory<TData>;
+    }): StreamFactory<TData>;
     deleteStream(stream: Stream, options?: {
         disableTypeCreation?: boolean;
     }): void;
@@ -57,5 +57,6 @@ export declare class LockedData {
     private removeFlow;
     private onFlowUpdated;
     private isValidStep;
+    private createStreamAdapter;
 }
 export {};

package/dist/src/locked-data.js

@@ -8,13 +8,14 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const guards_1 = require("./guards");
 const printer_1 = require("./printer");
-const state_stream_1 = require("./state-stream");
 const step_validator_1 = require("./step-validator");
+const file_stream_adapter_1 = require("./streams/adapters/file-stream-adapter");
+const memory_stream_adapter_1 = require("./streams/adapters/memory-stream-adapter");
 const generate_types_1 = require("./types/generate-types");
 class LockedData {
-    constructor(baseDir) {
+    constructor(baseDir, streamAdapter = 'file') {
         this.baseDir = baseDir;
-        this.state = null;
+        this.streamAdapter = streamAdapter;
         this.flows = {};
         this.activeSteps = [];
         this.devSteps = [];
@@ -40,9 +41,8 @@ class LockedData {
     disablePrinter() {
         this.printer = new printer_1.NoPrinter(this.baseDir);
     }
-    applyStreamWrapper(state, streamWrapper) {
+    applyStreamWrapper(streamWrapper) {
         this.streamWrapper = streamWrapper;
-        this.state = state;
     }
     saveTypes() {
         const types = (0, generate_types_1.generateTypesFromSteps)(this.activeSteps, this.printer);
@@ -76,7 +76,6 @@ class LockedData {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getStreams() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const streams = {};
         for (const [key, value] of Object.entries(this.streams)) {
             streams[key] = value.factory;
@@ -200,8 +199,8 @@ class LockedData {
         const stream = baseStream;
         this.streams[stream.config.name] = stream;
         this.streamHandlers['stream-created'].forEach((handler) => handler(stream));
-        if (stream.config.baseConfig.storageType === 'state') {
-            stream.factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+        if (stream.config.baseConfig.storageType === 'default') {
+            stream.factory = this.createFactoryWrapper(stream, () => this.createStreamAdapter(stream.config.name));
         }
         else {
             stream.factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
@@ -232,8 +231,8 @@ class LockedData {
         if (oldStream.config.name !== stream.config.name) {
             delete this.streams[oldStream.config.name];
         }
-        if (stream.config.baseConfig.storageType === 'state') {
-            stream.factory = this.createFactoryWrapper(stream, () => new state_stream_1.InternalStateStream(this.state));
+        if (stream.config.baseConfig.storageType === 'default') {
+            stream.factory = this.createFactoryWrapper(stream, () => this.createStreamAdapter(stream.config.name));
         }
         else {
             stream.factory = this.createFactoryWrapper(stream, stream.config.baseConfig.factory);
@@ -269,5 +268,11 @@ class LockedData {
         }
         return validationResult.success;
     }
+    createStreamAdapter(streamName) {
+        if (this.streamAdapter === 'file') {
+            return new file_stream_adapter_1.FileStreamAdapter(this.baseDir, streamName);
+        }
+        return new memory_stream_adapter_1.MemoryStreamAdapter();
+    }
 }
 exports.LockedData = LockedData;

package/dist/src/logger-factory.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from './logger';
-import { StateStream } from './state-stream';
+import { StreamAdapter } from './streams/adapters/stream-adapter';
 import { Log } from './streams/logs-stream';
 type CreateLogger = {
     traceId: string;
@@ -9,7 +9,7 @@ type CreateLogger = {
 export declare class LoggerFactory {
     private readonly isVerbose;
     private readonly logStream;
-    constructor(isVerbose: boolean, logStream: StateStream<Log>);
+    constructor(isVerbose: boolean, logStream: StreamAdapter<Log>);
     create({ stepName, traceId, flows }: CreateLogger): Logger;
 }
 export {};

package/dist/src/logger.d.ts

@@ -1,5 +1,5 @@
 import { Log } from './streams/logs-stream';
-import { StateStream } from './state-stream';
+import { StreamAdapter } from './streams/adapters/stream-adapter';
 export declare class BaseLogger {
     readonly isVerbose: boolean;
     private readonly meta;
@@ -18,7 +18,7 @@ export declare class Logger extends BaseLogger {
     private readonly step;
     private readonly logStream?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: StateStream<Log> | undefined);
+    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, logStream?: StreamAdapter<Log> | undefined);
     child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;

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

@@ -68,7 +68,7 @@ class ProcessManager {
     }
     kill() {
         if (this.child) {
-            this.child.kill();
+            this.child.kill('SIGKILL');
         }
     }
     close() {

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

@@ -8,7 +8,6 @@ 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
@@ -21,42 +20,6 @@ def parse_args(arg: str) -> Dict:
         print('Error parsing args:', arg)
         return arg
 
-async def validate_handler_input(
-    module: Any,
-    args: Dict,
-    context: Context,
-    is_api_handler: bool
-) -> Optional[ApiResponse]:
-    """Validate handler input based on module configuration"""
-    if not hasattr(args, "contextInFirstArg") or hasattr(module, "config"):
-        return None
-
-    config: FlowConfig = module.config
-    input_data = args.get("data")
-
-    if is_api_handler and hasattr(input_data, "body") and hasattr(config, "bodySchema"):
-        body = input_data.get("body", {})
-        body_schema = config.get("bodySchema", {})
-        validation_result = validate_with_jsonschema(body, body_schema)
-
-        if not validation_result["success"]:
-            return ApiResponse(
-                status=400,
-                body={"message": f'Input validation error: {validation_result["error"]}'}
-            )
-        input_data.body = validation_result['data']
-    
-    elif not is_api_handler and config.input is not None:
-        validation_result = validate_with_jsonschema(input_data, config.get("input", {}))
-
-        if not validation_result["success"]:
-            context.logger.info(f'Input Validation Error: {validation_result["error"]}', validation_result['details'])
-            return None
-        
-        input_data = validation_result["data"]
-
-    return None
-
 async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
     """Execute a Python module with the given arguments"""
     try:
@@ -94,12 +57,6 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
         
         context = Context(trace_id, flows, rpc, streams)
 
-        validation_result = await validate_handler_input(module, args, context, is_api_handler)
-        if validation_result:
-            await rpc.send('result', validation_result)
-            return
-
-    
         middlewares: List[Callable] = config.get("middleware", [])
         composed_middleware = compose_middleware(*middlewares)
         
@@ -111,11 +68,6 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Dict) -> None:
 
         result = await composed_middleware(data, context, handler_fn)
 
-        if not is_api_handler:
-            pending = asyncio.all_tasks() - {asyncio.current_task()}
-            if pending:
-                await asyncio.gather(*pending)
-
         if result:
             await rpc.send('result', result)
 

package/dist/src/server.d.ts

@@ -1,9 +1,9 @@
-import { CronManager } from './cron-handler';
 import { Express } from 'express';
 import http from 'http';
 import { Server as WsServer } from 'ws';
-import { ApiRouteConfig, EventManager, InternalStateManager, Step } from './types';
+import { CronManager } from './cron-handler';
 import { LockedData } from './locked-data';
+import { ApiRouteConfig, EventManager, InternalStateManager, Step } from './types';
 export type MotiaServer = {
     app: Express;
     server: http.Server;

package/dist/src/server.js

@@ -4,24 +4,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = void 0;
-const cron_handler_1 = require("./cron-handler");
 const body_parser_1 = __importDefault(require("body-parser"));
+const cors_1 = __importDefault(require("cors"));
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
-const cors_1 = __importDefault(require("cors"));
+const analytics_endpoint_1 = require("./analytics-endpoint");
+const utils_1 = require("./analytics/utils");
+const call_step_file_1 = require("./call-step-file");
+const cron_handler_1 = require("./cron-handler");
+const flows_config_endpoint_1 = require("./flows-config-endpoint");
 const flows_endpoint_1 = require("./flows-endpoint");
+const generate_trace_id_1 = require("./generate-trace-id");
 const guards_1 = require("./guards");
 const logger_1 = require("./logger");
-const steps_1 = require("./steps");
-const call_step_file_1 = require("./call-step-file");
 const logger_factory_1 = require("./logger-factory");
-const generate_trace_id_1 = require("./generate-trace-id");
-const flows_config_endpoint_1 = require("./flows-config-endpoint");
-const api_endpoints_1 = require("./streams/api-endpoints");
 const socket_server_1 = require("./socket-server");
+const steps_1 = require("./steps");
+const api_endpoints_1 = require("./streams/api-endpoints");
 const logs_stream_1 = require("./streams/logs-stream");
-const analytics_endpoint_1 = require("./analytics-endpoint");
-const utils_1 = require("./analytics/utils");
 const createServer = async (lockedData, eventManager, state, config) => {
     const printer = lockedData.printer;
     const app = (0, express_1.default)();
@@ -47,46 +47,52 @@ const createServer = async (lockedData, eventManager, state, config) => {
             }
         },
     });
-    lockedData.applyStreamWrapper(state, (streamName, stream) => {
+    lockedData.applyStreamWrapper((streamName, stream) => {
         return () => {
-            const suuper = stream();
+            const main = stream();
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const wrapObject = (groupId, id, object) => ({
-                ...object,
-                __motia: { type: 'state-stream', streamName, groupId, id },
-            });
-            const wrapper = {
-                ...suuper,
-                async send(channel, event) {
-                    pushEvent({ streamName, ...channel, event: { type: 'event', event } });
-                },
-                async get(groupId, id) {
-                    const result = await suuper.get.apply(wrapper, [groupId, id]);
-                    return wrapObject(groupId, id, result);
-                },
-                async set(groupId, id, data) {
-                    if (!data) {
-                        return null;
-                    }
-                    const exists = await suuper.get(groupId, id);
-                    const updated = await suuper.set.apply(wrapper, [groupId, id, data]);
-                    const result = updated ?? data;
-                    const wrappedResult = wrapObject(groupId, id, result);
-                    const type = exists ? 'update' : 'create';
-                    pushEvent({ streamName, groupId, id, event: { type, data: result } });
-                    return wrappedResult;
-                },
-                async delete(groupId, id) {
-                    const result = await suuper.delete.apply(wrapper, [groupId, id]);
-                    pushEvent({ streamName, groupId, id, event: { type: 'delete', data: result } });
-                    return wrapObject(groupId, id, result);
-                },
-                async getGroup(groupId) {
-                    const list = await suuper.getGroup.apply(wrapper, [groupId]);
-                    return list.map((object) => wrapObject(groupId, object.id, object));
-                },
+            const wrapObject = (groupId, id, object) => {
+                if (!object) {
+                    return null;
+                }
+                return {
+                    ...object,
+                    __motia: { type: 'state-stream', streamName, groupId, id },
+                };
+            };
+            const mainGetGroup = main.getGroup;
+            const mainGet = main.get;
+            const mainSet = main.set;
+            const mainDelete = main.delete;
+            main.send = async (channel, event) => {
+                pushEvent({ streamName, ...channel, event: { type: 'event', event } });
+            };
+            main.getGroup = async (groupId) => {
+                const result = await mainGetGroup.apply(main, [groupId]);
+                return result.map((object) => wrapObject(groupId, object.id, object));
+            };
+            main.get = async (groupId, id) => {
+                const result = await mainGet.apply(main, [groupId, id]);
+                return wrapObject(groupId, id, result);
+            };
+            main.set = async (groupId, id, data) => {
+                if (!data) {
+                    return null;
+                }
+                const exists = await main.get(groupId, id);
+                const updated = await mainSet.apply(main, [groupId, id, data]);
+                const result = updated ?? data;
+                const wrappedResult = wrapObject(groupId, id, result);
+                const type = exists ? 'update' : 'create';
+                pushEvent({ streamName, groupId, id, event: { type, data: result } });
+                return wrappedResult;
+            };
+            main.delete = async (groupId, id) => {
+                const result = await mainDelete.apply(main, [groupId, id]);
+                pushEvent({ streamName, groupId, id, event: { type: 'delete', data: result } });
+                return wrapObject(groupId, id, result);
             };
-            return wrapper;
+            return main;
         };
     });
     const logStream = lockedData.createStream({
@@ -127,6 +133,7 @@ const createServer = async (lockedData, eventManager, state, config) => {
                     traceId,
                 });
                 if (!result) {
+                    console.log('no result');
                     res.status(500).json({ error: 'Internal server error' });
                     return;
                 }

package/dist/src/streams/adapters/file-stream-adapter.d.ts

@@ -0,0 +1,20 @@
+import { StreamAdapter } from './stream-adapter';
+export type FileAdapterConfig = {
+    filePath: string;
+};
+export declare class FileStreamAdapter<TData> extends StreamAdapter<TData> {
+    private readonly filePath;
+    private readonly streamsDir;
+    constructor(filePath: string, streamName: string);
+    init(): void;
+    getGroup<T>(groupId: string): Promise<T[]>;
+    get<T>(groupId: string, key: string): Promise<T | null>;
+    set<T>(groupId: string, id: string, value: T): Promise<T & {
+        id: string;
+    }>;
+    delete<T>(groupId: string, id: string): Promise<T | null>;
+    clear(groupId: string): Promise<void>;
+    private _makeKey;
+    private _readFile;
+    private _writeFile;
+}

package/dist/src/streams/adapters/file-stream-adapter.js

@@ -0,0 +1,124 @@
+"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.FileStreamAdapter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+const stream_adapter_1 = require("./stream-adapter");
+class FileStreamAdapter extends stream_adapter_1.StreamAdapter {
+    constructor(filePath, streamName) {
+        super();
+        this.streamsDir = path.join(filePath, '.motia', 'streams');
+        this.filePath = path.join(this.streamsDir, `${streamName}.stream.json`);
+    }
+    init() {
+        try {
+            fs_1.default.realpathSync(this.streamsDir);
+        }
+        catch {
+            fs_1.default.mkdirSync(this.streamsDir, { recursive: true });
+        }
+        try {
+            fs_1.default.readFileSync(this.filePath, 'utf-8');
+        }
+        catch {
+            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(groupId, key) {
+        const data = this._readFile();
+        const fullKey = this._makeKey(groupId, key);
+        return data[fullKey] ? JSON.parse(data[fullKey]) : null;
+    }
+    async set(groupId, id, value) {
+        const data = this._readFile();
+        const key = this._makeKey(groupId, id);
+        data[key] = JSON.stringify(value);
+        this._writeFile(data);
+        return { ...value, id };
+    }
+    async delete(groupId, id) {
+        const data = this._readFile();
+        const key = this._makeKey(groupId, id);
+        const value = await this.get(groupId, id);
+        if (value) {
+            delete data[key];
+            this._writeFile(data);
+        }
+        return value;
+    }
+    async clear(groupId) {
+        const data = this._readFile();
+        const pattern = this._makeKey(groupId, '');
+        for (const key in data) {
+            if (key.startsWith(pattern)) {
+                delete data[key];
+            }
+        }
+        this._writeFile(data);
+    }
+    _makeKey(groupId, id) {
+        return `${groupId}:${id}`;
+    }
+    _readFile() {
+        try {
+            const content = fs_1.default.readFileSync(this.filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            this.init();
+            return {};
+        }
+    }
+    _writeFile(data) {
+        try {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (error) {
+            this.init();
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
+        }
+    }
+}
+exports.FileStreamAdapter = FileStreamAdapter;

package/dist/src/streams/adapters/memory-stream-adapter.d.ts

@@ -0,0 +1,12 @@
+import { StreamAdapter } from './stream-adapter';
+export declare class MemoryStreamAdapter<TData> extends StreamAdapter<TData> {
+    private state;
+    init(): Promise<void>;
+    getGroup<T>(groupId: string): Promise<T[]>;
+    get<T>(groupId: string, id: string): Promise<T | null>;
+    set<T>(groupId: string, id: string, value: T): Promise<T & {
+        id: string;
+    }>;
+    delete<T>(groupId: string, id: string): Promise<T | null>;
+    private _makeKey;
+}

package/dist/src/streams/adapters/memory-stream-adapter.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStreamAdapter = void 0;
+const stream_adapter_1 = require("./stream-adapter");
+class MemoryStreamAdapter extends stream_adapter_1.StreamAdapter {
+    constructor() {
+        super(...arguments);
+        this.state = {};
+    }
+    async init() {
+        this.state = {};
+    }
+    async getGroup(groupId) {
+        return Object.entries(this.state)
+            .filter(([key]) => key.startsWith(groupId))
+            .map(([, value]) => value);
+    }
+    async get(groupId, id) {
+        const key = this._makeKey(groupId, id);
+        return this.state[key] ? this.state[key] : null;
+    }
+    async set(groupId, id, value) {
+        const key = this._makeKey(groupId, id);
+        this.state[key] = value;
+        return { ...value, id };
+    }
+    async delete(groupId, id) {
+        const key = this._makeKey(groupId, id);
+        const value = await this.get(groupId, id);
+        if (value) {
+            delete this.state[key];
+        }
+        return value;
+    }
+    _makeKey(groupId, id) {
+        return `${groupId}:${id}`;
+    }
+}
+exports.MemoryStreamAdapter = MemoryStreamAdapter;

package/dist/src/streams/adapters/stream-adapter.d.ts

@@ -0,0 +1,11 @@
+import { BaseStreamItem, MotiaStream, StateStreamEvent, StateStreamEventChannel } from '../../types-stream';
+/**
+ * Interface for stream management adapters
+ */
+export declare abstract class StreamAdapter<TData> implements MotiaStream<TData> {
+    abstract get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
+    abstract set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData>>;
+    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>;
+}

package/dist/src/streams/adapters/stream-adapter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamAdapter = void 0;
+/**
+ * Interface for stream management adapters
+ */
+class StreamAdapter {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async send(channel, event) { }
+}
+exports.StreamAdapter = StreamAdapter;

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

@@ -2,7 +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 stream_adapter_1 = require("./adapters/stream-adapter");
 const mapEndpoint = (step) => {
     return {
         id: step.filePath,
@@ -14,7 +14,7 @@ const mapEndpoint = (step) => {
         bodySchema: step.config.bodySchema,
     };
 };
-class ApiEndpointsStream extends state_stream_1.StateStream {
+class ApiEndpointsStream extends stream_adapter_1.StreamAdapter {
     constructor(lockedData) {
         super();
         this.lockedData = lockedData;

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

@@ -1,10 +1,10 @@
 import { LockedData } from '../locked-data';
-import { StateStream } from '../state-stream';
+import { StreamAdapter } from './adapters/stream-adapter';
 export type Flow = {
     id: string;
     name: string;
 };
-export declare class FlowsStream extends StateStream<Flow> {
+export declare class FlowsStream extends StreamAdapter<Flow> {
     private readonly lockedData;
     constructor(lockedData: LockedData);
     get(id: string): Promise<Flow | null>;

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowsStream = void 0;
-const state_stream_1 = require("../state-stream");
-class FlowsStream extends state_stream_1.StateStream {
+const stream_adapter_1 = require("./adapters/stream-adapter");
+class FlowsStream extends stream_adapter_1.StreamAdapter {
     constructor(lockedData) {
         super();
         this.lockedData = lockedData;

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

@@ -1,4 +1,4 @@
-import { StateStream } from '../state-stream';
+import { StreamAdapter } from './adapters/stream-adapter';
 export type Log = {
     id: string;
     level: string;
@@ -8,7 +8,7 @@ export type Log = {
     flows: string[];
     [key: string]: any;
 };
-export declare class LogsStream extends StateStream<Log> {
+export declare class LogsStream extends StreamAdapter<Log> {
     get: () => Promise<null>;
     delete: () => Promise<null>;
     getGroup: () => Promise<never[]>;

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogsStream = void 0;
-const state_stream_1 = require("../state-stream");
+const stream_adapter_1 = require("./adapters/stream-adapter");
 /*
  * 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 {
+class LogsStream extends stream_adapter_1.StreamAdapter {
     constructor() {
         super(...arguments);
         this.get = async () => null;

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

@@ -0,0 +1,2 @@
+import { MotiaStream } from '../types-stream';
+export type StreamFactory<TData> = () => MotiaStream<TData>;

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

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

package/dist/src/types/generate-type-from-schema.js

@@ -14,9 +14,12 @@ const generateTypeFromSchema = (schema) => {
         });
         return props.length > 0 ? `{ ${props.join('; ')} }` : '{}';
     }
+    if (schema.type === 'string') {
+        return schema.enum && schema.enum.length > 0 // must have at least one enum value
+            ? schema.enum.map((value) => `'${value}'`).join(' | ')
+            : 'string';
+    }
     switch (schema.type) {
-        case 'string':
-            return 'string';
         case 'number':
             return 'number';
         case 'boolean':

package/dist/src/types/generate-types.js

@@ -13,12 +13,12 @@ const generateTypesString = (handlers, streams) => {
  * 
  * Consider adding this file to .prettierignore and eslint ignore.
  */
-import { EventHandler, ApiRouteHandler, ApiResponse, IStateStream } from 'motia'
+import { EventHandler, ApiRouteHandler, ApiResponse, MotiaStream } from 'motia'
 
 declare module 'motia' {
   interface FlowContextStateStreams {
     ${Object.entries(streams)
-        .map(([key, value]) => `'${key}': IStateStream<${value}>`)
+        .map(([key, value]) => `'${key}': MotiaStream<${value}>`)
         .join('\n    ')
         .trim()}
   }

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

@@ -1,4 +1,4 @@
-export type JsonSchemaType = 'string' | 'number' | 'boolean';
+export type JsonSchemaType = 'number' | 'boolean';
 export type JsonArray = {
     type: 'array';
     description?: string;
@@ -10,11 +10,16 @@ export type JsonObject = {
     properties: Record<string, JsonSchema>;
     required?: string[];
 };
+export type JsonString = {
+    type: 'string';
+    description?: string;
+    enum?: string[];
+};
 export type JsonProperty = {
     type: JsonSchemaType;
     description?: string;
 };
-export type JsonSchema = JsonArray | JsonObject | JsonProperty;
+export type JsonSchema = JsonArray | JsonObject | JsonString | JsonProperty;
 export declare class JsonSchemaError extends Error {
     constructor(message: string);
 }

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

@@ -1,13 +1,13 @@
 import { ZodObject } from 'zod';
-import { StateStreamFactory } from './state-stream';
-export interface StateStreamConfig {
+import { StreamFactory } from './streams/stream-factory';
+export interface StreamConfig {
     name: string;
     schema: ZodObject<any>;
     baseConfig: {
-        storageType: 'state';
+        storageType: 'default';
     } | {
         storageType: 'custom';
-        factory: () => IStateStream<any>;
+        factory: () => MotiaStream<any>;
     };
 }
 export type StateStreamEventChannel = {
@@ -21,15 +21,15 @@ export type StateStreamEvent<TData> = {
 export type BaseStreamItem<TData = unknown> = TData & {
     id: string;
 };
-export type Stream<TConfig extends StateStreamConfig = StateStreamConfig> = {
+export type Stream<TConfig extends StreamConfig = StreamConfig> = {
     filePath: string;
     config: TConfig;
     hidden?: boolean;
-    factory: StateStreamFactory<unknown>;
+    factory: StreamFactory<unknown>;
 };
-export interface IStateStream<TData> {
+export interface MotiaStream<TData> {
     get(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
-    set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData> | null>;
+    set(groupId: string, id: string, data: TData): Promise<BaseStreamItem<TData>>;
     delete(groupId: string, id: string): Promise<BaseStreamItem<TData> | null>;
     getGroup(groupId: string): Promise<BaseStreamItem<TData>[]>;
     send<T>(channel: StateStreamEventChannel, event: StateStreamEvent<T>): Promise<void>;

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

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

@@ -1,19 +0,0 @@
-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(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;
-    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

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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) {
-        super();
-        this.state = state;
-    }
-    async get(groupId, id) {
-        return this.state.get(groupId, id);
-    }
-    async set(groupId, id, data) {
-        return this.state.set(groupId, id, { id, ...data });
-    }
-    async delete(groupId, id) {
-        return this.state.delete(groupId, id);
-    }
-    async getGroup(groupId) {
-        return this.state.getGroup(groupId);
-    }
-    async send() { }
-}
-exports.InternalStateStream = InternalStateStream;