@navios/core 0.7.1 → 0.9.0

package/src/decorators/multipart.decorator.mts

@@ -13,9 +13,9 @@ import { MultipartAdapterToken } from '../tokens/index.mjs'
 
 /**
  * Extracts the typed parameters for a multipart endpoint handler function.
- * 
+ *
  * Similar to `EndpointParams`, but specifically for multipart/form-data endpoints.
- * 
+ *
  * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
  */
 export type MultipartParams<
@@ -48,7 +48,7 @@ export type MultipartParams<
 
 /**
  * Extracts the typed return value for a multipart endpoint handler function.
- * 
+ *
  * @typeParam EndpointDeclaration - The endpoint declaration from @navios/builder
  */
 export type MultipartResult<
@@ -64,13 +64,13 @@ export type MultipartResult<
 
 /**
  * Decorator that marks a method as a multipart/form-data endpoint.
- * 
+ *
  * Use this decorator for endpoints that handle file uploads or form data.
  * The endpoint must be defined using @navios/builder's `declareMultipart` method.
- * 
+ *
  * @param endpoint - The multipart endpoint declaration from @navios/builder
  * @returns A method decorator
- * 
+ *
  * @example
  * ```typescript
  * const uploadFileEndpoint = api.declareMultipart({
@@ -79,7 +79,7 @@ export type MultipartResult<
  *   requestSchema: z.object({ file: z.instanceof(File) }),
  *   responseSchema: z.object({ url: z.string() }),
  * })
- * 
+ *
  * @Controller()
  * export class FileController {
  *   @Multipart(uploadFileEndpoint)
@@ -91,6 +91,51 @@ export type MultipartResult<
  * }
  * ```
  */
+export function Multipart<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  ResponseSchema extends ZodType = ZodType,
+  RequestSchema = ZodType,
+  Params = QuerySchema extends ZodObject
+    ? RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+      : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
+    : RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+      : EndpointFunctionArgs<Url, undefined, undefined, true>,
+>(endpoint: {
+  config: BaseEndpointConfig<
+    Method,
+    Url,
+    QuerySchema,
+    ResponseSchema,
+    RequestSchema
+  >
+}): (
+  target: (
+    params: Params,
+  ) => Promise<z.input<ResponseSchema>> | z.input<ResponseSchema>,
+  context: ClassMethodDecoratorContext,
+) => void
+export function Multipart<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  ResponseSchema extends ZodType = ZodType,
+  RequestSchema = ZodType,
+>(endpoint: {
+  config: BaseEndpointConfig<
+    Method,
+    Url,
+    QuerySchema,
+    ResponseSchema,
+    RequestSchema
+  >
+}): (
+  target: () => Promise<z.input<ResponseSchema>> | z.input<ResponseSchema>,
+  context: ClassMethodDecoratorContext,
+) => void
 export function Multipart<
   Method extends HttpMethod = HttpMethod,
   Url extends string = string,
