vulcain-corejs/dist/di/resolvers.js

Vulcain micro-service framework

"use strict";
const annotations_1 = require("./annotations");
var BusUsage;
(function (BusUsage) {
    BusUsage[BusUsage["all"] = 0] = "all";
    BusUsage[BusUsage["commandOnly"] = 1] = "commandOnly";
    BusUsage[BusUsage["eventOnly"] = 2] = "eventOnly";
})(BusUsage = exports.BusUsage || (exports.BusUsage = {}));
class InstanceResolver {
    constructor(instance) {
        this.instance = instance;
        this.lifeTime = annotations_1.LifeTime.Singleton;
    }
    resolve(container, name) {
        return this.instance;
    }
}
exports.InstanceResolver = InstanceResolver;
class Resolver {
    constructor(fn, lifeTime, args) {
        this.fn = fn;
        this.lifeTime = lifeTime;
        this.args = args;
    }
    resolve(container, name) {
        let injects;
        try {
            injects = Reflect.getMetadata(Symbol.for("di:injects"), this.fn);
        }
        catch (e) { }
        let params = [];
        if (injects) {
            try {
                for (let inject in injects) {
                    let info = injects[inject];
                    params.push(container.get(info.name, info.optional));
                }
            }
            catch (e) {
                throw new Error(`Error when instanciating component ${name} on injected parameter : ${e.message}`);
            }
        }
        if (this.args) {
            this.args.forEach(a => {
                params.push(a);
            });
        }
        let component = invoke(this.fn, params);
        component._id = Resolver.nb++;
        return component;
    }
}
Resolver.nb = 0;
exports.Resolver = Resolver;
class SingletonResolver extends Resolver {
    constructor(fn, args) {
        super(fn, annotations_1.LifeTime.Singleton, args);
    }
    resolve(container, name, parentContainer) {
        let instance = name && container.scope.getInstance(name);
        if (!instance) {
            instance = super.resolve(container, name);
            // Add instance in the container where the resolver was defined
            if (name && instance)
                parentContainer.scope.set(name, instance);
        }
        return instance;
    }
}
exports.SingletonResolver = SingletonResolver;
class ScopedResolver extends Resolver {
    constructor(fn, args) {
        super(fn, annotations_1.LifeTime.Scoped, args);
    }
    resolve(container, name) {
        let instance = name && container.scope.getInstance(name);
        if (!instance) {
            instance = super.resolve(container, name);
            // Add instance in the current scope
            if (name && instance)
                container.scope.set(name, instance);
        }
        instance.requestContext = container.scope.requestContext;
        return instance;
    }
}
exports.ScopedResolver = ScopedResolver;
function invoke(fn, args) {
    switch (args.length) {
        case 0: return new fn();
        case 1: return new fn(args[0]);
        case 2: return new fn(args[0], args[1]);
        case 3: return new fn(args[0], args[1], args[2]);
        case 4: return new fn(args[0], args[1], args[2], args[3]);
        case 5: return new fn(args[0], args[1], args[2], args[3], args[4]);
        case 6: return new fn(args[0], args[1], args[2], args[3], args[4], args[5]);
        case 7: return new fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
        default:
            return Reflect.construct(fn, args);
    }
}

//# sourceMappingURL=resolvers.js.map