@onebun/core 0.1.18 → 0.1.20

package/src/module/module.ts

@@ -29,6 +29,13 @@ import {
   type IConfig,
   type OneBunAppConfig,
 } from './config.interface';
+import {
+  hasOnModuleInit,
+  hasOnApplicationInit,
+  hasOnModuleDestroy,
+  hasBeforeApplicationDestroy,
+  hasOnApplicationDestroy,
+} from './lifecycle';
 import { getServiceMetadata, getServiceTag } from './service';
 
 /**
@@ -68,7 +75,7 @@ export class OneBunModule implements ModuleInstance {
   private controllers: Function[] = [];
   private controllerInstances: Map<Function, Controller> = new Map();
   private serviceInstances: Map<Context.Tag<unknown, unknown>, unknown> = new Map();
-  private pendingAsyncInits: Array<{ name: string; init: () => Promise<void> }> = [];
+  private pendingServiceInits: Array<{ name: string; instance: unknown }> = [];
   private logger: SyncLogger;
   private config: IConfig<OneBunAppConfig>;
 
@@ -162,9 +169,6 @@ export class OneBunModule implements ModuleInstance {
         // Merge layers
         layer = Layer.merge(layer, childModule.getLayer());
 
-        // Add controllers from child module
-        controllers.push(...childModule.getControllers());
-
         // Get exported services from child module and register them for DI
         const exportedServices = childModule.getExportedServices();
         for (const [tag, instance] of exportedServices) {
@@ -303,16 +307,11 @@ export class OneBunModule implements ModuleInstance {
             .initializeService(this.logger, this.config);
         }
 
-        // Track services that need async initialization
-        if (
-          serviceInstance &&
-          typeof serviceInstance === 'object' &&
-          'onAsyncInit' in serviceInstance &&
-          typeof (serviceInstance as { onAsyncInit: unknown }).onAsyncInit === 'function'
-        ) {
-          this.pendingAsyncInits.push({
+        // Track services that need lifecycle hooks (onModuleInit)
+        if (hasOnModuleInit(serviceInstance)) {
+          this.pendingServiceInits.push({
             name: provider.name,
-            init: () => (serviceInstance as { onAsyncInit: () => Promise<void> }).onAsyncInit(),
+            instance: serviceInstance,
           });
         }
 
@@ -384,48 +383,20 @@ export class OneBunModule implements ModuleInstance {
    */
   createControllerInstances(): Effect.Effect<unknown, never, void> {
     return Effect.sync(() => {
-      // Services are already created in initModule via createServicesWithDI
-      // Just need to set up controllers with DI
-
-      // Get module metadata to access providers for controller dependency registration
-      const moduleMetadata = getModuleMetadata(this.moduleClass);
-      if (moduleMetadata && moduleMetadata.providers) {
-        // Create map of available services for dependency resolution
-        const availableServices = new Map<string, Function>();
-
-        // For each provider that is a class constructor, add to available services map
-        for (const provider of moduleMetadata.providers) {
-          if (typeof provider === 'function') {
-            availableServices.set(provider.name, provider);
-          }
-        }
-
-        // Also add services from imported modules
-        for (const childModule of this.childModules) {
-          const childMetadata = getModuleMetadata(childModule.moduleClass);
-          if (childMetadata?.exports) {
-            for (const exported of childMetadata.exports) {
-              if (typeof exported === 'function') {
-                availableServices.set(exported.name, exported);
-              }
-            }
-          }
-        }
-
-        // Add global services to available services for dependency resolution
-        for (const [, instance] of globalServicesRegistry) {
-          if (instance && typeof instance === 'object') {
-            availableServices.set(instance.constructor.name, instance.constructor);
-          }
+      // Build map of available services from this module's DI scope (own providers + imported exports + global)
+      const availableServices = new Map<string, Function>();
+      for (const [, instance] of this.serviceInstances) {
+        if (instance && typeof instance === 'object') {
+          availableServices.set(instance.constructor.name, instance.constructor);
         }
+      }
 
-        // Automatically analyze and register dependencies for all controllers
-        for (const controllerClass of this.controllers) {
-          registerControllerDependencies(controllerClass, availableServices);
-        }
+      // Automatically analyze and register dependencies for all controllers of this module
+      for (const controllerClass of this.controllers) {
+        registerControllerDependencies(controllerClass, availableServices);
       }
 
-      // Now create controller instances with automatic dependency injection
+      // Create controller instances with automatic dependency injection
       this.createControllersWithDI();
     }).pipe(Effect.provide(this.rootLayer));
   }
@@ -558,35 +529,50 @@ export class OneBunModule implements ModuleInstance {
    * Setup the module and its dependencies
    */
   setup(): Effect.Effect<unknown, never, void> {
-    return this.runAsyncServiceInit().pipe(
-      // Also run async init for child modules
+    return this.callServicesOnModuleInit().pipe(
+      // Also run onModuleInit for child modules' services
+      Effect.flatMap(() =>
+        Effect.forEach(this.childModules, (childModule) => childModule.callServicesOnModuleInit(), {
+          discard: true,
+        }),
+      ),
+      // Create controller instances in child modules first, then this module (each uses its own DI scope)
       Effect.flatMap(() =>
-        Effect.forEach(this.childModules, (childModule) => childModule.runAsyncServiceInit(), {
+        Effect.forEach(this.childModules, (childModule) => childModule.createControllerInstances(), {
           discard: true,
         }),
       ),
-      // Then create controller instances
       Effect.flatMap(() => this.createControllerInstances()),
+      // Then call onModuleInit for controllers
+      Effect.flatMap(() => this.callControllersOnModuleInit()),
+      // Also run onModuleInit for child modules' controllers
+      Effect.flatMap(() =>
+        Effect.forEach(this.childModules, (childModule) => childModule.callControllersOnModuleInit(), {
+          discard: true,
+        }),
+      ),
     );
   }
 
   /**
-   * Run async initialization for all services that need it
+   * Call onModuleInit lifecycle hook for all services that implement it
    */
-  runAsyncServiceInit(): Effect.Effect<unknown, never, void> {
-    if (this.pendingAsyncInits.length === 0) {
+  callServicesOnModuleInit(): Effect.Effect<unknown, never, void> {
+    if (this.pendingServiceInits.length === 0) {
       return Effect.void;
     }
 
-    this.logger.debug(`Running async initialization for ${this.pendingAsyncInits.length} service(s)`);
+    this.logger.debug(`Calling onModuleInit for ${this.pendingServiceInits.length} service(s)`);
 
-    // Run all async inits in parallel
-    const initPromises = this.pendingAsyncInits.map(async ({ name, init }) => {
+    // Run all service onModuleInit hooks sequentially
+    const initPromises = this.pendingServiceInits.map(async ({ name, instance }) => {
       try {
-        await init();
-        this.logger.debug(`Service ${name} async initialization completed`);
+        if (hasOnModuleInit(instance)) {
+          await instance.onModuleInit();
+        }
+        this.logger.debug(`Service ${name} onModuleInit completed`);
       } catch (error) {
-        this.logger.error(`Service ${name} async initialization failed: ${error}`);
+        this.logger.error(`Service ${name} onModuleInit failed: ${error}`);
         throw error;
       }
     });
@@ -594,45 +580,250 @@ export class OneBunModule implements ModuleInstance {
     return Effect.promise(() => Promise.all(initPromises)).pipe(
       Effect.map(() => {
         // Clear the list after initialization
-        this.pendingAsyncInits = [];
+        this.pendingServiceInits = [];
       }),
     );
   }
 
   /**
-   * Get all controllers from this module
+   * Call onModuleInit lifecycle hook for all controllers that implement it
+   */
+  callControllersOnModuleInit(): Effect.Effect<unknown, never, void> {
+    const controllers = Array.from(this.controllerInstances.values());
+    const controllersWithInit = controllers.filter((c): c is Controller & { onModuleInit(): Promise<void> | void } => 
+      hasOnModuleInit(c),
+    );
+
+    if (controllersWithInit.length === 0) {
+      return Effect.void;
+    }
+
+    this.logger.debug(`Calling onModuleInit for ${controllersWithInit.length} controller(s)`);
+
+    const initPromises = controllersWithInit.map(async (controller) => {
+      try {
+        await controller.onModuleInit();
+        this.logger.debug(`Controller ${controller.constructor.name} onModuleInit completed`);
+      } catch (error) {
+        this.logger.error(`Controller ${controller.constructor.name} onModuleInit failed: ${error}`);
+        throw error;
+      }
+    });
+
+    return Effect.promise(() => Promise.all(initPromises));
+  }
+
+  /**
+   * Call onApplicationInit lifecycle hook for all services and controllers
+   */
+  async callOnApplicationInit(): Promise<void> {
+    // Call for services
+    for (const [, instance] of this.serviceInstances) {
+      if (hasOnApplicationInit(instance)) {
+        try {
+          await instance.onApplicationInit();
+          this.logger.debug(`Service ${(instance as object).constructor.name} onApplicationInit completed`);
+        } catch (error) {
+          this.logger.error(`Service ${(instance as object).constructor.name} onApplicationInit failed: ${error}`);
+          throw error;
+        }
+      }
+    }
+
+    // Call for controllers
+    for (const [, controller] of this.controllerInstances) {
+      if (hasOnApplicationInit(controller)) {
+        try {
+          await controller.onApplicationInit();
+          this.logger.debug(`Controller ${controller.constructor.name} onApplicationInit completed`);
+        } catch (error) {
+          this.logger.error(`Controller ${controller.constructor.name} onApplicationInit failed: ${error}`);
+          throw error;
+        }
+      }
+    }
+
+    // Call for child modules
+    for (const childModule of this.childModules) {
+      await childModule.callOnApplicationInit();
+    }
+  }
+
+  /**
+   * Call beforeApplicationDestroy lifecycle hook for all services and controllers
+   */
+  async callBeforeApplicationDestroy(signal?: string): Promise<void> {
+    // Call for services
+    for (const [, instance] of this.serviceInstances) {
+      if (hasBeforeApplicationDestroy(instance)) {
+        try {
+          await instance.beforeApplicationDestroy(signal);
+          this.logger.debug(`Service ${(instance as object).constructor.name} beforeApplicationDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Service ${(instance as object).constructor.name} beforeApplicationDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for controllers
+    for (const [, controller] of this.controllerInstances) {
+      if (hasBeforeApplicationDestroy(controller)) {
+        try {
+          await controller.beforeApplicationDestroy(signal);
+          this.logger.debug(`Controller ${controller.constructor.name} beforeApplicationDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Controller ${controller.constructor.name} beforeApplicationDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for child modules
+    for (const childModule of this.childModules) {
+      await childModule.callBeforeApplicationDestroy(signal);
+    }
+  }
+
+  /**
+   * Call onModuleDestroy lifecycle hook for controllers first, then services
+   */
+  async callOnModuleDestroy(): Promise<void> {
+    // Call for controllers first (reverse order of creation)
+    const controllers = Array.from(this.controllerInstances.values()).reverse();
+    for (const controller of controllers) {
+      if (hasOnModuleDestroy(controller)) {
+        try {
+          await controller.onModuleDestroy();
+          this.logger.debug(`Controller ${controller.constructor.name} onModuleDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Controller ${controller.constructor.name} onModuleDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for services (reverse order of creation)
+    const services = Array.from(this.serviceInstances.values()).reverse();
+    for (const instance of services) {
+      if (hasOnModuleDestroy(instance)) {
+        try {
+          await instance.onModuleDestroy();
+          this.logger.debug(`Service ${(instance as object).constructor.name} onModuleDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Service ${(instance as object).constructor.name} onModuleDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for child modules
+    for (const childModule of this.childModules) {
+      await childModule.callOnModuleDestroy();
+    }
+  }
+
+  /**
+   * Call onApplicationDestroy lifecycle hook for all services and controllers
+   */
+  async callOnApplicationDestroy(signal?: string): Promise<void> {
+    // Call for services
+    for (const [, instance] of this.serviceInstances) {
+      if (hasOnApplicationDestroy(instance)) {
+        try {
+          await instance.onApplicationDestroy(signal);
+          this.logger.debug(`Service ${(instance as object).constructor.name} onApplicationDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Service ${(instance as object).constructor.name} onApplicationDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for controllers
+    for (const [, controller] of this.controllerInstances) {
+      if (hasOnApplicationDestroy(controller)) {
+        try {
+          await controller.onApplicationDestroy(signal);
+          this.logger.debug(`Controller ${controller.constructor.name} onApplicationDestroy completed`);
+        } catch (error) {
+          this.logger.error(`Controller ${controller.constructor.name} onApplicationDestroy failed: ${error}`);
+        }
+      }
+    }
+
+    // Call for child modules
+    for (const childModule of this.childModules) {
+      await childModule.callOnApplicationDestroy(signal);
+    }
+  }
+
+  /**
+   * Get all controllers from this module and child modules (recursive).
+   * Used by the application layer for routing and lifecycle.
    */
   getControllers(): Function[] {
-    return this.controllers;
+    const fromChildren = this.childModules.flatMap((child) => child.getControllers());
+
+    return [...this.controllers, ...fromChildren];
   }
 
   /**
-   * Get controller instance
+   * Get controller instance (searches this module then child modules recursively).
    */
   getControllerInstance(controllerClass: Function): Controller | undefined {
     const instance = this.controllerInstances.get(controllerClass);
-
-    if (!instance) {
-      this.logger.warn(`No instance found for controller ${controllerClass.name}`);
+    if (instance) {
+      return instance;
+    }
+    for (const childModule of this.childModules) {
+      const childInstance = childModule.getControllerInstance(controllerClass);
+      if (childInstance) {
+        return childInstance;
+      }
     }
+    this.logger.warn(`No instance found for controller ${controllerClass.name}`);
 
-    return instance;
+    return undefined;
   }
 
   /**
-   * Get all controller instances
+   * Get all controller instances from this module and child modules (recursive).
    */
   getControllerInstances(): Map<Function, Controller> {
-    return this.controllerInstances;
+    const merged = new Map<Function, Controller>(this.controllerInstances);
+    for (const childModule of this.childModules) {
+      for (const [cls, instance] of childModule.getControllerInstances()) {
+        merged.set(cls, instance);
+      }
+    }
+
+    return merged;
   }
 
   /**
-   * Get service instance
+   * Get service instance by tag
    */
   getServiceInstance<T>(tag: Context.Tag<T, T>): T | undefined {
     return this.serviceInstances.get(tag as Context.Tag<unknown, unknown>) as T | undefined;
   }
 
+  /**
+   * Get service instance by class
+   */
+  getServiceByClass<T>(serviceClass: new (...args: unknown[]) => T): T | undefined {
+    try {
+      const tag = getServiceTag(serviceClass);
+
+      return this.getServiceInstance(tag);
+    } catch {
+      // Service doesn't have @Service decorator or not found
+      return undefined;
+    }
+  }
+
+  /**
+   * Get all service instances
+   */
+  getAllServiceInstances(): Map<Context.Tag<unknown, unknown>, unknown> {
+    return new Map(this.serviceInstances);
+  }
+
   /**
    * Get the Layer for this module
    */

package/src/module/service.ts

@@ -99,16 +99,6 @@ export class BaseService {
     this.logger.debug(`Service ${className} initialized`);
   }
 
-  /**
-   * Async initialization hook - called by the framework after initializeService()
-   * Override in subclasses that need async initialization (e.g., database connections)
-   * The framework will await this method before making the service available
-   * @internal
-   */
-  async onAsyncInit(): Promise<void> {
-    // Default: no async init needed
-  }
-
   /**
    * Check if service is initialized
    * @internal

package/src/types.ts

@@ -1,7 +1,7 @@
 import type { Type } from 'arktype';
 import type { Effect, Layer } from 'effect';
 
-import type { Logger } from '@onebun/logger';
+import type { Logger, LoggerOptions } from '@onebun/logger';
 
 /**
  * Base interface for all OneBun services
@@ -58,6 +58,31 @@ export interface ModuleInstance {
    * Get controller instance
    */
   getControllerInstance?(controllerClass: Function): unknown;
+
+  /**
+   * Call onApplicationInit lifecycle hook for all services and controllers
+   */
+  callOnApplicationInit?(): Promise<void>;
+
+  /**
+   * Call beforeApplicationDestroy lifecycle hook for all services and controllers
+   */
+  callBeforeApplicationDestroy?(signal?: string): Promise<void>;
+
+  /**
+   * Call onModuleDestroy lifecycle hook for controllers first, then services
+   */
+  callOnModuleDestroy?(): Promise<void>;
+
+  /**
+   * Call onApplicationDestroy lifecycle hook for all services and controllers
+   */
+  callOnApplicationDestroy?(signal?: string): Promise<void>;
+
+  /**
+   * Get service instance by class
+   */
+  getServiceByClass?<T>(serviceClass: new (...args: unknown[]) => T): T | undefined;
 }
 
 /**
@@ -107,8 +132,28 @@ export interface ApplicationOptions {
   development?: boolean;
 
   /**
-   * Logger layer to use
-   * If not provided, a default logger will be created
+   * Logger configuration options.
+   * Provides a declarative way to configure logging.
+   * 
+   * Priority: loggerLayer > loggerOptions > LOG_LEVEL/LOG_FORMAT env > NODE_ENV defaults
+   * 
+   * @example
+   * ```typescript
+   * const app = new OneBunApplication(AppModule, {
+   *   loggerOptions: {
+   *     minLevel: 'info',
+   *     format: 'json',
+   *     defaultContext: { service: 'user-service' },
+   *   },
+   * });
+   * ```
+   */
+  loggerOptions?: LoggerOptions;
+
+  /**
+   * Logger layer to use (advanced).
+   * If provided, takes precedence over loggerOptions.
+   * Use loggerOptions for simpler configuration.
    */
   loggerLayer?: Layer.Layer<Logger>;