@@ -106,23 +151,21 @@ export function Multipart<
     RequestSchema
   >
 }) {
-  return (
-    target: (
-      params: QuerySchema extends ZodObject
-        ? RequestSchema extends ZodType
-          ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-          : EndpointFunctionArgs<Url, QuerySchema, undefined>
-        : RequestSchema extends ZodType
-          ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-          : EndpointFunctionArgs<Url, undefined, undefined>,
-    ) => Promise<z.input<ResponseSchema>>,
-    context: ClassMethodDecoratorContext,
-  ) => {
-    if (typeof target !== 'function') {
-      throw new Error(
-        '[Navios] Endpoint decorator can only be used on functions.',
-      )
-    }
+  type Params = QuerySchema extends ZodObject
+    ? RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+      : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
+    : RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+      : EndpointFunctionArgs<Url, undefined, undefined, true>
+
+  type Handler =
+    | ((
+        params: Params,
+      ) => Promise<z.input<ResponseSchema>> | z.input<ResponseSchema>)
+    | (() => Promise<z.input<ResponseSchema>> | z.input<ResponseSchema>)
+
+  return (target: Handler, context: ClassMethodDecoratorContext) => {
     if (context.kind !== 'method') {
       throw new Error(
         '[Navios] Endpoint decorator can only be used on methods.',

package/src/decorators/stream.decorator.mts

@@ -11,9 +11,9 @@ import { StreamAdapterToken } from '../tokens/index.mjs'
 
 /**
  * Extracts the typed parameters for a stream endpoint handler function.
- * 
+ *
  * Similar to `EndpointParams`, but specifically for streaming endpoints.
- * 
+ *
  * @typeParam EndpointDeclaration - The stream endpoint declaration from @navios/builder
  */
 export type StreamParams<
@@ -46,20 +46,20 @@ export type StreamParams<
 
 /**
  * Decorator that marks a method as a streaming endpoint.
- * 
+ *
  * Use this decorator for endpoints that stream data (e.g., file downloads, SSE).
  * The endpoint must be defined using @navios/builder's `declareStream` method.
- * 
+ *
  * @param endpoint - The stream endpoint declaration from @navios/builder
  * @returns A method decorator
- * 
+ *
  * @example
  * ```typescript
  * const downloadFileEndpoint = api.declareStream({
  *   method: 'get',
  *   url: '/files/$fileId',
  * })
- * 
+ *
  * @Controller()
  * export class FileController {
  *   @Stream(downloadFileEndpoint)
@@ -70,6 +70,51 @@ export type StreamParams<
  * }
  * ```
  */
+export function Stream<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  RequestSchema = ZodType,
+  Params = QuerySchema extends ZodObject
+    ? RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+      : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
+    : RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+      : EndpointFunctionArgs<Url, undefined, undefined, true>,
+>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>
+}): (
+  target: (params: Params, reply: any) => any,
+  context: ClassMethodDecoratorContext,
+) => void
+// Bun doesn't support reply parameter
+export function Stream<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  RequestSchema = ZodType,
+  Params = QuerySchema extends ZodObject
+    ? RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+      : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
+    : RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+      : EndpointFunctionArgs<Url, undefined, undefined, true>,
+>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>
+}): (
+  target: (params: Params) => any,
+  context: ClassMethodDecoratorContext,
+) => void
+export function Stream<
+  Method extends HttpMethod = HttpMethod,
+  Url extends string = string,
+  QuerySchema = undefined,
+  RequestSchema = ZodType,
+>(endpoint: {
+  config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>
+}): (target: () => any, context: ClassMethodDecoratorContext) => void
 export function Stream<
   Method extends HttpMethod = HttpMethod,
   Url extends string = string,
@@ -78,24 +123,20 @@ export function Stream<
 >(endpoint: {
   config: BaseStreamConfig<Method, Url, QuerySchema, RequestSchema>
 }) {
-  return (
-    target: (
-      params: QuerySchema extends ZodObject
-        ? RequestSchema extends ZodType
-          ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-          : EndpointFunctionArgs<Url, QuerySchema, undefined>
-        : RequestSchema extends ZodType
-          ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-          : EndpointFunctionArgs<Url, undefined, undefined>,
-      reply: any,
-    ) => Promise<void>,
-    context: ClassMethodDecoratorContext,
-  ) => {
-    if (typeof target !== 'function') {
-      throw new Error(
-        '[Navios] Endpoint decorator can only be used on functions.',
-      )
-    }
+  type Params = QuerySchema extends ZodObject
+    ? RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+      : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
+    : RequestSchema extends ZodType
+      ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+      : EndpointFunctionArgs<Url, undefined, undefined, true>
+
+  type Handler =
+    | ((params: Params, reply: any) => any)
+    | ((params: Params) => any)
+    | (() => any)
+
+  return (target: Handler, context: ClassMethodDecoratorContext) => {
     if (context.kind !== 'method') {
       throw new Error(
         '[Navios] Endpoint decorator can only be used on methods.',

package/src/interfaces/abstract-http-handler-adapter.interface.mts

@@ -2,6 +2,36 @@ import type { ClassType, ScopedContainer } from '@navios/di'
 
 import type { HandlerMetadata } from '../metadata/index.mjs'
 
+/**
+ * Static handler result - handler can be called without a scoped container.
+ * Used when the controller and all its dependencies are singletons.
+ */
+export type StaticHandler<TRequest = any, TReply = any> = {
+  isStatic: true
+  handler: (request: TRequest, reply: TReply) => Promise<any>
+}
+
+/**
+ * Dynamic handler result - handler requires a scoped container for resolution.
+ * Used when the controller or its dependencies need per-request resolution.
+ */
+export type DynamicHandler<TRequest = any, TReply = any> = {
+  isStatic: false
+  handler: (
+    scoped: ScopedContainer,
+    request: TRequest,
+    reply: TReply,
+  ) => Promise<any>
+}
+
+/**
+ * Handler result returned by provideHandler.
+ * Can be either static (pre-resolved) or dynamic (needs scoped container).
+ */
+export type HandlerResult<TRequest = any, TReply = any> =
+  | StaticHandler<TRequest, TReply>
+  | DynamicHandler<TRequest, TReply>
+
 export interface AbstractHttpHandlerAdapterInterface {
   prepareArguments?: (
     handlerMetadata: HandlerMetadata<any>,
@@ -9,5 +39,5 @@ export interface AbstractHttpHandlerAdapterInterface {
   provideHandler: (
     controller: ClassType,
     handlerMetadata: HandlerMetadata<any>,
-  ) => (context: ScopedContainer, request: any, reply: any) => Promise<any>
+  ) => Promise<HandlerResult>
 }

package/src/legacy-compat/__type-tests__/legacy-decorators.spec-d.mts

@@ -138,9 +138,7 @@ describe('Legacy Decorators Type Safety', () => {
           // - request.urlParams.userId: string | number
           // - request.params.page: number
           // - request.params.limit: number
-          expectTypeOf(request.urlParams.userId).toEqualTypeOf<
-            string | number
-          >()
+          expectTypeOf(request.urlParams.userId).toEqualTypeOf<string>()
           expectTypeOf(request.params.page).toEqualTypeOf<number>()
           expectTypeOf(request.params.limit).toEqualTypeOf<number>()
           return {
@@ -270,9 +268,7 @@ describe('Legacy Decorators Type Safety', () => {
           // - request.urlParams.fileId: string | number
           // - request.params.page: number
           // - request.params.limit: number
-          expectTypeOf(request.urlParams.fileId).toEqualTypeOf<
-            string | number
-          >()
+          expectTypeOf(request.urlParams.fileId).toEqualTypeOf<string>()
           expectTypeOf(request.params.page).toEqualTypeOf<number>()
           expectTypeOf(request.params.limit).toEqualTypeOf<number>()
         }

package/src/legacy-compat/decorators/endpoint.decorator.mts

@@ -92,7 +92,7 @@ export function Endpoint<
     // @ts-expect-error - we don't need to type the value
     const result = originalDecorator(typedDescriptor.value, context)
     if (result !== typedDescriptor.value) {
-      typedDescriptor.value = result
+      typedDescriptor.value = result as any
     }
     return typedDescriptor
   }

package/src/legacy-compat/decorators/multipart.decorator.mts

@@ -22,11 +22,11 @@ type MultipartMethodDescriptor<
   (
     params: QuerySchema extends ZodObject
       ? RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-        : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+        : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
       : RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-        : EndpointFunctionArgs<Url, undefined, undefined>,
+        ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+        : EndpointFunctionArgs<Url, undefined, undefined, true>,
   ) => Promise<z.input<ResponseSchema>>
 >
 
@@ -86,7 +86,7 @@ export function Multipart<
     // @ts-expect-error - we don't need to type the value
     const result = originalDecorator(descriptor.value, context)
     if (result !== descriptor.value) {
-      descriptor.value = result
+      descriptor.value = result as any
     }
     return descriptor
   }

package/src/legacy-compat/decorators/stream.decorator.mts

@@ -21,11 +21,11 @@ type StreamMethodDescriptor<
   (
     params: QuerySchema extends ZodObject
       ? RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema>
-        : EndpointFunctionArgs<Url, QuerySchema, undefined>
+        ? EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>
+        : EndpointFunctionArgs<Url, QuerySchema, undefined, true>
       : RequestSchema extends ZodType
-        ? EndpointFunctionArgs<Url, undefined, RequestSchema>
-        : EndpointFunctionArgs<Url, undefined, undefined>,
+        ? EndpointFunctionArgs<Url, undefined, RequestSchema, true>
+        : EndpointFunctionArgs<Url, undefined, undefined, true>,
     reply: any,
   ) => Promise<void>
 >
@@ -69,7 +69,7 @@ export function Stream<
     // @ts-expect-error - we don't need to type the value
     const result = originalDecorator(descriptor.value, context)
     if (result !== descriptor.value) {
-      descriptor.value = result
+      descriptor.value = result as any
     }
     return descriptor
   }

package/src/logger/logger.service.mts

@@ -60,8 +60,6 @@ export class LoggerInstance implements LoggerService {
     optionalParams = this.context
       ? optionalParams.concat(this.context)
       : optionalParams
-    console.log('log', message, optionalParams)
-    console.log('localInstance', this.localInstance)
     this.localInstance?.log(message, ...optionalParams)
   }
 

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.
@@ -55,6 +55,20 @@ export interface NaviosApplicationOptions extends NaviosApplicationContextOption
    * ```
    */
   adapter: NaviosEnvironmentOptions | NaviosEnvironmentOptions[]
+
+  /**
+   * Whether to validate response schemas.
+   * When `false`, response schema validation is skipped for better performance.
+   * @default true
+   */
+  validateResponses?: boolean
+
+  /**
+   * Whether to enable request ID propagation via AsyncLocalStorage.
+   * When `true`, request IDs are available via `getRequestId()` throughout the request.
+   * @default false
+   */
+  enableRequestId?: boolean
 }
 
 /**

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,17 +4,16 @@ 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'
 import { NaviosEnvironment } from './navios.environment.mjs'
+import { setRequestIdEnabled } from './stores/index.mjs'
+import { NaviosOptionsToken } from './tokens/index.mjs'
 
 /**
  * Factory class for creating and configuring Navios applications.
@@ -81,7 +80,16 @@ 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) {
+      setRequestIdEnabled(true)
+    }
+
+    // Store options in container for DI access by adapters
+    container.addInstance(NaviosOptionsToken, options)
+
     await this.registerLoggerConfiguration(container, options)
     const adapters = Array.isArray(options.adapter)
       ? options.adapter
@@ -109,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/guard-runner.service.mts

@@ -20,6 +20,11 @@ export class GuardRunnerService {
   private readonly logger = inject(Logger, {
     context: GuardRunnerService.name,
   })
+
+  /**
+   * Runs guards that need to be resolved from a scoped container.
+   * Use this when guards have request-scoped dependencies.
+   */
   async runGuards(
     allGuards: Set<
       | ClassTypeWithInstance<CanActivate>
@@ -28,16 +33,48 @@ export class GuardRunnerService {
     executionContext: AbstractExecutionContext,
     context: ScopedContainer,
   ) {
-    let canActivate = true
-    for (const guard of Array.from(allGuards).reverse()) {
-      const guardInstance = await context.get(
-        guard as InjectionToken<CanActivate, undefined>,
-      )
-      if (!guardInstance.canActivate) {
-        throw new Error(
-          `[Navios] Guard ${guard.name as string} does not implement canActivate()`,
+    // Reverse order: module guards run first, then controller, then endpoint
+    const guardsArray = Array.from(allGuards).reverse()
+
+    // Resolve all guards in parallel
+    const guardInstances = await Promise.all(
+      guardsArray.map(async (guard) => {
+        const guardInstance = await context.get(
+          guard as InjectionToken<CanActivate, undefined>,
         )
-      }
+        if (!guardInstance.canActivate) {
+          throw new Error(
+            `[Navios] Guard ${guard.name as string} does not implement canActivate()`,
+          )
+        }
+        return guardInstance
+      }),
+    )
+
+    return this.executeGuards(guardInstances, executionContext)
+  }
+
+  /**
+   * Runs pre-resolved guard instances.
+   * Use this when all guards are singletons and have been pre-resolved at startup.
+   */
+  async runGuardsStatic(
+    guardInstances: CanActivate[],
+    executionContext: AbstractExecutionContext,
+  ) {
+    return this.executeGuards(guardInstances, executionContext)
+  }
+
+  /**
+   * Shared guard execution logic.
+   * Iterates through guard instances and calls canActivate on each.
+   */
+  private async executeGuards(
+    guardInstances: CanActivate[],
+    executionContext: AbstractExecutionContext,
+  ): Promise<boolean> {
+    let canActivate = true
+    for (const guardInstance of guardInstances) {
       try {
         canActivate = await guardInstance.canActivate(executionContext)
         if (!canActivate) {

package/src/services/index.mts

@@ -1,2 +1,3 @@
+export * from './instance-resolver.service.mjs'
 export * from './guard-runner.service.mjs'
 export * from './module-loader.service.mjs'