@morojs/moro 1.0.0

package/src/core/middleware/index.ts

@@ -0,0 +1,188 @@
+// Middleware System for Moro
+import { EventEmitter } from "events";
+import { HookManager } from "../utilities";
+import {
+  MiddlewareMetadata,
+  MiddlewareContext,
+  MiddlewareInterface,
+  SimpleMiddlewareFunction,
+  MoroMiddleware,
+} from "../../types/hooks";
+import { createFrameworkLogger } from "../logger";
+
+// Export types needed by built-in middleware
+export type { MiddlewareInterface, MoroMiddleware } from "../../types/hooks";
+
+export class MiddlewareManager extends EventEmitter {
+  private middleware = new Map<string, MiddlewareInterface>();
+  private simpleMiddleware = new Map<string, SimpleMiddlewareFunction>();
+  private hooks: HookManager;
+  private logger = createFrameworkLogger("Middleware");
+
+  constructor() {
+    super();
+    this.hooks = new HookManager();
+  }
+
+  // Register middleware without installing
+  register(name: string, middleware: MiddlewareInterface): void {
+    if (this.middleware.has(name)) {
+      throw new Error(`Middleware ${name} is already registered`);
+    }
+
+    this.middleware.set(name, middleware);
+    this.logger.debug(`Registered middleware: ${name}`, "Registration");
+    this.emit("registered", { name, middleware });
+  }
+
+  // Install simple function-style middleware
+  install(
+    middleware: SimpleMiddlewareFunction | MiddlewareInterface,
+    options: any = {},
+  ): void {
+    if (typeof middleware === "function") {
+      // Simple function-style middleware
+      const simpleName = middleware.name || "anonymous";
+      this.logger.debug(
+        `Installing simple middleware: ${simpleName}`,
+        "Installation",
+      );
+
+      this.simpleMiddleware.set(simpleName, middleware);
+      this.emit("installed", { name: simpleName, type: "simple" });
+      this.logger.info(
+        `Simple middleware installed: ${simpleName}`,
+        "Installation",
+      );
+      return;
+    }
+
+    // Advanced middleware with dependencies and lifecycle
+    const name = middleware.metadata?.name || "unknown";
+
+    if (this.middleware.has(name)) {
+      throw new Error(`Middleware ${name} is already installed`);
+    }
+
+    // Check dependencies
+    if (middleware.metadata?.dependencies) {
+      for (const dep of middleware.metadata.dependencies) {
+        if (!this.middleware.has(dep)) {
+          throw new Error(`Dependency ${dep} not found for middleware ${name}`);
+        }
+      }
+    }
+
+    // Store middleware
+    this.middleware.set(name, middleware);
+
+    this.logger.debug(`Installing middleware: ${name}`, "Installation");
+
+    // Initialize middleware
+    if (middleware.install) {
+      middleware.install(this.hooks, options);
+    }
+
+    this.emit("installed", { name, middleware, options });
+    this.logger.info(`Middleware installed: ${name}`, "Installation");
+  }
+
+  // Uninstall middleware and clean up
+  uninstall(name: string): void {
+    if (!this.middleware.has(name)) {
+      throw new Error(`Middleware ${name} is not installed`);
+    }
+
+    const middleware = this.middleware.get(name)!;
+
+    this.logger.debug(`Uninstalling middleware: ${name}`, "Uninstallation");
+
+    // Call cleanup if available
+    if (middleware.uninstall) {
+      middleware.uninstall(this.hooks);
+    }
+
+    this.middleware.delete(name);
+    this.emit("uninstalled", { name, middleware });
+    this.logger.info(`Middleware uninstalled: ${name}`, "Uninstallation");
+  }
+
+  // Get installed middleware
+  getInstalled(): string[] {
+    return Array.from(this.middleware.keys());
+  }
+
+  // Get middleware configuration
+  getConfig(name: string): any {
+    return this.middleware.get(name)?.metadata;
+  }
+
+  // Check if middleware is installed
+  isInstalled(name: string): boolean {
+    return this.middleware.has(name);
+  }
+
+  // List all registered middleware
+  list(): MiddlewareInterface[] {
+    return Array.from(this.middleware.values());
+  }
+
+  // Dependency resolution with topological sorting for optimal middleware loading
+  async installWithDependencies(
+    middleware: MiddlewareInterface[],
+    options?: Record<string, any>,
+  ): Promise<void> {
+    // Advanced topological sort for dependency resolution
+    const resolved = this.topologicalSort(middleware);
+
+    for (const middlewareItem of resolved) {
+      const middlewareOptions = options?.[middlewareItem.name];
+      await this.install(middlewareItem, middlewareOptions);
+    }
+  }
+
+  // Optimized topological sort implementation for middleware dependencies
+  private topologicalSort(
+    middleware: MiddlewareInterface[],
+  ): MiddlewareInterface[] {
+    const visited = new Set<string>();
+    const temp = new Set<string>();
+    const result: MiddlewareInterface[] = [];
+
+    const visit = (middlewareItem: MiddlewareInterface) => {
+      if (temp.has(middlewareItem.name)) {
+        throw new Error(`Circular dependency detected: ${middlewareItem.name}`);
+      }
+
+      if (!visited.has(middlewareItem.name)) {
+        temp.add(middlewareItem.name);
+
+        // Visit dependencies first
+        if (middlewareItem.dependencies) {
+          for (const depName of middlewareItem.dependencies) {
+            const dependency = middleware.find((m) => m.name === depName);
+            if (dependency) {
+              visit(dependency);
+            }
+          }
+        }
+
+        temp.delete(middlewareItem.name);
+        visited.add(middlewareItem.name);
+        result.push(middlewareItem);
+      }
+    };
+
+    for (const middlewareItem of middleware) {
+      if (!visited.has(middlewareItem.name)) {
+        visit(middlewareItem);
+      }
+    }
+
+    return result;
+  }
+}
+
+// Built-in middleware exports
+export { builtInMiddleware, simpleMiddleware } from "./built-in";
+export * from "./built-in";

