InversifyJS Logger Middleware

Common errors

• Error: No matching bindings found for serviceIdentifier: Symbol(Weapon)

  cause The logger middleware cannot resolve bindings that are not correctly configured in the InversifyJS container.
  fix Review your `ContainerModule` or direct `bind` calls to ensure that all requested service identifiers have at least one valid binding. Check for typos in service identifiers or incorrect `when` clauses.

• TypeError: container.applyMiddleware is not a function

  cause You might be using an older version of InversifyJS that does not support the `applyMiddleware` method, or `container` is not an instance of `Inversify.Container`.
  fix Update your `inversify` package to a version that supports middleware (e.g., 2.0.0 or higher). Ensure that the `container` variable is indeed a `new Container()` instance.

Warnings

• breaking Version 3.0.0 introduced breaking changes to align with InversifyJS v3.0.0. Ensure your core 'inversify' package is also updated to v3.x.x for compatibility.
  Fix: Update 'inversify' to a compatible 3.x.x version. Consult the InversifyJS v3 migration guide if upgrading from an older major version.
• breaking Version 2.0.0 of inversify-logger-middleware is compatible with inversify@2.0.0. Major version bumps typically indicate breaking changes aligning with the core InversifyJS library's API changes.
  Fix: Ensure your 'inversify' dependency matches the major version required by inversify-logger-middleware. For v2.x.x of the logger, use inversify@2.x.x.
• gotcha This package requires TypeScript 2.0 or higher for its type definitions. Using an older TypeScript version may result in compilation errors related to missing types or incorrect type inference.
  Fix: Upgrade your project's TypeScript version to 2.0 or newer. Ensure 'skipLibCheck' is not masking issues if you are encountering unexpected type problems.

Install

• npm install inversify-logger-middleware npm
• yarn add inversify-logger-middleware yarn
• pnpm add inversify-logger-middleware pnpm

Imports

• makeLoggerMiddleware
  wrong:

  const makeLoggerMiddleware = require('inversify-logger-middleware');

  correct:

  import { makeLoggerMiddleware } from 'inversify-logger-middleware';

  Primary factory function to create the middleware. InversifyJS and its ecosystem are primarily TypeScript/ESM-first, though CommonJS usage is possible with appropriate transpilation.
• Container
  wrong:

  import { Container } from 'inversify-logger-middleware';

  correct:

  import { Container, ContainerModule } from 'inversify';

  Container and related types (like ContainerModule) are part of the core 'inversify' package, not the logger middleware itself.
• interfaces.Bind
  wrong:

  import { Bind } from 'inversify-logger-middleware';

  correct:

  import { interfaces } from 'inversify';

  Binding interfaces are exported from the core 'inversify' package.

Quickstart

This quickstart demonstrates how to set up an InversifyJS container with conditional bindings, apply the logger middleware, and resolve dependencies, showing the detailed resolution plan in the console.

import "reflect-metadata";
import { Container, ContainerModule, interfaces } from 'inversify';
import { makeLoggerMiddleware } from 'inversify-logger-middleware';

interface Weapon { attack(): string; }
interface Warrior { fight(): string; sneak(): string; }

class Katana implements Weapon {
  public attack() { return "cut!"; }
}

class Shuriken implements Weapon {
  public attack() { return "throw!"; }
}

class Samurai implements Warrior {
  private _weapon: Weapon;
  constructor(@inversify.inject("Weapon") weapon: Weapon) { this._weapon = weapon; }
  public fight() { return this._weapon.attack(); }
  public sneak() { return ""; }
}

class Ninja implements Warrior {
  private _weapon: Weapon;
  constructor(@inversify.inject("Weapon") weapon: Weapon) { this._weapon = weapon; }
  public fight() { return this._weapon.attack(); }
  public sneak() { return "sneak!"; }
}

const container = new Container();
const logger = makeLoggerMiddleware();
container.applyMiddleware(logger);

const warriorModule = new ContainerModule((bind: interfaces.Bind) => {
    bind<Weapon>("Weapon").to(Katana).whenInjectedInto(Samurai);
    bind<Weapon>("Weapon").to(Shuriken).whenInjectedInto(Ninja);
    bind<Warrior>("Warrior").to(Samurai).whenTargetTagged("canSneak", false);
    bind<Warrior>("Warrior").to(Ninja).whenTargetTagged("canSneak", true);
});

container.load(warriorModule);

// This will now log the resolution plan to the console
const ninja = container.getTagged<Warrior>("Warrior", "canSneak", true);
console.log(ninja.fight());
console.log(ninja.sneak());

const samurai = container.getTagged<Warrior>("Warrior", "canSneak", false);
console.log(samurai.fight());