@motiadev/core 0.0.19 → 0.0.21

package/dist/src/server.d.ts

@@ -1,19 +1,17 @@
+import { CronManager } from './cron-handler';
 import { Express } from 'express';
 import http from 'http';
 import { Server as SocketIOServer } from 'socket.io';
 import { StateAdapter } from './state/state-adapter';
-import { EventManager, LockedData, Step } from './types';
-type ServerOptions = {
-    steps: Step[];
-    flows: LockedData['flows'];
-    eventManager: EventManager;
-    state: StateAdapter;
-};
-type ServerOutput = {
+import { ApiRouteConfig, EventManager, Step } from './types';
+import { LockedData } from './locked-data';
+export type MotiaServer = {
     app: Express;
     server: http.Server;
     socketServer: SocketIOServer;
     close: () => Promise<void>;
+    removeRoute: (step: Step<ApiRouteConfig>) => void;
+    addRoute: (step: Step<ApiRouteConfig>) => void;
+    cronManager: CronManager;
 };
-export declare const createServer: (options: ServerOptions) => Promise<ServerOutput>;
-export {};
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => Promise<MotiaServer>;

package/dist/src/server.js

@@ -15,13 +15,13 @@ const guards_1 = require("./guards");
 const logger_1 = require("./logger");
 const get_module_export_1 = require("./node/get-module-export");
 const steps_1 = require("./steps");
-const createServer = async (options) => {
-    const { flows, steps, eventManager, state } = options;
+const utils_1 = require("./utils");
+const createServer = async (lockedData, eventManager, state) => {
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
     const io = new socket_io_1.Server(server);
-    const allSteps = [...steps_1.systemSteps, ...steps];
-    const cleanupCronJobs = (0, cron_handler_1.setupCronHandlers)(allSteps, eventManager, io);
+    const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, io);
     const asyncHandler = (step, flows) => {
         return async (req, res) => {
             const traceId = (0, crypto_1.randomUUID)();
@@ -35,6 +35,10 @@ const createServer = async (options) => {
                 queryParams: req.query,
             };
             const emit = async ({ data, type }) => {
+                if (!(0, utils_1.isAllowedToEmit)(step, type)) {
+                    lockedData.printer.printInvalidEmit(step, type);
+                    return;
+                }
                 await eventManager.emit({ data, type, traceId, flows, logger }, step.filePath);
             };
             try {
@@ -54,30 +58,44 @@ const createServer = async (options) => {
     };
     app.use(body_parser_1.default.json());
     app.use(body_parser_1.default.urlencoded({ extended: true }));
-    const apiSteps = allSteps.filter(guards_1.isApiStep);
-    for (const step of apiSteps) {
+    const router = express_1.default.Router();
+    const addRoute = (step) => {
         const { method, flows, path } = step.config;
         logger_1.globalLogger.debug('[API] Registering route', step.config);
         if (method === 'POST') {
-            app.post(path, asyncHandler(step, flows));
+            router.post(path, asyncHandler(step, flows));
         }
         else if (method === 'GET') {
-            app.get(path, asyncHandler(step, flows));
+            router.get(path, asyncHandler(step, flows));
         }
         else {
             throw new Error(`Unsupported method: ${method}`);
         }
-    }
-    (0, flows_endpoint_1.flowsEndpoint)(flows, app);
+    };
+    const removeRoute = (step) => {
+        const { path, method } = step.config;
+        const routerStack = router.stack;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const filteredStack = routerStack.filter((layer) => {
+            if (layer.route) {
+                const match = layer.route.path === path && layer.route.methods[method.toLowerCase()];
+                return !match;
+            }
+            return true;
+        });
+        router.stack = filteredStack;
+    };
+    allSteps.filter(guards_1.isApiStep).forEach(addRoute);
+    app.use(router);
+    (0, flows_endpoint_1.flowsEndpoint)(lockedData, app);
     server.on('error', (error) => {
         console.error('Server error:', error);
-        cleanupCronJobs();
     });
     const close = async () => {
-        cleanupCronJobs();
+        cronManager.close();
         await io.close();
         server.close();
     };
-    return { app, server, socketServer: io, close };
+    return { app, server, socketServer: io, close, removeRoute, addRoute, cronManager };
 };
 exports.createServer = createServer;

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

@@ -9,6 +9,7 @@ export type RpcMessage = {
 export declare class RpcProcessor {
     private child;
     private handlers;
+    private isClosed;
     constructor(child: ChildProcess);
     handler<TInput, TOutput = unknown>(method: string, handler: RpcHandler<TInput, TOutput>): void;
     handle(method: string, input: unknown): Promise<any>;

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

@@ -6,6 +6,7 @@ class RpcProcessor {
         this.child = child;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.handlers = {};
+        this.isClosed = false;
     }
     handler(method, handler) {
         this.handlers[method] = handler;
@@ -18,7 +19,7 @@ class RpcProcessor {
         return handler(input);
     }
     response(id, result, error) {
-        if (id) {
+        if (id && !this.isClosed && this.child.connected && !this.child.killed) {
             this.child.send?.({ type: 'rpc_response', id, result, error });
         }
     }
@@ -31,6 +32,15 @@ class RpcProcessor {
                     .catch((error) => this.response(id, null, error));
             }
         });
+        this.child.on('exit', () => {
+            this.isClosed = true;
+        });
+        this.child.on('close', () => {
+            this.isClosed = true;
+        });
+        this.child.on('disconnect', () => {
+            this.isClosed = true;
+        });
     }
 }
 exports.RpcProcessor = RpcProcessor;

package/dist/src/step-handlers.d.ts

@@ -1,2 +1,8 @@
-import { EventManager, InternalStateManager, Step } from './types';
-export declare const createStepHandlers: (steps: Step[], eventManager: EventManager, state: InternalStateManager) => void;
+import { EventConfig, EventManager, Step } from './types';
+import { LockedData } from './locked-data';
+import { StateAdapter } from './state/state-adapter';
+export type MotiaEventManager = {
+    createHandler: (step: Step<EventConfig>) => void;
+    removeHandler: (step: Step<EventConfig>) => void;
+};
+export declare const createStepHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => MotiaEventManager;

package/dist/src/step-handlers.js

@@ -2,32 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStepHandlers = void 0;
 const logger_1 = require("./logger");
-const guards_1 = require("./guards");
 const call_step_file_1 = require("./call-step-file");
-const createStepHandlers = (steps, eventManager, state) => {
-    logger_1.globalLogger.debug(`[step handler] creating step handlers for ${steps.length} steps`);
-    steps.filter(guards_1.isEventStep).forEach((step) => {
+const createStepHandlers = (lockedData, eventManager, state) => {
+    const eventSteps = lockedData.eventSteps();
+    logger_1.globalLogger.debug(`[step handler] creating step handlers for ${eventSteps.length} steps`);
+    const createHandler = (step) => {
         const { config, filePath } = step;
         const { subscribes } = config;
         logger_1.globalLogger.debug('[step handler] establishing step subscriptions', { filePath, step: step.config.name });
         subscribes.forEach((subscribe) => {
-            eventManager.subscribe(subscribe, step.config.name, async (event) => {
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const { logger, ...rest } = event;
-                logger_1.globalLogger.debug('[step handler] received event', { event: rest, step: step.config.name });
-                try {
-                    await (0, call_step_file_1.callStepFile)(filePath, step.config.name, event, eventManager, state);
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (error) {
-                    logger_1.globalLogger.error(`[step handler] error calling step`, {
-                        error: error.message,
-                        filePath,
-                        step: step.config.name,
-                    });
-                }
+            eventManager.subscribe({
+                filePath,
+                event: subscribe,
+                handlerName: step.config.name,
+                handler: async (event) => {
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { logger, ...rest } = event;
+                    logger_1.globalLogger.debug('[step handler] received event', { event: rest, step: step.config.name });
+                    try {
+                        await (0, call_step_file_1.callStepFile)(step, lockedData, event, eventManager, state);
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    }
+                    catch (error) {
+                        logger_1.globalLogger.error(`[step handler] error calling step`, {
+                            error: error.message,
+                            filePath,
+                            step: step.config.name,
+                        });
+                    }
+                },
             });
         });
-    });
+    };
+    const removeHandler = (step) => {
+        const { config, filePath } = step;
+        const { subscribes } = config;
+        subscribes.forEach((subscribe) => {
+            eventManager.unsubscribe({ filePath, event: subscribe });
+        });
+    };
+    eventSteps.forEach(createHandler);
+    return { removeHandler, createHandler };
 };
 exports.createStepHandlers = createStepHandlers;

package/dist/src/step-validator.d.ts

@@ -0,0 +1,14 @@
+import { Step } from './types';
+export type ValidationSuccess = {
+    success: true;
+};
+export type ValidationError = {
+    success: false;
+    error: string;
+    errors?: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export type ValidationResult = ValidationSuccess | ValidationError;
+export declare const validateStep: (step: Step) => ValidationResult;

package/dist/src/step-validator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStep = void 0;
+const zod_1 = require("zod");
+const emits = zod_1.z.array(zod_1.z.union([
+    zod_1.z.string(),
+    zod_1.z
+        .object({
+        type: zod_1.z.string(),
+        label: zod_1.z.string().optional(),
+        conditional: zod_1.z.boolean().optional(),
+    })
+        .strict(),
+]));
+const noopSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('noop'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    virtualEmits: emits,
+    virtualSubscribes: zod_1.z.array(zod_1.z.string()),
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const eventSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('event'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    subscribes: zod_1.z.array(zod_1.z.string()),
+    emits: emits,
+    virtualEmits: emits.optional(),
+    input: zod_1.z.any(),
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const apiSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('api'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    path: zod_1.z.string(),
+    method: zod_1.z.string(),
+    emits: emits,
+    virtualEmits: emits.optional(),
+    virtualSubscribes: zod_1.z.array(zod_1.z.string()).optional(),
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+    bodySchema: zod_1.z.instanceof(zod_1.z.ZodObject).optional(),
+})
+    .strict();
+const cronSchema = zod_1.z
+    .object({
+    type: zod_1.z.literal('cron'),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    cron: zod_1.z.string(),
+    virtualEmits: emits.optional(),
+    emits: emits,
+    flows: zod_1.z.array(zod_1.z.string()).optional(),
+})
+    .strict();
+const validateStep = (step) => {
+    try {
+        if (step.config.type === 'noop') {
+            noopSchema.parse(step.config);
+        }
+        else if (step.config.type === 'event') {
+            eventSchema.parse(step.config);
+        }
+        else if (step.config.type === 'api') {
+            apiSchema.parse(step.config);
+        }
+        else if (step.config.type === 'cron') {
+            cronSchema.parse(step.config);
+        }
+        else {
+            return {
+                success: false,
+                error: 'Invalid step type',
+            };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            return {
+                success: false,
+                error: 'Invalid step configuration',
+                errors: error.errors.map((err) => ({ path: err.path.join('.'), message: err.message })),
+            };
+        }
+        // Handle unexpected errors
+        return {
+            success: false,
+            error: 'Unexpected validation error occurred',
+        };
+    }
+};
+exports.validateStep = validateStep;

package/dist/src/types.d.ts

@@ -1,6 +1,4 @@
 import { z, ZodObject } from 'zod';
-import { Server } from 'http';
-import { Server as SocketIOServer } from 'socket.io';
 import { Logger } from './logger';
 export type InternalStateManager = {
     get<T>(traceId: string, key: string): Promise<T | null>;
@@ -25,7 +23,7 @@ export type Emit = string | {
     label?: string;
     conditional?: boolean;
 };
-export type EventConfig<TInput extends ZodObject<any>> = {
+export type EventConfig<TInput extends ZodObject<any> = any> = {
     type: 'event';
     name: string;
     description?: string;
@@ -33,7 +31,7 @@ export type EventConfig<TInput extends ZodObject<any>> = {
     emits: Emit[];
     virtualEmits?: Emit[];
     input: TInput;
-    flows: string[];
+    flows?: string[];
 };
 export type NoopConfig = {
     type: 'noop';
@@ -41,7 +39,7 @@ export type NoopConfig = {
     description?: string;
     virtualEmits: Emit[];
     virtualSubscribes: string[];
-    flows: string[];
+    flows?: string[];
 };
 export type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
 export type ApiRouteConfig = {
@@ -50,10 +48,10 @@ export type ApiRouteConfig = {
     description?: string;
     path: string;
     method: ApiRouteMethod;
-    emits: string[];
+    emits: Emit[];
     virtualEmits?: Emit[];
     virtualSubscribes?: string[];
-    flows: string[];
+    flows?: string[];
     bodySchema?: ZodObject<any>;
 };
 export type ApiRequest = {
@@ -74,23 +72,32 @@ export type CronConfig = {
     description?: string;
     cron: string;
     virtualEmits?: Emit[];
-    emits: string[];
-    flows: string[];
+    emits: Emit[];
+    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;
-export type MotiaSocketServer = SocketIOServer;
 export type Event<TData = unknown> = {
     type: string;
     data: TData;
     traceId: string;
-    flows: string[];
+    flows?: string[];
     logger: Logger;
 };
 export type Handler<TData = unknown> = (event: Event<TData>) => Promise<void>;
+export type SubscribeConfig<TData> = {
+    event: string;
+    handlerName: string;
+    filePath: string;
+    handler: Handler<TData>;
+};
+export type UnsubscribeConfig = {
+    filePath: string;
+    event: string;
+};
 export type EventManager = {
     emit: <TData>(event: Event<TData>, file?: string) => Promise<void>;
-    subscribe: <TData>(event: string, handlerName: string, handler: Handler<TData>) => void;
+    subscribe: <TData>(config: SubscribeConfig<TData>) => void;
+    unsubscribe: (config: UnsubscribeConfig) => void;
 };
 export type StepConfig = EventConfig<ZodObject<any>> | NoopConfig | ApiRouteConfig | CronConfig;
 export type Step<TConfig extends StepConfig = StepConfig> = {
@@ -103,16 +110,3 @@ export type Flow = {
     description?: string;
     steps: Step[];
 };
-export type LockedData = {
-    baseDir: string;
-    steps: {
-        active: Step[];
-        dev: Step[];
-    };
-    flows: Record<string, Flow>;
-    state: {
-        adapter: string;
-        host: string;
-        port: number;
-    };
-};

package/dist/src/utils.d.ts

@@ -0,0 +1,2 @@
+import { Step } from './types';
+export declare const isAllowedToEmit: (step: Step, emit: string) => boolean;

package/dist/src/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedToEmit = void 0;
+const guards_1 = require("./guards");
+const toType = (emit) => (typeof emit === 'string' ? emit : emit.type);
+const isAllowedToEmit = (step, emit) => {
+    if ((0, guards_1.isApiStep)(step)) {
+        return step.config.emits.map(toType).includes(emit);
+    }
+    if ((0, guards_1.isEventStep)(step)) {
+        return step.config.emits.map(toType).includes(emit);
+    }
+    return false;
+};
+exports.isAllowedToEmit = isAllowedToEmit;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "dependencies": {
     "body-parser": "^1.20.3",
+    "colors": "^1.4.0",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
     "node-cron": "^3.0.3",

package/dist/src/ruby/state_adapter.rb

@@ -1,62 +0,0 @@
-require 'net/http'
-require 'json'
-require 'uri'
-require 'logger'
-
-class StateManagerError < StandardError; end
-
-LOGGER = Logger.new($stdout)
-
-def get_state_manager_handler(state_manager_url)
-  lambda do |action, payload|
-    begin
-      uri = URI("#{state_manager_url}/#{action}")
-      request = Net::HTTP::Post.new(uri)
-      request['Content-Type'] = 'application/json'
-      request['x-trace-id'] = payload[:traceId]
-      # TODO: Add internal auth token for security
-      # TODO: Encrypt the payload for security
-      request.body = payload.to_json
-
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-        http.request(request)
-      end
-
-      unless response.is_a?(Net::HTTPSuccess)
-        error_message = "Failed posting state change: #{response.code} - #{response.message}"
-        LOGGER.error(error_message)
-        raise StateManagerError, error_message
-      end
-
-      if action == 'get'
-        result = JSON.parse(response.body, object_class: OpenStruct)
-        return result.data
-      end
-
-      nil
-    rescue StandardError => error
-      LOGGER.error("[internal state manager] failed posting state change: #{error.message}")
-      raise StateManagerError, "Failed posting state change: #{error.message}"
-    end
-  end
-end
-
-def create_internal_state_manager(state_manager_url:)
-  handler = get_state_manager_handler(state_manager_url)
-
-  {
-    get: ->(trace_id, key) { 
-      result = handler.call('get', { traceId: trace_id, key: key })
-      { data: result }
-    },
-    set: ->(trace_id, key, value) { 
-      handler.call('set', { traceId: trace_id, key: key, value: value })
-    },
-    delete: ->(trace_id, key) { 
-      handler.call('delete', { traceId: trace_id, key: key })
-    },
-    clear: ->(trace_id) {
-      handler.call('clear', { traceId: trace_id })
-    }
-  }
-end