Enhanced IFactory<T> flexibility

[remojansen]

Expected Behavior

export interface IFactory<T> extends Function {
    (...args: any[]): (IFactory<T>|T);
} 

Current Behavior

export interface IFactory<T> extends Function {
    (...args: any[]): T;
}

Context

This use cases comes form the #177.

interface IInjectorPump {}

@injectable()
class InjectorPump implements IInjectorPump {}

interface ISparkPlugs {}

@injectable()
class SparkPlugs implements ISparkPlugs {}

class IEngine {
    public displacement: number;
}

@injectable()
class DieselEngine implements IEngine {
    public displacement: number;
    private _injectorPump: IInjectorPump;
    constructor(
        @inject("IInjectorPump") injectorPump: IInjectorPump
    ) {
        this._injectorPump = injectorPump;
        this.displacement = null;
    }
}

@injectable()
class PetrolEngine implements IEngine {
    public displacement: number;
    private _sparkPlugs: ISparkPlugs;
    constructor(
        @inject("ISparkPlugs") sparkPlugs: ISparkPlugs
    ) {
        this._sparkPlugs = sparkPlugs;
        this.displacement = null;
    }
}

interface ICarFactory {
    createEngine(displacement: number): IEngine;
}

@injectable()
class DieselCarFactory implements ICarFactory {
    private _dieselFactory: (...args: any[]) => IEngine ;
    constructor(
        @inject("IFactory<IEngine>") factory: (category: string) => (displacement: number) => IEngine
    ) {
        this._dieselFactory = factory("diesel");
    }
    public createEngine(displacement: number): IEngine {
        return this._dieselFactory(displacement);
    }
}

let kernel = new Kernel();
kernel.bind<ISparkPlugs>("ISparkPlugs").to(SparkPlugs);
kernel.bind<IInjectorPump>("IInjectorPump").to(InjectorPump);
kernel.bind<IEngine>("IEngine").to(PetrolEngine).whenTargetNamed("petrol");
kernel.bind<IEngine>("IEngine").to(DieselEngine).whenTargetNamed("diesel");

kernel.bind<IFactory<IEngine>>("IFactory<IEngine>").toFactory<IEngine>((context) => {
    return (named: string) => (displacement: number) => {
        let engine = context.kernel.getNamed<IEngine>("IEngine", named);
        engine.displacement = displacement;
        return engine;
    };
});

kernel.bind<ICarFactory>("IDieselCarFactory").to(DieselCarFactory);

let dieselCarFactory = kernel.get<ICarFactory>("IDieselCarFactory");
let engine = dieselCarFactory.createEngine(300);

expect(engine.displacement).eql(300);
expect(engine instanceof DieselEngine).eql(true);

[remojansen]

@lazyoft I have this almost ready in a fork. The problem is that the users are forced to write the full signature of the Factory:

@inject("IFactory<IEngine>") factory: (category: string) => (displacement: number) => IEngine

An alternative was to use generics:

@inject("IFactory<string, number, IEngine>") factory: IFactory<string, number, IEngine>

But it would be limited to a number of generic arguments and it would be really verbose.

I have created another issue to request a feature that would the following:

@inject("IFactory<IEngine>") factory: IFactory<IEngine>

I'm going to wait to see what the TypeScript guys write back.

[lazyoft]

Hi @remojansen,
from what I can see they will going to implement variadic types in 2.1 hopefully (it was something I was interested into as well, along with support for nominal types). For the time being I would say that it will be most unlikely to go with partial applications with more than 2 or three parameters for these cases, so the long signature should not be a big deal.
Thaks a lot, really appreciated your efforts.

[remojansen]

This has been implemented I will release version 2.0.0-beta.2 really soon 😄