@navios/core 0.8.0 → 0.9.1

package/src/legacy-compat/index.mts

@@ -1,13 +1,13 @@
 /**
  * Legacy-compatible decorators for projects that cannot use Stage 3 decorators.
- * 
+ *
  * These decorators use the TypeScript experimental decorator API and convert
  * the arguments to Stage 3 format internally.
- * 
+ *
  * @example
  * ```typescript
  * import { Module, Controller, Endpoint } from '@navios/core/legacy-compat'
- * 
+ *
  * @Module({
  *   controllers: [UserController],
  * })
@@ -36,5 +36,16 @@ export {
   HttpCode,
   Multipart,
   Stream,
+  Injectable,
 } from './decorators/index.mjs'
 
+// Export legacy-compatible AttributeFactory
+export {
+  AttributeFactory,
+  LegacyAttributeFactory,
+  type LegacyClassAttribute,
+  type LegacyClassSchemaAttribute,
+} from './attribute.factory.mjs'
+
+// Export context compatibility utilities
+export * from './context-compat.mjs'

package/src/metadata/index.mts

@@ -1,3 +1,4 @@
 export * from './controller.metadata.mjs'
 export * from './handler.metadata.mjs'
 export * from './module.metadata.mjs'
+export * from './navios-managed.metadata.mjs'

package/src/metadata/navios-managed.metadata.mts

@@ -0,0 +1,42 @@
+import type { ClassType } from '@navios/di'
+
+/**
+ * Symbol used to identify Navios-managed classes (Controller, Module, MessageController, etc.).
+ * This allows AttributeFactory to work with any Navios-managed class type generically.
+ */
+export const NaviosManagedMetadataKey = Symbol('NaviosManagedMetadataKey')
+
+/**
+ * Interface for metadata that has custom attributes.
+ * Used by Navios-managed classes (Controller, Module, MessageController, etc.).
+ */
+export interface ManagedMetadata {
+  customAttributes: Map<string | symbol, any>
+}
+
+/**
+ * Gets managed metadata from a class if it exists.
+ * This is a generic function that works with any Navios-managed class type.
+ *
+ * @param target - The class to check
+ * @returns The metadata with customAttributes, or null if not managed
+ */
+export function getManagedMetadata(target: ClassType): ManagedMetadata | null {
+  // @ts-expect-error - Checking for managed metadata key
+  if (target[NaviosManagedMetadataKey]) {
+    // @ts-expect-error - Accessing managed metadata
+    return target[NaviosManagedMetadataKey] as ManagedMetadata
+  }
+  return null
+}
+
+/**
+ * Checks if a class is Navios-managed (has managed metadata).
+ *
+ * @param target - The class to check
+ * @returns true if the class is Navios-managed
+ */
+export function hasManagedMetadata(target: ClassType): boolean {
+  return getManagedMetadata(target) !== null
+}
+

package/src/navios.application.mts

@@ -1,4 +1,4 @@
-import type { ClassTypeWithInstance } from '@navios/di'
+import type { ClassTypeWithInstance, Registry } from '@navios/di'
 
 import { Container, inject, Injectable } from '@navios/di'
 
@@ -19,9 +19,9 @@ import { ModuleLoaderService } from './services/index.mjs'
 
 /**
  * Options for configuring the Navios application context.
- * These options control dependency injection and logging behavior.
+ * These options control the application configuration.
  */
