typed-inject

You can control whether a dependency is cached or recreated every time using the third argument of provideFactory or provideClass, which accepts a Scope value.

• Scope.Singleton (default): The dependency is cached within the specific injector and its children. Subsequent requests for the same dependency return the same instance.
• Scope.Transient: Caching is disabled. A fresh instance is created every time the dependency is requested.

// ... imports and setup

const fooProvider = injector
  .provideFactory('log', loggerFactory, Scope.Transient)
  .provideClass('foo', Foo, Scope.Singleton);

const foo = fooProvider.resolve('foo');
const fooCopy = fooProvider.resolve('foo');
const log = fooProvider.resolve('foo').log;

console.log(foo === fooCopy); // => true (Singleton)
// log will be a different instance if provided as Transient

The Injector<TContext> is the core interface. It uses a TContext lookup type where keys are injection tokens and values are the types of those tokens.

• rootInjector: The only built-in implementation. It implements Injector<{}> and provides no tokens (except magic tokens). You use it as a starting point to create child injectors.
• Child Injectors: Created via provideXXX methods, these extend the parent's capabilities by adding new tokens or overriding existing ones.

The Injector returned by createInjector() is an empty base injector. To make it useful, you create child injectors by chaining provideXXX methods.

Each child injector inherits the dependencies of its parent. For example, if a parent injector provides 'foo', a child injector created via .provideValue('bar', ...) can resolve both 'foo' and 'bar'.

import { createInjector } from 'typed-inject';

function barFactory(foo: number) {
  return foo + 1;
}
barFactory.inject = ['foo'] as const;

class Baz {
  constructor(bar: number) {
    console.log(`bar is: ${bar}`);
  }
  static inject = ['bar'] as const;
}

const childInjector = createInjector()
  .provideValue('foo', 42)
  .provideFactory('bar', barFactory)
  .provideClass('baz', Baz);

function run(baz: Baz) {
  // baz is created!
}
run.inject = ['baz'] as const;

childInjector.injectFunction(run);

To allow the Injector to automatically clean up your dependencies, implement a dispose() method. Because of TypeScript's structural typing, you don't need to explicitly implement a Disposable interface; simply having a dispose() method is enough.

interface Disposable {
  dispose(): void;
}

Install typed-inject locally within your project folder using npm or yarn.

Requirements:

• TypeScript 3.0 or above.
• Your TypeScript configuration must enable --strictFunctionTypes (or --strict) to ensure type errors are correctly caught.

npm i typed-inject

yarn add typed-inject

In typed-inject, an InjectionTarget is the identifier used to look up or provide a dependency within an injector. It can be a Function (often used as a class or constructor), a symbol, a number, a string, or undefined.

export type InjectionTarget = Function | symbol | number | string | undefined;

When an error occurs during the injection process (e.g., a constructor throws), typed-inject wraps the error in an InjectionError. This error provides a detailed path showing exactly which tokens and classes were involved in the failed resolution chain.

You can catch this error and access the original error via the cause property to inspect the stack trace.

import { InjectionError } from 'typed-inject';

try {
  createInjector()
    .provideClass('grandChild', GrandChild)
    .provideClass('child', Child)
    .injectClass(Parent);
} catch (err) {
  if (err instanceof InjectionError) {
    // err.cause contains the original error and the injection path
    console.error(err.cause.stack);
  }
}

You can implement the decorator pattern by using provideFactory or provideClass to wrap an existing dependency. By providing a factory that takes the original dependency as an argument (and declaring it in the factory's inject property), you can return a decorated version of the object.

import { createInjector } from 'typed-inject';

class Foo {
  public bar() {
    console.log('bar!');
  }
}

function fooDecorator(foo: Foo) {
  return {
    bar() {
      console.log('before call');
      foo.bar();
      console.log('after call');
    },
  };
}
fooDecorator.inject = ['foo'] as const;

const fooProvider = createInjector()
  .provideClass('foo', Foo)
  .provideFactory('foo', fooDecorator);

const foo = fooProvider.resolve('foo');

foo.bar();
// => "before call"
// => "bar!"
// => "after call"

Use createInjector() to create a new Injector<{}>. It is recommended to create one injector per application or per request. For unit testing, create a fresh injector for each test (e.g., in a global test setup) to ensure isolation.

import { createInjector } from 'typed-inject';

const appInjector = createInjector();