@navios/core 1.0.0-alpha.2 → 1.0.0-alpha.4

package/src/logger/console-logger.service.mts

@@ -30,15 +30,46 @@ export interface ConsoleLoggerOptions {
    */
   logLevels?: LogLevel[]
   /**
-   * If enabled, will print timestamp (time difference) between current and previous log message.
+   * If enabled, will print timestamp difference between current and previous log message.
    * Note: This option is not used when `json` is enabled.
+   * @default false
    */
-  timestamp?: boolean
+  showTimeDiff?: boolean
   /**
    * A prefix to be used for each log message.
    * Note: This option is not used when `json` is enabled.
    */
   prefix?: string
+  /**
+   * If true, will print the process ID in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showPid?: boolean
+  /**
+   * If true, will print the log level in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showLogLevel?: boolean
+  /**
+   * If true, will print the prefix/app name in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showPrefix?: boolean
+  /**
+   * If true, will print the context in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showContext?: boolean
+  /**
+   * If true, will print the absolute timestamp in the log message.
+   * Note: This option is not used when `json` is enabled.
+   * @default true
+   */
+  showTimestamp?: boolean
   /**
    * If enabled, will add a request ID to the log message.
    */
@@ -129,6 +160,31 @@ const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
   token: LoggerOutput,
 })
 export class ConsoleLogger implements LoggerService {
+  /**
+   * Creates a new ConsoleLogger instance with the given options.
+   * This is a convenience method that instantiates and sets up the logger in one call.
+   */
+  static create(): ConsoleLogger
+  static create(context: string): ConsoleLogger
+  static create(options: ConsoleLoggerOptions): ConsoleLogger
+  static create(context: string, options: ConsoleLoggerOptions): ConsoleLogger
+  static create(
+    contextOrOptions?: string | ConsoleLoggerOptions,
+    options?: ConsoleLoggerOptions,
+  ): ConsoleLogger {
+    const logger = new ConsoleLogger()
+    if (contextOrOptions !== undefined) {
+      if (typeof contextOrOptions === 'string') {
+        logger.setup(contextOrOptions, options ?? {})
+      } else {
+        logger.setup(contextOrOptions)
+      }
+    } else {
+      logger.setup()
+    }
+    return logger
+  }
+
   /**
    * The options of the logger.
    */
@@ -412,11 +468,24 @@ export class ConsoleLogger implements LoggerService {
   }
 
   protected formatPid(pid: number) {
-    return `[${this.options.prefix}] ${pid} - `
+    const showPrefix = this.options.showPrefix ?? true
+    const showPid = this.options.showPid ?? true
+
+    if (!showPrefix && !showPid) {
+      return ''
+    }
+
+    const prefix = showPrefix ? `[${this.options.prefix}]` : ''
+    const pidPart = showPid ? `${pid}` : ''
+    const separator = showPrefix && showPid ? ' ' : ''
+    const suffix = showPrefix || showPid ? ' - ' : ''
+
+    return `${prefix}${separator}${pidPart}${suffix}`
   }
 
   protected formatContext(context: string): string {
-    if (!context) {
+    const showContext = this.options.showContext ?? true
+    if (!context || !showContext) {
       return ''
     }
 
@@ -434,9 +503,29 @@ export class ConsoleLogger implements LoggerService {
     requestId?: string,
   ) {
     const output = this.stringifyMessage(message, logLevel)
+    const showLogLevel = this.options.showLogLevel ?? true
+    const showTimestamp = this.options.showTimestamp ?? true
+
     pidMessage = this.colorize(pidMessage, logLevel)
-    formattedLogLevel = this.colorize(formattedLogLevel, logLevel)
-    return `${pidMessage}${this.getRequestId(requestId)}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`
+    formattedLogLevel = showLogLevel
+      ? this.colorize(formattedLogLevel, logLevel)
+      : ''
+
+    const timestamp = showTimestamp ? this.getTimestamp() : ''
+    const requestIdPart = this.getRequestId(requestId)
+
+    // Build the message parts, filtering out empty ones
+    const parts: string[] = []
+
+    if (pidMessage) parts.push(pidMessage.trimEnd())
+    if (requestIdPart) parts.push(requestIdPart.trimEnd())
+    if (timestamp) parts.push(timestamp)
+    if (formattedLogLevel) parts.push(formattedLogLevel)
+    if (contextMessage) parts.push(contextMessage.trimEnd())
+
+    const prefix = parts.length > 0 ? parts.join(' ') + ' ' : ''
+
+    return `${prefix}${output}${timestampDiff}\n`
   }
 
   protected getRequestId(requestId?: string) {
@@ -488,7 +577,8 @@ export class ConsoleLogger implements LoggerService {
   }
 
   protected updateAndGetTimestampDiff(): string {
-    const includeTimestamp = this.lastTimestampAt && this.options?.timestamp
+    const showTimeDiff = this.options?.showTimeDiff ?? false
+    const includeTimestamp = this.lastTimestampAt && showTimeDiff
     const result = includeTimestamp
       ? this.formatTimestampDiff(Date.now() - this.lastTimestampAt!)
       : ''

package/src/metadata/module.metadata.mts

@@ -16,6 +16,17 @@ export interface ModuleMetadata {
   >
   overrides: Set<ClassType>
   customAttributes: Map<string | symbol, any>
+  /**
+   * Extensible entries for adapter-specific data.
+   * Adapters can store custom metadata using symbol keys.
+   *
+   * @example
+   * ```typescript
+   * const CommandEntryKey = Symbol('CommandEntryKey')
+   * metadata.customEntries.set(CommandEntryKey, new Set([Command1, Command2]))
+   * ```
+   */
+  customEntries: Map<symbol, unknown>
 }
 
 export function getModuleMetadata(
@@ -38,6 +49,7 @@ export function getModuleMetadata(
         >(),
         overrides: new Set<ClassType>(),
         customAttributes: new Map<string | symbol, any>(),
+        customEntries: new Map<symbol, unknown>(),
       }
       context.metadata[ModuleMetadataKey] = newMetadata
       // @ts-expect-error We add a custom metadata key to the target
@@ -63,3 +75,34 @@ export function hasModuleMetadata(target: ClassType): boolean {
   // @ts-expect-error We add a custom metadata key to the target
   return !!target[ModuleMetadataKey]
 }
+
+/**
+ * Type-safe helper to get or create a custom entry in module metadata.
+ * Adapters use this to store their own metadata in modules.
+ *
+ * @param metadata - The module metadata object
+ * @param key - Symbol key for the custom entry
+ * @param defaultValue - Factory function to create default value if entry doesn't exist
+ * @returns The existing or newly created entry value
+ *
+ * @example
+ * ```typescript
+ * const CommandEntryKey = Symbol('CommandEntryKey')
+ * const commands = getModuleCustomEntry<Set<ClassType>>(
+ *   metadata,
+ *   CommandEntryKey,
+ *   () => new Set(),
+ * )
+ * commands.add(MyCommand)
+ * ```
+ */
+export function getModuleCustomEntry<T>(
+  metadata: ModuleMetadata,
+  key: symbol,
+  defaultValue: () => T,
+): T {
+  if (!metadata.customEntries.has(key)) {
+    metadata.customEntries.set(key, defaultValue())
+  }
+  return metadata.customEntries.get(key) as T
+}

package/src/navios.application.mts

@@ -1,10 +1,26 @@
-import type { ClassTypeWithInstance, Registry } from '@navios/di'
+import type {
+  ClassType,
+  ClassTypeWithArgument,
+  ClassTypeWithInstance,
+  InjectionTokenSchemaType,
+  Registry,
+} from '@navios/di'
+import type { z } from 'zod/v4'
 
-import { Container, inject, Injectable } from '@navios/di'
+import {
+  BoundInjectionToken,
+  Container,
+  FactoryInjectionToken,
+  inject,
+  Injectable,
+  InjectionToken,
+} from '@navios/di'
 
 import type {
-  AbstractHttpAdapterInterface,
-  AbstractHttpListenOptions,
+  AbstractAdapterInterface,
+  AdapterEnvironment,
+  DefaultAdapterEnvironment,
+  HttpAdapterEnvironment,
   NaviosModule,
   PluginContext,
   PluginDefinition,
@@ -12,10 +28,11 @@ import type {
 import type { LoggerService, LogLevel } from './logger/index.mjs'
 import type { NaviosEnvironmentOptions } from './navios.environment.mjs'
 
-import { HttpAdapterToken } from './index.mjs'
 import { Logger } from './logger/index.mjs'
 import { NaviosEnvironment } from './navios.environment.mjs'
 import { ModuleLoaderService } from './services/index.mjs'
+import { AdapterToken } from './tokens/index.mjs'
+import { assertAdapterSupports } from './utils/index.mjs'
 
 /**
  * Options for configuring the Navios application context.
@@ -44,14 +61,14 @@ export interface NaviosApplicationOptions {
   container?: Container
 
   /**
-   * HTTP adapter environment(s) to use for the application.
+   * Adapter environment(s) to use for the application.
    * Can be a single adapter or an array of adapters.
    *
    * @example
    * ```typescript
    * adapter: defineFastifyEnvironment()
    * // or
-   * adapter: [defineFastifyEnvironment(), defineBunEnvironment()]
+   * adapter: [defineFastifyEnvironment()]
    * ```
    */
   adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[]
@@ -75,7 +92,7 @@ export interface NaviosApplicationOptions {
  * Main application class for Navios.
  *
  * This class represents a Navios application instance and provides methods
- * for initializing, configuring, and managing the HTTP server.
+ * for initializing, configuring, and managing the application lifecycle.
  *
  * @example
  * ```typescript
@@ -90,10 +107,12 @@ export interface NaviosApplicationOptions {
  * ```
  */
 @Injectable()
-export class NaviosApplication {
+export class NaviosApplication<
+  Environment extends AdapterEnvironment = DefaultAdapterEnvironment,
+> {
   private environment = inject(NaviosEnvironment)
   private moduleLoader = inject(ModuleLoaderService)
-  private httpApplication: AbstractHttpAdapterInterface<any> | null = null
+  private adapter: Environment['adapter'] | null = null
   private logger = inject(Logger, {
     context: NaviosApplication.name,
   })
@@ -103,7 +122,7 @@ export class NaviosApplication {
   private options: NaviosApplicationOptions = {
     adapter: [],
   }
-  private plugins: PluginDefinition<any>[] = []
+  private plugins: PluginDefinition<any, any>[] = []
 
   /**
    * Indicates whether the application has been initialized.
@@ -127,8 +146,10 @@ export class NaviosApplication {
   ) {
     this.appModule = appModule
     this.options = options
-    if (this.environment.hasHttpSetup()) {
-      this.httpApplication = await this.container.get(HttpAdapterToken)
+    if (this.environment.hasAdapterSetup()) {
+      this.adapter = (await this.container.get(
+        AdapterToken,
+      )) as Environment['adapter']
     }
   }
 
@@ -141,6 +162,19 @@ export class NaviosApplication {
     return this.container
   }
 
+  /**
+   * Returns the current adapter instance.
+   *
+   * @returns The adapter instance
+   * @throws Error if adapter is not initialized
+   */
+  getAdapter(): Environment['adapter'] {
+    if (!this.adapter) {
+      throw new Error('Adapter not initialized')
+    }
+    return this.adapter
+  }
+
   /**
    * Registers a plugin to be initialized after modules are loaded.
    *
@@ -159,7 +193,9 @@ export class NaviosApplication {
    * }))
    * ```
    */
-  usePlugin<TOptions>(definition: PluginDefinition<TOptions>): this {
+  usePlugin<TOptions, TAdapter extends AbstractAdapterInterface>(
+    definition: PluginDefinition<TOptions, TAdapter>,
+  ): this {
     this.plugins.push(definition)
     return this
   }
@@ -169,7 +205,7 @@ export class NaviosApplication {
    *
    * This method:
    * - Loads all modules and their dependencies
-   * - Sets up the HTTP server if an adapter is configured
+   * - Sets up the adapter if one is configured
    * - Calls onModuleInit hooks on all modules
    * - Initializes registered plugins
    * - Marks the application as initialized
@@ -192,13 +228,16 @@ export class NaviosApplication {
       throw new Error('App module is not set. Call setAppModule() first.')
     }
     await this.moduleLoader.loadModules(this.appModule)
-    if (this.environment.hasHttpSetup()) {
-      await this.httpApplication?.setupHttpServer(this.options)
+
+    if (this.environment.hasAdapterSetup() && this.adapter) {
+      await this.adapter.setupAdapter(this.options)
     }
+
     await this.initPlugins()
     await this.initModules()
-    if (this.environment.hasHttpSetup()) {
-      await this.httpApplication?.ready()
+
+    if (this.adapter) {
+      await this.adapter.ready()
     }
 
     this.isInitialized = true
@@ -207,23 +246,22 @@ export class NaviosApplication {
 
   private async initModules() {
     const modules = this.moduleLoader.getAllModules()
-    await this.httpApplication?.onModulesInit(modules)
+    if (this.adapter) {
+      await this.adapter.onModulesInit(modules)
+    }
   }
 
   private async initPlugins() {
     if (this.plugins.length === 0) return
 
-    let server: any = null
-    try {
-      server = this.httpApplication?.getServer() ?? null
-    } catch {
-      // ignore
+    if (!this.adapter) {
+      throw new Error('Cannot initialize plugins without an adapter')
     }
+
     const context: PluginContext = {
       modules: this.moduleLoader.getAllModules(),
-      server,
+      adapter: this.adapter,
       container: this.container,
-      globalPrefix: this.httpApplication?.getGlobalPrefix() ?? '',
       moduleLoader: this.moduleLoader,
     }
 
@@ -233,11 +271,79 @@ export class NaviosApplication {
     }
   }
 
+  /**
+   * Gets a service instance from the dependency injection container.
+   *
+   * This is a shorthand for `app.getContainer().get(token)`.
+   *
+   * @param token - The injection token or class to resolve
+   * @returns Promise resolving to the service instance
+   *
+   * @example
+   * ```typescript
+   * const userService = await app.get(UserService)
+   * const config = await app.get(ConfigToken)
+   * ```
+   */
+  get<T extends ClassType>(token: T): Promise<InstanceType<T>>
+  get<T extends ClassTypeWithArgument<R>, R>(
+    token: T,
+    args: R,
+  ): Promise<InstanceType<T>>
+  get<T, S extends InjectionTokenSchemaType>(
+    token: InjectionToken<T, S>,
+    args: z.input<S>,
+  ): Promise<T>
+  get<T, S extends InjectionTokenSchemaType, R extends boolean>(
+    token: InjectionToken<T, S, R>,
+  ): Promise<T>
+  get<T>(token: InjectionToken<T, undefined>): Promise<T>
+  get<T>(token: BoundInjectionToken<T, any>): Promise<T>
+  get<T>(token: FactoryInjectionToken<T, any>): Promise<T>
+  async get(
+    token:
+      | ClassType
+      | InjectionToken<any>
+      | BoundInjectionToken<any, any>
+      | FactoryInjectionToken<any, any>,
+    args?: unknown,
+  ): Promise<any> {
+    return this.container.get(token as any, args)
+  }
+
+  /**
+   * Configures the adapter with additional options before initialization.
+   *
+   * This method allows setting adapter-specific configuration options
+   * before the adapter is initialized. Must be called before `init()`.
+   *
+   * @param options - Adapter-specific configuration options
+   * @returns this for method chaining
+   * @throws Error if called after init() or if adapter doesn't support configure
+   *
+   * @example
+   * ```typescript
+   * // With Fastify adapter
+   * app.configure({ trustProxy: true, logger: true })
+   *
+   * // With Bun adapter
+   * app.configure({ development: true })
+   * ```
+   */
+  configure(options: Partial<Environment['options']>): this {
+    if (this.isInitialized) {
+      throw new Error('configure() must be called before init()')
+    }
+    assertAdapterSupports(this.adapter, 'configure')
+    this.adapter.configure(options)
+    return this
+  }
+
   /**
    * Enables CORS (Cross-Origin Resource Sharing) for the application.
    *
    * @param options - CORS configuration options (adapter-specific)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support enableCors
    *
    * @example
    * ```typescript
@@ -248,18 +354,20 @@ export class NaviosApplication {
    * })
    * ```
    */
-  enableCors(options: any) {
-    if (!this.httpApplication) {
-      throw new Error('HTTP application is not set')
-    }
-    this.httpApplication.enableCors(options)
+  enableCors(
+    options: Environment extends HttpAdapterEnvironment
+      ? Environment['corsOptions']
+      : never,
+  ): void {
+    assertAdapterSupports(this.adapter, 'enableCors')
+    this.adapter.enableCors(options)
   }
 
   /**
    * Enables multipart/form-data support for file uploads.
    *
    * @param options - Multipart configuration options (adapter-specific)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support enableMultipart
    *
    * @example
    * ```typescript
@@ -270,18 +378,20 @@ export class NaviosApplication {
    * })
    * ```
    */
-  enableMultipart(options: any) {
-    if (!this.httpApplication) {
-      throw new Error('HTTP application is not set')
-    }
-    this.httpApplication.enableMultipart(options)
+  enableMultipart(
+    options: Environment extends HttpAdapterEnvironment
+      ? Environment['multipartOptions']
+      : never,
+  ): void {
+    assertAdapterSupports(this.adapter, 'enableMultipart')
+    this.adapter.enableMultipart(options)
   }
 
   /**
    * Sets a global prefix for all routes.
    *
    * @param prefix - The prefix to prepend to all route URLs (e.g., '/api')
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support setGlobalPrefix
    *
    * @example
    * ```typescript
@@ -289,11 +399,9 @@ export class NaviosApplication {
    * // All routes will be prefixed with /api/v1
    * ```
    */
-  setGlobalPrefix(prefix: string) {
-    if (!this.httpApplication) {
-      throw new Error('HTTP application is not set')
-    }
-    this.httpApplication.setGlobalPrefix(prefix)
+  setGlobalPrefix(prefix: string): void {
+    assertAdapterSupports(this.adapter, 'setGlobalPrefix')
+    this.adapter.setGlobalPrefix(prefix)
   }
 
   /**
@@ -304,7 +412,7 @@ export class NaviosApplication {
    * - Bun adapter: Returns Bun.Server
    *
    * @returns The HTTP server instance
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support getServer
    *
    * @example
    * ```typescript
@@ -312,40 +420,44 @@ export class NaviosApplication {
    * // Use adapter-specific server methods
    * ```
    */
-  getServer() {
-    if (!this.httpApplication) {
-      throw new Error('HTTP application is not set')
-    }
-    return this.httpApplication.getServer()
+  getServer(): Environment extends HttpAdapterEnvironment
+    ? Environment['server']
+    : never {
+    assertAdapterSupports(this.adapter, 'getServer')
+    return this.adapter.getServer() as Environment extends HttpAdapterEnvironment
+      ? Environment['server']
+      : never
   }
 
   /**
    * Starts the HTTP server and begins listening for requests.
    *
    * @param options - Listen options (port, host, etc.)
-   * @throws Error if HTTP application is not set
+   * @throws Error if adapter doesn't support listen
    *
    * @example
    * ```typescript
    * await app.listen({ port: 3000, host: '0.0.0.0' })
    * ```
    */
-  async listen(options: AbstractHttpListenOptions) {
-    if (!this.httpApplication) {
-      throw new Error('HTTP application is not set')
-    }
-    await this.httpApplication.listen(options)
+  async listen(
+    options: Environment extends HttpAdapterEnvironment
+      ? Environment['listenOptions']
+      : never,
+  ): Promise<string> {
+    assertAdapterSupports(this.adapter, 'listen')
+    return this.adapter.listen(options) as Promise<string>
   }
 
   /**
    * Disposes of application resources.
    *
-   * Cleans up the HTTP server and module loader.
+   * Cleans up the adapter and module loader.
    * This method is called automatically by `close()`.
    */
   async dispose() {
-    if (this.httpApplication) {
-      await this.httpApplication.dispose()
+    if (this.adapter) {
+      await this.adapter.dispose()
     }
     if (this.moduleLoader) {
       this.moduleLoader.dispose()

package/src/navios.environment.mts

@@ -2,31 +2,41 @@ import type { AnyInjectableType, InjectionToken } from '@navios/di'
 
 import { Injectable } from '@navios/di'
 
+import { AdapterToken } from './tokens/index.mjs'
+
 export interface NaviosEnvironmentOptions {
-  // Future options can be added here
-  httpTokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>
+  tokens?: Map<InjectionToken<any, undefined>, AnyInjectableType>
 }
 
 @Injectable()
 export class NaviosEnvironment {
-  private httpTokens = new Map<
-    InjectionToken<any, undefined>,
-    AnyInjectableType
-  >()
+  private adapterConfigured = false
+  private tokens = new Map<InjectionToken<any, undefined>, AnyInjectableType>()
 
-  setupHttpEnvironment(
+  setupEnvironment(
     tokens: Map<InjectionToken<any, undefined>, AnyInjectableType>,
   ) {
+    const hasAdapterToken = tokens.has(AdapterToken)
+    if (hasAdapterToken && this.adapterConfigured) {
+      throw new Error(
+        'Adapter already configured. Only one adapter per application.',
+      )
+    }
+
     for (const [token, value] of tokens) {
-      this.httpTokens.set(token, value)
+      this.tokens.set(token, value)
+    }
+
+    if (hasAdapterToken) {
+      this.adapterConfigured = true
     }
   }
 
-  getHttpToken(token: InjectionToken<any, undefined>) {
-    return this.httpTokens.get(token)
+  getToken(token: InjectionToken<any, undefined>) {
+    return this.tokens.get(token)
   }
 
-  hasHttpSetup() {
-    return this.httpTokens.size > 0
+  hasAdapterSetup() {
+    return this.adapterConfigured
   }
 }