Resumen de la API

Esta página resume la API pública del core. Consulta el README del paquete y las declaraciones de TypeScript para ver las definiciones genéricas exactas.

Container

import {
  Container,
  type ContainerOptions,
  type DependenciesMap,
  type Lazy,
  type LazySpec,
  type Module,
  type RegistrationKind,
  type Spec,
  type SpecMap,
} from '@inferdi/inferdi'

class Container<T extends DependenciesMap = Record<never, never>> {
  constructor(options?: ContainerOptions)

  registerClass(key, Ctor, deps, kind?, lazyKey?)
  registerFactory(key, factory, kind?, lazyKey?)
  registerValue(key, value)
  override(key, value)
  use(fn)

  createScope()
  get(key)
  has(key)

  get disposed(): boolean
  dispose(): Promise<void>
  [Symbol.dispose](): void
  [Symbol.asyncDispose](): Promise<void>
}

Métodos de registro

Método	Uso
registerClass	Registra un constructor y una tupla de dependencias.
registerFactory	Registra lógica de construcción personalizada.
registerValue	Registra un valor singleton de propiedad externa.
override	Reemplaza un registro existente; rechaza una clave ya guardada en la caché local.
use	Aplica un constructor de módulos.

registerClass y registerFactory aceptan los tiempos de vida singleton, scoped y transient, además de un acompañante opcional lazyKey. registerValue siempre es singleton y de propiedad externa.

Trata la tupla de dependencias que se pasa a registerClass como inmutable después del registro. Las rutas de construcción optimizadas no crean una copia defensiva.

La comprobación de tiempo de override solo consulta la caché del contenedor actual. Detecta valores singleton/scoped guardados localmente, registerValue y overrides repetidos, pero no registra resoluciones transient ni valores propiedad de un ancestro resueltos desde un hijo. Aplica los overrides antes de resolver el grafo de dependencias.

Tipos del namespace

namespace Container {
  type Resolve<C>
  type ResolveUnwrapped<C>
  type UnwrappedValue<C, K>
  type Providers<C>
}

Tipo	Uso
Container.Resolve<C>	Extrae un mapa plano { key: Value } de un contenedor construido.
Container.ResolveUnwrapped<C>	Como Resolve, pero solo desenvuelve a T las entradas auxiliares administradas LazySpec; los servicios normales con .get() no cambian.
Container.UnwrappedValue<C, K>	Busca el tipo de un único servicio desenvuelto.
Container.Providers<C>	Crea un mapa de thunks de proveedores para pruebas.

Tipos públicos

type Lazy<T> = { readonly get: () => T }
type RegistrationKind = 'singleton' | 'transient' | 'scoped'

interface ContainerOptions {
  readonly strict?: boolean
}

interface Spec<V, K extends RegistrationKind = 'singleton'> {
  readonly type: V
  readonly kind: K
}

type SpecMap<M, K extends RegistrationKind = 'singleton'> = {
  [P in keyof M]: Spec<M[P], K>
}

type Module<TIn extends DependenciesMap, TOut extends DependenciesMap> =
  (c: Container<TIn>) => Container<TIn & TOut>

Formas de la API de los adaptadores

Todos los adaptadores exportan:

• la función de integración, como inferdiFastify
• skipInferdiDispose
• MaybePromise
• los helpers estructurales InferdiScope, InferdiRoot e InferdiScopeOf
• tipos de opciones y helpers de contexto específicos del framework

Usa las páginas de los adaptadores para conocer los nombres genéricos y los detalles del ciclo de vida específicos de cada framework.