package/src/core/modules/auto-discovery.ts

@@ -0,0 +1,265 @@
+// Auto-discovery system for Moro modules
+import { readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+import { ModuleConfig } from "../../types/module";
+import { DiscoveryOptions } from "../../types/discovery";
+
+export class ModuleDiscovery {
+  private baseDir: string;
+  private options: DiscoveryOptions;
+
+  constructor(baseDir: string = process.cwd(), options: DiscoveryOptions = {}) {
+    this.baseDir = baseDir;
+    this.options = {
+      pattern: /\.(module|config)\.(ts|js)$/,
+      recursive: true,
+      extensions: [".ts", ".js"],
+      ...options,
+    };
+  }
+
+  // Auto-discover modules in the filesystem
+  async discoverModules(): Promise<ModuleConfig[]> {
+    const modules: ModuleConfig[] = [];
+    const modulePaths = this.findModuleFiles();
+
+    for (const modulePath of modulePaths) {
+      try {
+        const module = await this.loadModule(modulePath);
+        if (module) {
+          modules.push(module);
+          console.log(
+            `Auto-discovered module: ${module.name}@${module.version} from ${modulePath}`,
+          );
+        }
+      } catch (error) {
+        console.warn(`Failed to load module from ${modulePath}:`, error);
+      }
+    }
+
+    return modules;
+  }
+
+  // Find modules by directory structure
+  async discoverModuleDirectories(
+    modulesDir: string = "src/modules",
+  ): Promise<ModuleConfig[]> {
+    const modules: ModuleConfig[] = [];
+    const fullPath = join(this.baseDir, modulesDir);
+
+    try {
+      if (!statSync(fullPath).isDirectory()) {
+        return modules;
+      }
+
+      const items = readdirSync(fullPath);
+
+      for (const item of items) {
+        const itemPath = join(fullPath, item);
+
+        if (statSync(itemPath).isDirectory()) {
+          const indexPath = join(itemPath, "index.ts");
+
+          try {
+            if (statSync(indexPath).isFile()) {
+              const module = await this.loadModule(indexPath);
+              if (module) {
+                modules.push(module);
+                console.log(
+                  `Auto-discovered module directory: ${module.name} from ${item}/`,
+                );
+              }
+            }
+          } catch {
+            // Try alternate patterns
+            const alternates = ["module.ts", `${item}.module.ts`, "config.ts"];
+
+            for (const alt of alternates) {
+              const altPath = join(itemPath, alt);
+              try {
+                if (statSync(altPath).isFile()) {
+                  const module = await this.loadModule(altPath);
+                  if (module) {
+                    modules.push(module);
+                    console.log(
+                      `Auto-discovered module: ${module.name} from ${item}/${alt}`,
+                    );
+                    break;
+                  }
+                }
+              } catch {
+                // Continue trying
+              }
+            }
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist, that's fine
+    }
+
+    return modules;
+  }
+
+  // Find all module files matching the pattern
+  private findModuleFiles(): string[] {
+    const files: string[] = [];
+    this.scanDirectory(this.baseDir, files);
+    return files.filter((file) => this.options.pattern?.test(file));
+  }
+
+  // Recursively scan directories for module files
+  private scanDirectory(dir: string, files: string[]): void {
+    try {
+      const items = readdirSync(dir);
+
+      for (const item of items) {
+        const fullPath = join(dir, item);
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          // Skip node_modules and other common directories
+          if (
+            !["node_modules", ".git", "dist", "build"].includes(item) &&
+            this.options.recursive
+          ) {
+            this.scanDirectory(fullPath, files);
+          }
+        } else if (stat.isFile()) {
+          const ext = extname(item);
+          if (this.options.extensions?.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+      // Directory not accessible, skip
+    }
+  }
+
+  // Load a module from a file path
+  private async loadModule(modulePath: string): Promise<ModuleConfig | null> {
+    try {
+      const module = await import(modulePath);
+
+      // Try different export patterns
+      const candidates = [
+        module.default,
+        module.module,
+        module.config,
+        module,
+        ...Object.values(module).filter(
+          (exp) =>
+            exp && typeof exp === "object" && "name" in exp && "version" in exp,
+        ),
+      ];
+
+      for (const candidate of candidates) {
+        if (this.isValidModule(candidate)) {
+          return candidate as ModuleConfig;
+        }
+      }
+
+      return null;
+    } catch (error) {
+      throw new Error(`Failed to import module: ${(error as Error).message}`);
+    }
+  }
+
+  // Validate that an object is a valid ModuleConfig
+  private isValidModule(obj: any): boolean {
+    return (
+      obj &&
+      typeof obj === "object" &&
+      typeof obj.name === "string" &&
+      typeof obj.version === "string" &&
+      (obj.routes === undefined || Array.isArray(obj.routes)) &&
+      (obj.websockets === undefined || Array.isArray(obj.websockets)) &&
+      (obj.services === undefined || Array.isArray(obj.services))
+    );
+  }
+
+  // Watch for module changes (for development)
+  watchModules(callback: (modules: ModuleConfig[]) => void): void {
+    const fs = require("fs");
+    const modulePaths = this.findModuleFiles();
+
+    modulePaths.forEach((path) => {
+      try {
+        fs.watchFile(path, async () => {
+          console.log(`Module file changed: ${path}`);
+          const modules = await this.discoverModules();
+          callback(modules);
+        });
+      } catch {
+        // File watching not supported or failed
+      }
+    });
+  }
+}
+
+// Convenience functions
+export async function autoDiscoverModules(
+  baseDir?: string,
+  options?: DiscoveryOptions,
+): Promise<ModuleConfig[]> {
+  const discovery = new ModuleDiscovery(baseDir, options);
+  return discovery.discoverModules();
+}
+
+export async function autoDiscoverModuleDirectories(
+  baseDir?: string,
+  modulesDir?: string,
+): Promise<ModuleConfig[]> {
+  const discovery = new ModuleDiscovery(baseDir);
+  return discovery.discoverModuleDirectories(modulesDir);
+}
+
+// Module registry for tracking loaded modules
+export class ModuleRegistry {
+  private modules = new Map<string, ModuleConfig>();
+  private loadedModules = new Set<string>();
+
+  register(module: ModuleConfig): void {
+    const key = `${module.name}@${module.version}`;
+    this.modules.set(key, module);
+  }
+
+  markLoaded(moduleName: string, version: string): void {
+    const key = `${moduleName}@${version}`;
+    this.loadedModules.add(key);
+  }
+
+  isLoaded(moduleName: string, version: string): boolean {
+    const key = `${moduleName}@${version}`;
+    return this.loadedModules.has(key);
+  }
+
+  getModule(moduleName: string, version?: string): ModuleConfig | undefined {
+    if (version) {
+      return this.modules.get(`${moduleName}@${version}`);
+    }
+
+    // Find latest version if no version specified
+    const modules = Array.from(this.modules.entries())
+      .filter(([key]) => key.startsWith(`${moduleName}@`))
+      .sort(([a], [b]) => b.localeCompare(a)); // Sort by version desc
+
+    return modules[0]?.[1];
+  }
+
+  getAllModules(): ModuleConfig[] {
+    return Array.from(this.modules.values());
+  }
+
+  getLoadedModules(): ModuleConfig[] {
+    return Array.from(this.modules.entries())
+      .filter(([key]) => this.loadedModules.has(key))
+      .map(([, module]) => module);
+  }
+
+  clear(): void {
+    this.modules.clear();
+    this.loadedModules.clear();
+  }
+}

package/src/core/modules/index.ts

@@ -0,0 +1,6 @@
+// Module System - Centralized Exports
+export { defineModule, ModuleLoader } from "./modules";
+export {
+  ModuleDiscovery,
+  autoDiscoverModuleDirectories,
+} from "./auto-discovery";

package/src/core/modules/modules.ts

@@ -0,0 +1,125 @@
+// Module System - Definition and Loading
+import { promises as fs } from "fs";
+import path from "path";
+import { Container } from "../utilities";
+import { ModuleConfig } from "../../types/module";
+import {
+  ModuleDefinition,
+  ModuleRoute,
+  ModuleSocket,
+} from "../../types/module";
+
+// Module Definition Function
+export function defineModule(definition: ModuleDefinition): ModuleConfig {
+  const moduleConfig: ModuleConfig = {
+    name: definition.name,
+    version: definition.version,
+    dependencies: definition.dependencies,
+  };
+
+  // Store route definitions and handlers
+  if (definition.routes) {
+    moduleConfig.routes = definition.routes.map((route, index) => ({
+      method: route.method,
+      path: route.path,
+      handler: `route_handler_${index}`, // Standardized naming
+      validation: route.validation,
+      cache: route.cache,
+      rateLimit: route.rateLimit,
+      middleware: route.middleware,
+    }));
+
+    // Store the actual route handler functions
+    moduleConfig.routeHandlers = definition.routes.reduce(
+      (acc, route, index) => {
+        acc[`route_handler_${index}`] = route.handler;
+        return acc;
+      },
+      {} as Record<string, Function>,
+    );
+  }
+
+  // Store socket definitions and handlers
+  if (definition.sockets) {
+    moduleConfig.sockets = definition.sockets.map((socket, index) => ({
+      event: socket.event,
+      handler: `socket_handler_${index}`, // Standardized naming
+      validation: socket.validation,
+      rateLimit: socket.rateLimit,
+      rooms: socket.rooms,
+      broadcast: socket.broadcast,
+    }));
+
+    // Store the actual socket handler functions
+    moduleConfig.socketHandlers = definition.sockets.reduce(
+      (acc, socket, index) => {
+        acc[`socket_handler_${index}`] = socket.handler;
+        return acc;
+      },
+      {} as Record<string, Function>,
+    );
+  }
+
+  // Copy config
+  if (definition.config) {
+    moduleConfig.config = definition.config;
+  }
+
+  return moduleConfig;
+}
+
+// Module Loader Class
+export class ModuleLoader {
+  constructor(private container: Container) {}
+
+  async discoverModules(directory: string): Promise<ModuleConfig[]> {
+    const modules: ModuleConfig[] = [];
+
+    try {
+      const moduleDir = path.resolve(directory);
+      const entries = await fs.readdir(moduleDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const modulePath = path.join(moduleDir, entry.name, "index.ts");
+
+          try {
+            await fs.access(modulePath);
+            const moduleExports = await import(modulePath);
+
+            // Look for exported module config
+            for (const exportName of Object.keys(moduleExports)) {
+              const exported = moduleExports[exportName];
+              if (
+                exported &&
+                typeof exported === "object" &&
+                exported.name &&
+                exported.version
+              ) {
+                modules.push(exported as ModuleConfig);
+              }
+            }
+          } catch (error) {
+            console.warn(
+              `⚠️  Could not load module from ${modulePath}:`,
+              error instanceof Error ? error.message : String(error),
+            );
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Failed to discover modules:", error);
+    }
+
+    return modules;
+  }
+
+  validateModule(config: ModuleConfig): boolean {
+    if (!config.name || !config.version) {
+      return false;
+    }
+
+    // [TODO] Add more validation logic here
+    return true;
+  }
+}

package/src/core/networking/index.ts

@@ -0,0 +1,7 @@
+// Networking System - Centralized Exports
+export { WebSocketManager } from "./websocket-manager";
+export {
+  ServiceRegistry,
+  ServiceInfo,
+  ServiceDiscoveryOptions,
+} from "./service-discovery";