@motiadev/core 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -7,3 +7,5 @@ export * from './src/state/create-state-adapter';
 export * from './src/python/get-python-config';
 export * from './src/ruby/get-ruby-config';
 export * from './src/node/get-config';
+export * from './src/cron-handler';
+export * from './src/guards';

package/dist/index.js

@@ -23,3 +23,5 @@ __exportStar(require("./src/state/create-state-adapter"), exports);
 __exportStar(require("./src/python/get-python-config"), exports);
 __exportStar(require("./src/ruby/get-ruby-config"), exports);
 __exportStar(require("./src/node/get-config"), exports);
+__exportStar(require("./src/cron-handler"), exports);
+__exportStar(require("./src/guards"), exports);

package/dist/src/cron-handler.d.ts

@@ -0,0 +1,3 @@
+import { EventManager, Step } from './types';
+import { Server } from 'socket.io';
+export declare const setupCronHandlers: (steps: Step[], eventManager: EventManager, socketServer?: Server) => () => void;

package/dist/src/cron-handler.js

@@ -0,0 +1,95 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCronHandlers = void 0;
+const logger_1 = require("./logger");
+const cron = __importStar(require("node-cron"));
+const guards_1 = require("./guards");
+const get_module_export_1 = require("./node/get-module-export");
+const cronJobs = new Map();
+const setupCronHandlers = (steps, eventManager, socketServer) => {
+    steps.filter(guards_1.isCronStep).forEach(async (step) => {
+        const { config, filePath } = step;
+        const { cron: cronExpression } = config;
+        if (!cron.validate(cronExpression)) {
+            logger_1.globalLogger.error('[cron handler] invalid cron expression', {
+                expression: cronExpression,
+                step: step.config.name
+            });
+            return;
+        }
+        logger_1.globalLogger.debug('[cron handler] setting up cron job', {
+            filePath,
+            step: step.config.name,
+            cron: cronExpression
+        });
+        const task = cron.schedule(cronExpression, async () => {
+            const traceId = Math.random().toString(36).substring(7);
+            const logger = new logger_1.Logger(traceId, config.flows, step.config.name, socketServer);
+            try {
+                const handler = await (0, get_module_export_1.getModuleExport)(filePath, 'handler');
+                const emit = async (event) => {
+                    await eventManager.emit({
+                        ...event,
+                        traceId,
+                        flows: config.flows,
+                        logger
+                    }, filePath);
+                };
+                if (handler) {
+                    await handler({ emit, logger, traceId });
+                }
+                else {
+                    await emit({
+                        type: config.emits[0],
+                        data: { timestamp: Date.now() }
+                    });
+                }
+            }
+            catch (error) {
+                logger.error('[cron handler] error executing cron job', {
+                    error: error.message,
+                    step: step.config.name
+                });
+            }
+        });
+        cronJobs.set(step.config.name, task);
+    });
+    return () => {
+        cronJobs.forEach((task) => task.stop());
+        cronJobs.clear();
+    };
+};
+exports.setupCronHandlers = setupCronHandlers;

package/dist/src/flows-endpoint.d.ts

@@ -18,7 +18,7 @@ type FlowEdge = {
 type FlowStepResponse = {
     id: string;
     name: string;
-    type: 'event' | 'api' | 'noop';
+    type: 'event' | 'api' | 'noop' | 'cron';
     description?: string;
     subscribes?: string[];
     emits: Emit[];
@@ -28,6 +28,7 @@ type FlowStepResponse = {
     bodySchema?: any;
     language?: string;
     nodeComponentPath?: string;
+    cronExpression?: string;
 };
 type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];

package/dist/src/flows-endpoint.js

@@ -107,6 +107,17 @@ const createNoopStepResponse = (step, id) => {
         subscribes: step.config.virtualSubscribes,
     };
 };
