Class AwilixProvider

constructor

• new AwilixProvider(options?: AwilixProviderOptions): AwilixProvider

  Creates a new AwilixProvider instance

  Parameters

  • options: AwilixProviderOptions = {}

    Configuration options

  Returns AwilixProvider

  Remarks

  When using the constructor directly, you must call init() before use, or use createSync() for synchronous initialization.

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(): AwilixContainer

  Returns the underlying Awilix container instance

  Returns AwilixContainer

  The AwilixContainer instance

init

• init(): Promise<void>

  Initializes the provider asynchronously

  Returns Promise<void>

  Remarks

  Required before using the provider if not using createSync().

  Example

  const provider = new AwilixProvider({ injectionMode: 'PROXY' })
  await provider.init()
  useContainerProvider(provider)
  Copy

isRegistered

• isRegistered(token: symbol | Constructor<unknown>): boolean

  Checks if a token is already registered in the container

  Parameters

  • token: symbol | Constructor<unknown>

    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: symbol | Constructor<T>,
      impl?: Constructor<T>,
      lifecycle?: ProviderLifecycle,
  ): void

  Registers a class in the container

  Type Parameters

  • T

    The type of the class instance

  Parameters

  • token: symbol | Constructor<T>

    Token (symbol or class) to register under

  • Optionalimpl: Constructor<T>

    Class to instantiate (optional if token is a class)

  • Optionallifecycle: ProviderLifecycle

    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: symbol | Constructor<T>): T

  Resolves a dependency from the container

  Type Parameters

  • T

    The type of the resolved dependency

  Parameters

  • token: symbol | Constructor<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

StaticcreateSync

• createSync(awilix: __module, options?: AwilixProviderOptions): AwilixProvider

  Creates a pre-initialized provider synchronously

  Parameters

  • awilix: __module

    The awilix module import

  • options: AwilixProviderOptions = {}

    Configuration options

  Returns AwilixProvider

  Fully initialized AwilixProvider instance

  Remarks

  This is the recommended way to create an AwilixProvider as it avoids async initialization and ensures the provider is ready immediately.

  Example

  import * as awilix from 'awilix'
  
  const provider = AwilixProvider.createSync(awilix, {
      injectionMode: 'CLASSIC'
  })
  Copy