Could Inversify help TypeScript perform type check on an ServiceIdentifier I use with @inject decorator?

Thanks for the suggestion, I will try this out.

Another way to write it, fyi:

container.bind(TokenStorageTS2).toService(TokenStorageTS1);

What I found out:

• You can leave away the @inject, but only if you leave it away for all the arguments. As I need to mix string service identifiers and class service identifiers, the @inject needs to stay (for now).

• The type error message, when something goes wrong is a little confusing.

  Consider this toy example:

  import "reflect-metadata";
  import { Container, injectable, inject } from "inversify";
  
  abstract class Warrior {
    abstract fight(): string;
  }
  
  abstract class Weapon {
    abstract hit(): string;
  }
  
  abstract class ThrowableWeapon {
    abstract throw(): string;
  }
  
  @injectable()
  class Katana implements Weapon {
    public hit() {
      return "cut!";
    }
  }
  
  @injectable()
  class Ninja implements Warrior {
    public constructor(private weapon: ThrowableWeapon) {}
  
    public fight() { return this.weapon.throw(); }
  }
  
  const myContainer = new Container();
  myContainer.bind(Weapon).to(Katana);
  

  Now when we incorrectly bind Katana to ThrowableWeapon with

  myContainer.bind(ThrowableWeapon).to(Katana);
  

  we get a nice error message:

  Argument of type 'typeof Katana' is not assignable to parameter of type 'new (...args: any[]) => ThrowableWeapon'.
    Property 'throw' is missing in type 'Katana' but required in type 'ThrowableWeapon'.
  

  When we try to use toService though

  myContainer.bind(ThrowableWeapon).toService(Weapon);
  

  the error message is not helpful at all:

  Argument of type 'typeof Weapon' is not assignable to parameter of type 'string | symbol | Newable<ThrowableWeapon> | Abstract<ThrowableWeapon>'.
    Type 'typeof Weapon' is not assignable to type 'Newable<ThrowableWeapon>'.
      Cannot assign an abstract constructor type to a non-abstract constructor type.
  

• When using bind(ThrowableWeapon).toService(Weapon), inversify does not type check Katana against ThrowableWeapon, but instead checks Weapon against ThrowableWeapon.

  So if we had a Katana that implemented both Weapon and ThrowableWeapon, we would have to use a more complex syntax to achieve proper type checking. Directly binding both to different instances of Katana would work of course. Otherwise the following does the trick:

  myContainer.bind(Katana).toSelf().inSingletonScope();
  myContainer.bind(Weapon).toConstantValue(myContainer.get(Katana));
  myContainer.bind(ThrowableWeapon).toConstantValue(myContainer.get(Katana));
  

  It is not very beautiful though.

  Luckily this case is rare.