One phase initialization for providers

[remojansen]

Expected Behavior

Reduce the number of steps required by the users when using synchronous factories (AKA Providers).

Current Behavior

Asynchronous factories require two steps for initialization:

class UserRepository { 

    private _db: DbClient;
    private _dbProvider: Provider<DbClient>;

    // STEP 1
    public constructor(
        @inject("Provider<DbClient>") provider: Provider<DbClient> // Provider injection 
    ) { 
        this._dbProvider = provider;
    }

    // STEP 2
    private async init() {
        if (this._db) return this._db;
        this._db = await this._dbProvider();
        return Promise.resolve(this._db);
    }

    public async getUser(): Promise<Users[]>{
        let db = await this.init();
        return db.collections.user.get({});
    }

    public async deletetUser(id: number): Promise<boolean>{
        let db = await this.init();
        return db.collections.user.delete({ id: id });
    }

}

Possible Solution

As suggested by @buehler:

class Provider<T>{
    public readonly value: T;

    public get someFancyNameForProvideValue(): Promise<T> {
        return this.value !== undefined ? Promise.resolve(this.value): this.provide();
    }

    public provide(): Promise<T> {
         /* exec provider function */
         this.value = 42; // save the result of the provider function
    }
}

// then you could make either:

class UserRepository { 

    // STEP 1
    public constructor(
        @inject("Provider<DbClient>") private provider: Provider<DbClient> // Provider injection 
    ) {}

    public async getUser(): Promise<Users[]>{
        let db = this.provider.value || await this.provider.provide();
        return db.collections.user.get({});
    }
}

// or (would be cool too, with the fancy getter):

class UserRepository { 

    // STEP 1
    public constructor(
        @inject("Provider<DbClient>") private provider: Provider<DbClient> // Provider injection 
    ) {}

    public async getUser(): Promise<Users[]>{
        let db = await this.provider.someFancyNameForProvideValue;
        return db.collections.user.get({});
    }
}

Context

#404

[remojansen]

I started working on this and I realized that the proposed solution has a problem: It assumes that we want the provider to return a singleton. For this reason, I decided not to go ahead with this change. However, I noticed that the Provider was much less flexible than the Factory. I have upgraded the Provider signature to allow advanced use cases like:

• Singleton and Transient scope support
• Custom arguments support
• Support for the partial application of custom arguments

I have created a PR #431 that documents all these features. The PR also documents a "recipe" that helps to reduce boilerplate:

function valueOrDefault<T>(provider: () => Promise<T>, defaultValue: T) {
    return new Promise<T>((resolve, reject) => {
        provider().then((value) => {
            resolve(value);
        }).catch(() => {
            resolve(defaultValue);
        });
    });
}

@injectable()
class Ninja {
    public level: number;
    public rank: string;
    public constructor() {
        this.level = 0;
        this.rank = "Ninja";
    }
    public train(): Promise<number> {
        return new Promise<number>((resolve) => {
            setTimeout(() => {
                this.level += 10;
                resolve(this.level);
            }, 100);
        });
    }
}

@injectable()
class NinjaMaster {
    public rank: string;
    public constructor() {
        this.rank = "NinjaMaster";
    }
}

type NinjaMasterProvider = () => Promise<NinjaMaster>;

let container = new Container();

container.bind<Ninja>("Ninja").to(Ninja).inSingletonScope();
container.bind<NinjaMasterProvider>("NinjaMasterProvider").toProvider((context) => {
    return () => {
        return new Promise<NinjaMaster>((resolve, reject) => {
            let ninja = context.container.get<Ninja>("Ninja");
            ninja.train().then((level) => {
                if (level >= 20) {
                    resolve(new NinjaMaster());
                } else {
                    reject("Not enough training");
                }
            });
        });
    };
});

let ninjaMasterProvider = container.get<NinjaMasterProvider>("NinjaMasterProvider");

valueOrDefault(ninjaMasterProvider, { rank: "DefaultNinjaMaster" }).then((ninjaMaster) => {
    // Using default here because the provider was rejected (the ninja has a level below 20)
    expect(ninjaMaster.rank).to.eql("DefaultNinjaMaster");
});

valueOrDefault(ninjaMasterProvider, { rank: "DefaultNinjaMaster" }).then((ninjaMaster) => {
    // A NinjaMaster was provided because the the ninja has a level above 20
    expect(ninjaMaster.rank).to.eql("NinjaMaster");
    done();
});

[bal1anD]

Any updates on this feature?

[parisholley]

@bal1anD check out #1074