+const createCronStepResponse = (step, id) => {
+    if (!(0, guards_1.isCronStep)(step)) {
+        throw new Error('Attempted to create Cron step response with non-Cron step');
+    }
+    return {
+        ...createBaseStepResponse(step, id),
+        type: 'cron',
+        emits: step.config.emits,
+        cronExpression: step.config.cron
+    };
+};
 const createStepResponse = (step) => {
     const id = (0, crypto_1.randomUUID)();
     if ((0, guards_1.isApiStep)(step))
@@ -115,6 +126,8 @@ const createStepResponse = (step) => {
         return createEventStepResponse(step, id);
     if ((0, guards_1.isNoopStep)(step))
         return createNoopStepResponse(step, id);
+    if ((0, guards_1.isCronStep)(step))
+        return createCronStepResponse(step, id);
     throw new Error(`Unknown step type for step: ${step.config.name}`);
 };
 const createEdgesForStep = (sourceStep, allSteps) => {

package/dist/src/guards.d.ts

@@ -1,4 +1,5 @@
-import { ApiRouteConfig, EventConfig, NoopConfig, Step } from './types';
+import { ApiRouteConfig, EventConfig, NoopConfig, Step, CronConfig } from './types';
 export declare const isApiStep: (step: Step) => step is Step<ApiRouteConfig>;
 export declare const isEventStep: (step: Step) => step is Step<EventConfig<any>>;
 export declare const isNoopStep: (step: Step) => step is Step<NoopConfig>;
+export declare const isCronStep: (step: Step) => step is Step<CronConfig>;

package/dist/src/guards.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
+exports.isCronStep = exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
 const isApiStep = (step) => step.config.type === 'api';
 exports.isApiStep = isApiStep;
 const isEventStep = (step) => step.config.type === 'event';
 exports.isEventStep = isEventStep;
 const isNoopStep = (step) => step.config.type === 'noop';
 exports.isNoopStep = isNoopStep;
+const isCronStep = (step) => step.config.type === 'cron';
+exports.isCronStep = isCronStep;

package/dist/src/node/rpc.js

@@ -22,8 +22,15 @@ class RpcSender {
             if (msg.type === 'rpc_response') {
                 const { id, result, error } = msg;
                 const callbacks = this.pendingRequests[id];
-                const callback = error ? callbacks.reject : callbacks.resolve;
-                callback(result);
+                if (!callbacks) {
+                    return;
+                }
+                else if (error) {
+                    callbacks.reject(error);
+                }
+                else {
+                    callbacks.resolve(result);
+                }
                 delete this.pendingRequests[id];
             }
         });

package/dist/src/server.d.ts

@@ -13,6 +13,7 @@ type ServerOutput = {
     app: Express;
     server: http.Server;
     socketServer: SocketIOServer;
+    close: () => Promise<void>;
 };
 export declare const createServer: (options: ServerOptions) => Promise<ServerOutput>;
 export {};

package/dist/src/server.js

@@ -4,6 +4,7 @@ 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 crypto_1 = require("crypto");
 const express_1 = __importDefault(require("express"));
@@ -18,6 +19,8 @@ const createServer = async (options) => {
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
     const io = new socket_io_1.Server(server);
+    // Setup cron handlers with socket server
+    const cleanupCronJobs = (0, cron_handler_1.setupCronHandlers)(steps, eventManager, io);
     const asyncHandler = (step, flows) => {
         return async (req, res) => {
             const traceId = (0, crypto_1.randomUUID)();
@@ -67,7 +70,13 @@ const createServer = async (options) => {
     (0, flows_endpoint_1.flowsEndpoint)(flows, app);
     server.on('error', (error) => {
         console.error('Server error:', error);
+        cleanupCronJobs();
     });
-    return { app, server, socketServer: io };
+    const close = async () => {
+        cleanupCronJobs();
+        await io.close();
+        server.close();
+    };
+    return { app, server, socketServer: io, close };
 };
 exports.createServer = createServer;

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

@@ -0,0 +1,11 @@
+import { StateAdapter } from '../state-adapter';
+export declare class MemoryStateAdapter implements StateAdapter {
+    private state;
+    init(): Promise<void>;
+    get(traceId: string, key: string): Promise<any>;
+    set(traceId: string, key: string, value: any): Promise<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+    cleanup(): Promise<void>;
+    private _makeKey;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStateAdapter = void 0;
+class MemoryStateAdapter {
+    constructor() {
+        this.state = {};
+    }
+    async init() {
+        this.state = {};
+    }
+    async get(traceId, key) {
+        const fullKey = this._makeKey(traceId, key);
+        return this.state[fullKey] ? this.state[fullKey] : null;
+    }
+    async set(traceId, key, value) {
+        const fullKey = this._makeKey(traceId, key);
+        this.state[fullKey] = value;
+    }
+    async delete(traceId, key) {
+        const fullKey = this._makeKey(traceId, key);
+        delete this.state[fullKey];
+    }
+    async clear(traceId) {
+        const pattern = this._makeKey(traceId, '');
+        for (const key in this.state) {
+            if (key.startsWith(pattern)) {
+                delete this.state[key];
+            }
+        }
+    }
+    async cleanup() {
+        // No cleanup needed for file system
+    }
+    _makeKey(traceId, key) {
+        return `${traceId}:${key}`;
+    }
+}
+exports.MemoryStateAdapter = MemoryStateAdapter;

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

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

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStateAdapter = createStateAdapter;
 const default_state_adapter_1 = require("./adapters/default-state-adapter");
+const memory_state_adapter_1 = require("./adapters/memory-state-adapter");
 const redis_state_adapter_1 = require("./adapters/redis-state-adapter");
 function createStateAdapter(config) {
     const { adapter = 'redis', ...adapterConfig } = config;
@@ -10,6 +11,8 @@ function createStateAdapter(config) {
             return new redis_state_adapter_1.RedisStateAdapter(adapterConfig);
         case 'default':
             return new default_state_adapter_1.FileStateAdapter(adapterConfig);
+        case 'memory':
+            return new memory_state_adapter_1.MemoryStateAdapter();
         default:
             throw new Error(`Unknown state adapter type: ${adapter}`);
     }

package/dist/src/types.d.ts

@@ -68,7 +68,16 @@ export type ApiResponse = {
     body: string | Buffer | Record<string, any>;
 };
 export type ApiRouteHandler = (req: ApiRequest, ctx: FlowContext) => Promise<ApiResponse>;
-export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : never;
+export type CronConfig = {
+    type: 'cron';
+    name: string;
+    description?: string;
+    cron: string;
+    virtualEmits?: Emit[];
+    emits: string[];
+    flows: string[];
+};
+export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : T extends CronConfig ? never : never;
 export type MotiaServer = Server<any>;
 export type MotiaSocketServer = SocketIOServer;
 export type Event<TData = unknown> = {
@@ -83,7 +92,7 @@ export type EventManager = {
     emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
     subscribe: <TData>(event: string, handlerName: string, handler: Handler<TData>) => void;
 };
-export type StepConfig = EventConfig<ZodObject<any>> | NoopConfig | ApiRouteConfig;
+export type StepConfig = EventConfig<ZodObject<any>> | NoopConfig | ApiRouteConfig | CronConfig;
 export type Step<TConfig extends StepConfig = StepConfig> = {
     filePath: string;
     version: string;

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "dependencies": {
+    "node-cron": "^3.0.3",
     "body-parser": "^1.20.3",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
@@ -15,6 +16,7 @@
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
+    "@types/node-cron": "^3.0.11",
     "@types/body-parser": "^1.19.5",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",

package/tsconfig.json

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