@morojs/moro 1.6.1 → 1.6.2

package/dist/moro.d.ts

@@ -1,27 +1,36 @@
-import { Moro as MoroCore } from './core/framework';
-import { HttpRequest, HttpResponse } from './core/http';
-import { ModuleConfig } from './types/module';
-import { MoroOptions } from './types/core';
-import { MoroEventBus } from './core/events';
-import { RouteBuilder, RouteSchema, CompiledRoute } from './core/routing';
-import { DocsConfig } from './core/docs';
+import { Moro as MoroCore } from './core/framework.js';
+import { HttpRequest, HttpResponse } from './core/http/index.js';
+import { ModuleConfig } from './types/module.js';
+import { MoroOptions } from './types/core.js';
+import { MoroEventBus } from './core/events/index.js';
+import { RouteSchema } from './core/routing/index.js';
+import { RouteBuilder as UnifiedRouteBuilder } from './core/routing/unified-router.js';
+import { DocsConfig } from './core/docs/index.js';
 import { EventEmitter } from 'events';
-import { type AppConfig } from './core/config';
-import { RuntimeAdapter, RuntimeType } from './core/runtime';
+import { type AppConfig } from './core/config/index.js';
+import { RuntimeAdapter, RuntimeType } from './core/runtime/index.js';
 export declare class Moro extends EventEmitter {
     private coreFramework;
     private routes;
     private moduleCounter;
     private loadedModules;
+    private lazyModules;
     private routeHandlers;
+    private moduleDiscovery?;
+    private autoDiscoveryOptions;
+    private autoDiscoveryInitialized;
+    private autoDiscoveryPromise;
     private eventBus;
     private logger;
+    private unifiedRouter;
     private intelligentRouting;
     private documentation;
     private config;
+    private userSetLogger;
     private runtimeAdapter;
     private runtimeType;
     private middlewareManager;
+    private queuedWebSocketRegistrations;
     constructor(options?: MoroOptions);
     /**
      * Get configuration object
@@ -39,19 +48,19 @@ export declare class Moro extends EventEmitter {
      * Extract default options from configuration
      */
     private getDefaultOptionsFromConfig;
-    get(path: string): RouteBuilder;
+    get(path: string): UnifiedRouteBuilder;
     get(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-    post(path: string): RouteBuilder;
+    post(path: string): UnifiedRouteBuilder;
     post(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-    put(path: string): RouteBuilder;
+    put(path: string): UnifiedRouteBuilder;
     put(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-    delete(path: string): RouteBuilder;
+    delete(path: string): UnifiedRouteBuilder;
     delete(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-    patch(path: string): RouteBuilder;
+    patch(path: string): UnifiedRouteBuilder;
     patch(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-    route(schema: RouteSchema): CompiledRoute;
+    route(schema: RouteSchema): void;
     enableDocs(config: DocsConfig): void;
-    getOpenAPISpec(): import("./core/docs").OpenAPISpec;
+    getOpenAPISpec(): import("./core/docs/openapi-generator.js").OpenAPISpec;
     getDocsJSON(): string;
     getDocsYAML(): string;
     refreshDocs(): void;
@@ -60,9 +69,25 @@ export declare class Moro extends EventEmitter {
     loadModule(moduleOrPath: ModuleConfig | string): Promise<this>;
     database(adapter: any): this;
     websocket(namespace: string, handlers: Record<string, Function>): this;
+    private processWebSocketRegistration;
+    private processQueuedWebSocketRegistrations;
     listen(callback?: () => void): void;
     listen(port: number, callback?: () => void): void;
     listen(port: number, host: string, callback?: () => void): void;
+    initializeAutoDiscoveryNow(): Promise<void>;
+    initModules(options?: {
+        paths?: string[];
+        patterns?: string[];
+        recursive?: boolean;
+        loadingStrategy?: 'eager' | 'lazy' | 'conditional';
+        watchForChanges?: boolean;
+        ignorePatterns?: string[];
+        loadOrder?: 'alphabetical' | 'dependency' | 'custom';
+        failOnError?: boolean;
+        maxDepth?: number;
+    }): void;
+    private ensureAutoDiscoveryComplete;
+    private performAutoDiscovery;
     getHandler(): any;
     private handleDirectRoutes;
     private routeCache;
@@ -79,11 +104,40 @@ export declare class Moro extends EventEmitter {
     private rateLimitStore;
     private checkRateLimit;
     private setupDefaultMiddleware;
+    private initializeAutoDiscovery;
+    private mergeAutoDiscoveryConfig;
+    private loadDiscoveredModules;
+    private registerLazyModules;
+    private loadConditionalModules;
+    private shouldLoadModule;
+    private handleModuleChanges;
     private autoDiscoverModules;
     private importModule;
+    /**
+     * Node.js Clustering Implementation
+     * This clustering algorithm is based on published research and Node.js best practices.
+     *
+     * IPC (Inter-Process Communication) Considerations:
+     * - Excessive workers create IPC bottlenecks (Source: BetterStack Node.js Guide)
+     * - Round-robin scheduling provides better load distribution (Node.js Documentation)
+     * - Message passing overhead increases significantly with worker count
+     *
+     * Memory Management:
+     * - ~2GB per worker prevents memory pressure and GC overhead
+     * - Conservative heap limits reduce memory fragmentation
+     *
+     * References:
+     * - Node.js Cluster Documentation: https://nodejs.org/api/cluster.html
+     * - BetterStack Node.js Clustering: https://betterstack.com/community/guides/scaling-nodejs/node-clustering/
+     */
     private clusterWorkers;
     private startWithClustering;
     private handleWorkerMessage;
+    /**
+     * Gracefully close the application and clean up resources
+     * This should be called in tests and during shutdown
+     */
+    close(): Promise<void>;
 }
 export declare function createApp(options?: MoroOptions): Moro;
 export declare function createAppNode(options?: Omit<MoroOptions, 'runtime'>): Moro;