Class TsyringeProvider

constructor

• new TsyringeProvider(
      dependencies: TsyringeDependencies,
      options?: TsyringeProviderOptions,
  ): TsyringeProvider

  Creates a new TsyringeProvider instance

  Parameters

  • dependencies: TsyringeDependencies

    tsyringe dependencies (container and Lifecycle)

  • options: TsyringeProviderOptions = {}

    Configuration options

  Returns TsyringeProvider

  Example

  import { container, Lifecycle } from 'tsyringe'
  
  const provider = new TsyringeProvider(
      { container, Lifecycle },
      { useChildContainer: true }
  )
  Copy

Readonlyname

createScope

• createScope(): ContainerProvider

  Creates a child scope (child container) Useful for HTTP requests, transactions, or isolated contexts

  Returns ContainerProvider

  New scoped provider instance

  Example

  const requestScope = provider.createScope()
  requestScope.registerValue(TOKENS.RequestId, generateRequestId())
  Copy

dispose

• dispose(): void

  Releases provider resources Called during application cleanup or shutdown

  Returns void

getUnderlyingContainer

• getUnderlyingContainer(): TsyringeDependencyContainer

  Returns the underlying tsyringe DependencyContainer

  Returns TsyringeDependencyContainer

  The tsyringe container instance

isRegistered

• isRegistered(token: ProviderToken): boolean

  Checks if a token is already registered in the container

  Parameters

  • token: ProviderToken

    Token to check

  Returns boolean

  true if the token is registered, false otherwise

  Example

  if (!provider.isRegistered(TOKENS.Logger)) {
      provider.registerClass(TOKENS.Logger, ConsoleLogger)
  }
  Copy

registerClass

• registerClass<T>(
      token: ProviderToken<T>,
      implementation?: Constructor<T>,
      lifecycle?: ProviderLifecycle,
  ): void

  Registers a class in the container

  Type Parameters

  • T

    The type of the class instance

  Parameters

  • token: ProviderToken<T>

    Token (symbol or class) to register under

  • Optionalimplementation: Constructor<T>

    Class to instantiate (optional if token is a class)

  • lifecycle: ProviderLifecycle = ProviderLifecycle.Singleton

    Instance lifecycle (Singleton, Transient, or Scoped)

  Returns void

  Example

  // Register class as its own token
  provider.registerClass(UserService)
  
  // Register implementation for a symbol token
  provider.registerClass(TOKENS.Logger, ConsoleLogger, ProviderLifecycle.Singleton)
  Copy

registerFactory

• registerFactory<T>(
      token: symbol,
      factory: (provider: ContainerProvider) => T,
  ): void

  Registers a factory function in the container

  Type Parameters

  • T

    The type of the value produced by the factory

  Parameters

  • token: symbol

    Symbol token to register the factory under

  • factory: (provider: ContainerProvider) => T

    Function that creates the instance (receives the provider to resolve dependencies)

  Returns void

  Example

  provider.registerFactory(TOKENS.HttpClient, (p) => {
      return new HttpClient(p.resolve(TOKENS.ApiUrl))
  })
  Copy

registerValue

• registerValue<T>(token: symbol, value: T): void

  Registers a static value in the container

  Type Parameters

  • T

    The type of the value

  Parameters

  • token: symbol

    Symbol token to register the value under

  • value: T

    The value to register

  Returns void

  Example

  provider.registerValue(TOKENS.ApiUrl, 'https://api.example.com')
  Copy

resolve

• resolve<T>(token: ProviderToken<T>): T

  Resolves a dependency from the container

  Type Parameters

  • T

    The type of the resolved dependency

  Parameters

  • token: ProviderToken<T>

    Token of the dependency to resolve

  Returns T

  Instance of the dependency

  Throws

  Error if the token is not registered

  Example

  const logger = provider.resolve<LoggerInterface>(TOKENS.Logger)
  const userService = provider.resolve(UserService)
  Copy