@onebun/core 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",
@@ -41,7 +41,7 @@
   "dependencies": {
     "effect": "^3.13.10",
     "arktype": "^2.0.0",
-    "@onebun/logger": "^0.1.5",
+    "@onebun/logger": "^0.1.6",
     "@onebun/envs": "^0.1.4",
     "@onebun/metrics": "^0.1.6",
     "@onebun/requests": "^0.1.3",

package/src/application/application.test.ts

@@ -432,6 +432,236 @@ describe('OneBunApplication', () => {
       expect(prodApp).toBeInstanceOf(OneBunApplication);
     });
 
+    test('should use PORT env variable when port is not explicitly provided', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '4567';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:4567');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should use HOST env variable when host is not explicitly provided', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '192.168.1.100';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://192.168.1.100:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
+    test('should use both PORT and HOST env variables when not explicitly provided', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '8888';
+        process.env.HOST = '10.0.0.1';
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://10.0.0.1:8888');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should prefer explicit port over PORT env variable', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '9999';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule, { port: 5555 });
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:5555');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should prefer explicit host over HOST env variable', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '192.168.1.100';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule, { host: 'localhost' });
+        expect(app.getHttpUrl()).toBe('http://localhost:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
+    test('should use defaults when env variables are not set', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        delete process.env.PORT;
+        delete process.env.HOST;
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort !== undefined) {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost !== undefined) {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore invalid PORT env variable and use default', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = 'invalid';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore empty PORT env variable and use default', () => {
+      const originalPort = process.env.PORT;
+      const originalHost = process.env.HOST;
+      try {
+        process.env.PORT = '';
+        delete process.env.HOST; // Clear HOST to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+      }
+    });
+
+    test('should ignore empty HOST env variable and use default', () => {
+      const originalHost = process.env.HOST;
+      const originalPort = process.env.PORT;
+      try {
+        process.env.HOST = '';
+        delete process.env.PORT; // Clear PORT to get default
+
+        @Module({})
+        class TestModule {}
+
+        const app = createTestApp(TestModule);
+        expect(app.getHttpUrl()).toBe('http://0.0.0.0:3000');
+      } finally {
+        if (originalHost === undefined) {
+          delete process.env.HOST;
+        } else {
+          process.env.HOST = originalHost;
+        }
+        if (originalPort === undefined) {
+          delete process.env.PORT;
+        } else {
+          process.env.PORT = originalPort;
+        }
+      }
+    });
+
     test('should handle complex envSchema configuration', () => {
       @Module({})
       class TestModule {}
@@ -596,7 +826,7 @@ describe('OneBunApplication', () => {
       await expect(app.start()).resolves.toBeUndefined();
     });
 
-    test('should stop server when running', () => {
+    test('should stop server when running', async () => {
       @Module({})
       class TestModule {}
 
@@ -608,20 +838,20 @@ describe('OneBunApplication', () => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (app as any).server = mockServer;
 
-      app.stop();
+      await app.stop();
 
       expect(mockServer.stop).toHaveBeenCalled();
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       expect((app as any).server).toBeNull();
     });
 
-    test('should handle stop when server is not running', () => {
+    test('should handle stop when server is not running', async () => {
       @Module({})
       class TestModule {}
 
       const app = createTestApp(TestModule);
 
-      expect(() => app.stop()).not.toThrow();
+      await expect(app.stop()).resolves.toBeUndefined();
     });
   });
 

package/src/application/application.ts

@@ -13,6 +13,7 @@ import {
   type Logger,
   LoggerService,
   makeLogger,
+  makeLoggerFromOptions,
   type SyncLogger,
 } from '@onebun/logger';
 import {
@@ -112,17 +113,48 @@ function normalizePath(path: string): string {
   return path.endsWith('/') ? path.slice(0, -1) : path;
 }
 
+/**
+ * Resolve port from options, environment variable, or default.
+ * Priority: explicit option > PORT env > default (3000)
+ */
+function resolvePort(explicitPort: number | undefined): number {
+  if (explicitPort !== undefined) {
+    return explicitPort;
+  }
+  const envPort = process.env.PORT;
+  if (envPort !== undefined && envPort !== '') {
+    const parsed = parseInt(envPort, 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+
+  return 3000;
+}
+
+/**
+ * Resolve host from options, environment variable, or default.
+ * Priority: explicit option > HOST env > default ('0.0.0.0')
+ */
+function resolveHost(explicitHost: string | undefined): string {
+  if (explicitHost !== undefined) {
+    return explicitHost;
+  }
+  const envHost = process.env.HOST;
+  if (envHost !== undefined && envHost !== '') {
+    return envHost;
+  }
+
+  return '0.0.0.0';
+}
+
 /**
  * OneBun Application
  */
 export class OneBunApplication {
   private rootModule: ModuleInstance;
   private server: ReturnType<typeof Bun.serve> | null = null;
-  private options: ApplicationOptions = {
-    port: 3000,
-    host: '0.0.0.0',
-    development: process.env.NODE_ENV !== 'production',
-  };
+  private options: ApplicationOptions;
   private logger: SyncLogger;
   private config: IConfig<OneBunAppConfig>;
   private configService: ConfigServiceImpl | null = null;
@@ -144,9 +176,13 @@ export class OneBunApplication {
     moduleClass: new (...args: unknown[]) => object,
     options?: Partial<ApplicationOptions>,
   ) {
-    if (options) {
-      this.options = { ...this.options, ...options };
-    }
+    // Resolve port and host with priority: explicit > env > default
+    this.options = {
+      port: resolvePort(options?.port),
+      host: resolveHost(options?.host),
+      development: options?.development ?? process.env.NODE_ENV !== 'production',
+      ...options,
+    };
 
     // Initialize configuration - TypedEnv if schema provided, otherwise NotInitializedConfig
     if (this.options.envSchema) {
@@ -156,8 +192,12 @@ export class OneBunApplication {
       this.config = new NotInitializedConfig();
     }
 
-    // Use provided logger layer or create a default one
-    const loggerLayer = this.options.loggerLayer || makeLogger();
+    // Use provided logger layer, or create from options, or use default
+    // Priority: loggerLayer > loggerOptions > env variables > NODE_ENV defaults
+    const loggerLayer = this.options.loggerLayer
+      ?? (this.options.loggerOptions
+        ? makeLoggerFromOptions(this.options.loggerOptions)
+        : makeLogger());
 
     // Initialize logger with application class name as context
     const effectLogger = Effect.runSync(
@@ -467,6 +507,12 @@ export class OneBunApplication {
         }
       }
 
+      // Call onApplicationInit lifecycle hook for all services and controllers
+      if (this.rootModule.callOnApplicationInit) {
+        await this.rootModule.callOnApplicationInit();
+        this.logger.debug('Application initialization hooks completed');
+      }
+
       // Get metrics path
       const metricsPath = this.options.metrics?.path || '/metrics';
 
@@ -1179,11 +1225,18 @@ export class OneBunApplication {
    * Stop the application with graceful shutdown
    * @param options - Shutdown options
    */
-  async stop(options?: { closeSharedRedis?: boolean }): Promise<void> {
+  async stop(options?: { closeSharedRedis?: boolean; signal?: string }): Promise<void> {
     const closeRedis = options?.closeSharedRedis ?? true;
+    const signal = options?.signal;
 
     this.logger.info('Stopping OneBun application...');
 
+    // Call beforeApplicationDestroy lifecycle hook
+    if (this.rootModule.callBeforeApplicationDestroy) {
+      this.logger.debug('Calling beforeApplicationDestroy hooks');
+      await this.rootModule.callBeforeApplicationDestroy(signal);
+    }
+
     // Cleanup WebSocket resources
     if (this.wsHandler) {
       this.logger.debug('Cleaning up WebSocket handler');
@@ -1212,12 +1265,24 @@ export class OneBunApplication {
       this.logger.debug('HTTP server stopped');
     }
 
+    // Call onModuleDestroy lifecycle hook
+    if (this.rootModule.callOnModuleDestroy) {
+      this.logger.debug('Calling onModuleDestroy hooks');
+      await this.rootModule.callOnModuleDestroy();
+    }
+
     // Close shared Redis connection if configured and requested
     if (closeRedis && SharedRedisProvider.isConnected()) {
       this.logger.debug('Disconnecting shared Redis');
       await SharedRedisProvider.disconnect();
     }
 
+    // Call onApplicationDestroy lifecycle hook
+    if (this.rootModule.callOnApplicationDestroy) {
+      this.logger.debug('Calling onApplicationDestroy hooks');
+      await this.rootModule.callOnApplicationDestroy(signal);
+    }
+
     this.logger.info('OneBun application stopped');
   }
 
@@ -1405,7 +1470,7 @@ export class OneBunApplication {
   enableGracefulShutdown(): void {
     const shutdown = async (signal: string) => {
       this.logger.info(`Received ${signal}, initiating graceful shutdown...`);
-      await this.stop();
+      await this.stop({ signal });
       process.exit(0);
     };
 
@@ -1434,4 +1499,36 @@ export class OneBunApplication {
   getHttpUrl(): string {
     return `http://${this.options.host}:${this.options.port}`;
   }
+
+  /**
+   * Get a service instance by class from the module container.
+   * Useful for accessing services outside of the request context.
+   * 
+   * @param serviceClass - The service class to get
+   * @returns The service instance
+   * @throws Error if service is not found
+   * 
+   * @example
+   * ```typescript
+   * const app = new OneBunApplication(AppModule, options);
+   * await app.start();
+   * 
+   * const userService = app.getService(UserService);
+   * await userService.performBackgroundTask();
+   * ```
+   */
+  getService<T>(serviceClass: new (...args: unknown[]) => T): T {
+    if (!this.rootModule.getServiceByClass) {
+      throw new Error('Module does not support getServiceByClass');
+    }
+
+    const service = this.rootModule.getServiceByClass(serviceClass);
+    if (!service) {
+      throw new Error(
+        `Service ${serviceClass.name} not found. Make sure it's registered in the module's providers.`,
+      );
+    }
+
+    return service;
+  }
 }

package/src/application/multi-service-application.ts

@@ -12,6 +12,7 @@ import {
   type Logger,
   LoggerService,
   makeLogger,
+  parseLogLevel,
   type SyncLogger,
 } from '@onebun/logger';
 
@@ -201,9 +202,9 @@ export class MultiServiceApplication<TServices extends ServicesMap = ServicesMap
           ...this.options.envOptions,
           valueOverrides: resolvedOverrides,
         },
-        // Logger configuration - use minLevel if provided
-        loggerLayer: mergedOptions.logger?.minLevel
-          ? makeLogger({ minLevel: this.getLogLevel(mergedOptions.logger.minLevel) })
+        // Logger configuration - use loggerOptions if minLevel provided
+        loggerOptions: mergedOptions.logger?.minLevel
+          ? { minLevel: parseLogLevel(mergedOptions.logger.minLevel) }
           : undefined,
         metrics: {
           ...mergedOptions.metrics,
@@ -316,24 +317,4 @@ export class MultiServiceApplication<TServices extends ServicesMap = ServicesMap
   getLogger(): SyncLogger {
     return this.logger;
   }
-
-  /**
-   * Convert log level string to numeric LogLevel value.
-   * LogLevel values: Fatal=60, Error=50, Warning=40, Info=30, Debug=20, Trace=10
-   */
-  private getLogLevel(level: string): number {
-    /* eslint-disable @typescript-eslint/no-magic-numbers */
-    const LOG_LEVEL_INFO = 30;
-    const levelMap: Record<string, number> = {
-      fatal: 60,
-      error: 50,
-      warning: 40,
-      info: LOG_LEVEL_INFO,
-      debug: 20,
-      trace: 10,
-    };
-
-    return levelMap[level.toLowerCase()] ?? LOG_LEVEL_INFO;
-    /* eslint-enable @typescript-eslint/no-magic-numbers */
-  }
 }