-export interface NaviosApplicationContextOptions {
+export interface NaviosApplicationOptions {
   /**
    * Specifies the logger to use. Pass `false` to turn off logging.
    *
@@ -31,18 +31,18 @@ export interface NaviosApplicationContextOptions {
    */
   logger?: LoggerService | LogLevel[] | false
 
+  /**
+   * Specifies a custom registry to use. Useful for testing.
+   * If not provided, a new Registry will be created.
+   */
+  registry?: Registry
+
   /**
    * Specifies a custom container to use. Useful for testing.
    * If not provided, a new Container will be created.
    */
   container?: Container
-}
 
-/**
- * Complete options for creating a Navios application.
- * Extends NaviosApplicationContextOptions with adapter configuration.
- */
-export interface NaviosApplicationOptions extends NaviosApplicationContextOptions {
   /**
    * HTTP adapter environment(s) to use for the application.
    * Can be a single adapter or an array of adapters.

package/src/navios.environment.mts

@@ -17,7 +17,9 @@ export class NaviosEnvironment {
   setupHttpEnvironment(
     tokens: Map<InjectionToken<any, undefined>, AnyInjectableType>,
   ) {
-    this.httpTokens = tokens
+    for (const [token, value] of tokens) {
+      this.httpTokens.set(token, value)
+    }
   }
 
   getHttpToken(token: InjectionToken<any, undefined>) {

package/src/navios.factory.mts

@@ -4,13 +4,10 @@ import type {
   InjectionToken,
 } from '@navios/di'
 
-import { Container, InjectableScope, InjectableType } from '@navios/di'
+import { Container } from '@navios/di'
 
 import type { NaviosModule } from './interfaces/index.mjs'
-import type {
-  NaviosApplicationContextOptions,
-  NaviosApplicationOptions,
-} from './navios.application.mjs'
+import type { NaviosApplicationOptions } from './navios.application.mjs'
 
 import { ConsoleLogger, isNil, LoggerOutput } from './logger/index.mjs'
 import { NaviosApplication } from './navios.application.mjs'
@@ -83,7 +80,7 @@ export class NaviosFactory {
       adapter: [],
     },
   ) {
-    const container = options.container ?? new Container()
+    const container = options.container ?? new Container(options.registry)
 
     // Set request ID flag early, before any adapters are registered
     if (options.enableRequestId === true) {
@@ -91,15 +88,7 @@ export class NaviosFactory {
     }
 
     // Store options in container for DI access by adapters
-    container
-      .getServiceLocator()
-      .getManager()
-      .storeCreatedHolder(
-        NaviosOptionsToken.toString(),
-        options,
-        InjectableType.Class,
-        InjectableScope.Singleton,
-      )
+    container.addInstance(NaviosOptionsToken, options)
 
     await this.registerLoggerConfiguration(container, options)
     const adapters = Array.isArray(options.adapter)
@@ -128,28 +117,21 @@ export class NaviosFactory {
 
   private static async registerLoggerConfiguration(
     container: Container,
-    options: NaviosApplicationContextOptions,
+    options: NaviosApplicationOptions,
   ) {
     const { logger } = options
-    if (Array.isArray(logger) || isNil(logger)) {
+    if (Array.isArray(logger) || isNil(logger) || options.enableRequestId) {
       const loggerInstance = (await container.get(
         LoggerOutput,
       )) as ConsoleLogger
       loggerInstance?.setup({
-        logLevels: logger,
+        logLevels: Array.isArray(logger) ? logger : undefined,
+        requestId: options.enableRequestId ?? false,
       })
       return
     }
     if ((logger as boolean) !== true && !isNil(logger)) {
-      container
-        .getServiceLocator()
-        .getManager()
-        .storeCreatedHolder(
-          LoggerOutput.toString(),
-          logger,
-          InjectableType.Class,
-          InjectableScope.Singleton,
-        )
+      container.addInstance(LoggerOutput, logger)
     }
   }
 }

package/src/services/instance-resolver.service.mts

@@ -110,16 +110,13 @@ export class InstanceResolverService {
       // Class has request-scoped dependencies, update its scope to Request
       // so it will be resolved per-request from the scoped container
       const token = getInjectableToken(classType)
-      this.container
-        .getRegistry()
-        .updateScope(token, InjectableScope.Request)
+      this.container.getRegistry().updateScope(token, InjectableScope.Request)
     }
 
     return {
       cached: cachedInstance !== null,
       instance: cachedInstance,
-      resolve: (scoped: ScopedContainer) =>
-        scoped.get(classType) as Promise<T>,
+      resolve: (scoped: ScopedContainer) => scoped.get(classType) as Promise<T>,
     }
   }
 
@@ -133,7 +130,9 @@ export class InstanceResolverService {
    * @param classTypes - The classes to resolve
    * @returns A resolution result containing either all cached instances or resolver function
    */
-  async resolveMany<T>(classTypes: ClassType[]): Promise<MultiInstanceResolution<T>> {
+  async resolveMany<T>(
+    classTypes: ClassType[],
+  ): Promise<MultiInstanceResolution<T>> {
     if (classTypes.length === 0) {
       return {
         cached: true,
@@ -170,7 +169,9 @@ export class InstanceResolverService {
       instances: cachedInstances,
       classTypes,
       resolve: (scoped: ScopedContainer) =>
-        Promise.all(classTypes.map((classType) => scoped.get(classType) as Promise<T>)),
+        Promise.all(
+          classTypes.map((classType) => scoped.get(classType) as Promise<T>),
+        ),
     }
   }
 }

package/src/services/module-loader.service.mts

@@ -1,6 +1,6 @@
 import type { ClassType, ClassTypeWithInstance } from '@navios/di'
 
-import { Container, inject, Injectable } from '@navios/di'
+import { Container, getInjectableToken, inject, Injectable } from '@navios/di'
 
 import type { NaviosModule } from '../interfaces/index.mjs'
 import type { ModuleMetadata } from '../metadata/index.mjs'
@@ -135,7 +135,8 @@ export class ModuleLoaderService {
     if (parentMetadata) {
       this.mergeMetadata(metadata, parentMetadata)
     }
-    const moduleName = module.name
+    const moduleToken = getInjectableToken(module)
+    const moduleName = moduleToken.id
     if (this.modulesMetadata.has(moduleName)) {
       return
     }

package/src/testing/index.mts

@@ -1,2 +1,3 @@
 export * from '@navios/di/testing'
 export * from './testing-module.mjs'
+export * from './unit-testing-module.mjs'