typedi/ContainerInstance.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Token_1 = require("./Token");
var ServiceNotFoundError_1 = require("./error/ServiceNotFoundError");
var MissingProvidedServiceTypeError_1 = require("./error/MissingProvidedServiceTypeError");
var Container_1 = require("./Container");
/**
 * TypeDI can have multiple containers.
 * One container is ContainerInstance.
 */
var ContainerInstance = /** @class */ (function () {
    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------
    function ContainerInstance(id) {
        // -------------------------------------------------------------------------
        // Private Properties
        // -------------------------------------------------------------------------
        /**
         * All registered services.
         */
        this.services = [];
        this.id = id;
    }
    /**
     * Checks if the service with given name or type is registered service container.
     * Optionally, parameters can be passed in case if instance is initialized in the container for the first time.
     */
    ContainerInstance.prototype.has = function (identifier) {
        return !!this.findService(identifier);
    };
    /**
     * Retrieves the service with given name or type from the service container.
     * Optionally, parameters can be passed in case if instance is initialized in the container for the first time.
     */
    ContainerInstance.prototype.get = function (identifier) {
        var globalContainer = Container_1.Container.of(undefined);
        var service = globalContainer.findService(identifier);
        var scopedService = this.findService(identifier);
        if (service && service.global === true)
            return this.getServiceValue(identifier, service);
        if (scopedService)
            return this.getServiceValue(identifier, scopedService);
        if (service && this !== globalContainer) {
            var clonedService = Object.assign({}, service);
            clonedService.value = undefined;
            var value = this.getServiceValue(identifier, clonedService);
            this.set(identifier, value);
            return value;
        }
        return this.getServiceValue(identifier, service);
    };
    /**
     * Gets all instances registered in the container of the given service identifier.
     * Used when service defined with multiple: true flag.
     */
    ContainerInstance.prototype.getMany = function (id) {
        var _this = this;
        return this.filterServices(id).map(function (service) { return _this.getServiceValue(id, service); });
    };
    /**
     * Sets a value for the given type or service name in the container.
     */
    ContainerInstance.prototype.set = function (identifierOrServiceMetadata, value) {
        var _this = this;
        if (identifierOrServiceMetadata instanceof Array) {
            identifierOrServiceMetadata.forEach(function (v) { return _this.set(v); });
            return this;
        }
        if (typeof identifierOrServiceMetadata === "string" || identifierOrServiceMetadata instanceof Token_1.Token) {
            return this.set({ id: identifierOrServiceMetadata, value: value });
        }
        if (identifierOrServiceMetadata instanceof Function) {
            return this.set({ type: identifierOrServiceMetadata, id: identifierOrServiceMetadata, value: value });
        }
        // const newService: ServiceMetadata<any, any> = arguments.length === 1 && typeof identifierOrServiceMetadata === "object"  && !(identifierOrServiceMetadata instanceof Token) ? identifierOrServiceMetadata : undefined;
        var newService = identifierOrServiceMetadata;
        var service = this.findService(newService.id);
        if (service && service.multiple !== true) {
            Object.assign(service, newService);
        }
        else {
            this.services.push(newService);
        }
        return this;
    };
    /**
     * Removes services with a given service identifiers (tokens or types).
     */
    ContainerInstance.prototype.remove = function () {
        var _this = this;
        var ids = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            ids[_i] = arguments[_i];
        }
        ids.forEach(function (id) {
            _this.filterServices(id).forEach(function (service) {
                _this.services.splice(_this.services.indexOf(service), 1);
            });
        });
        return this;
    };
    /**
     * Completely resets the container by removing all previously registered services from it.
     */
    ContainerInstance.prototype.reset = function () {
        this.services = [];
        return this;
    };
    // -------------------------------------------------------------------------
    // Private Methods
    // -------------------------------------------------------------------------
    /**
     * Filters registered service in the with a given service identifier.
     */
    ContainerInstance.prototype.filterServices = function (identifier) {
        return this.services.filter(function (service) {
            if (service.id)
                return service.id === identifier;
            if (service.type && identifier instanceof Function)
                return service.type === identifier || identifier.prototype instanceof service.type;
            return false;
        });
    };
    /**
     * Finds registered service in the with a given service identifier.
     */
    ContainerInstance.prototype.findService = function (identifier) {
        return this.services.find(function (service) {
            if (service.id)
                return service.id === identifier;
            if (service.type && identifier instanceof Function)
                return service.type === identifier; // todo: not sure why it was here || identifier.prototype instanceof service.type;
            return false;
        });
    };
    /**
     * Gets service value.
     */
    ContainerInstance.prototype.getServiceValue = function (identifier, service) {
        // find if instance of this object already initialized in the container and return it if it is
        if (service && service.value !== null && service.value !== undefined)
            return service.value;
        // if named service was requested and its instance was not found plus there is not type to know what to initialize,
        // this means service was not pre-registered and we throw an exception
        if ((!service || !service.type) &&
            (!service || !service.factory) &&
            (typeof identifier === "string" || identifier instanceof Token_1.Token))
            throw new ServiceNotFoundError_1.ServiceNotFoundError(identifier);
        // at this point we either have type in service registered, either identifier is a target type
        var type = undefined;
        if (service && service.type) {
            type = service.type;
        }
        else if (service && service.id instanceof Function) {
            type = service.id;
        }
        else if (identifier instanceof Function) {
            type = identifier;
        }
        // if service was not found then create a new one and register it
        if (!service) {
            if (!type)
                throw new MissingProvidedServiceTypeError_1.MissingProvidedServiceTypeError(identifier);
            service = { type: type };
            this.services.push(service);
        }
        // setup constructor parameters for a newly initialized service
        var paramTypes = type && Reflect && Reflect.getMetadata ? Reflect.getMetadata("design:paramtypes", type) : undefined;
        var params = paramTypes ? this.initializeParams(type, paramTypes) : [];
        // if factory is set then use it to create service instance
        var value;
        if (service.factory) {
            // filter out non-service parameters from created service constructor
            // non-service parameters can be, lets say Car(name: string, isNew: boolean, engine: Engine)
            // where name and isNew are non-service parameters and engine is a service parameter
            params = params.filter(function (param) { return param !== undefined; });
            if (service.factory instanceof Array) {
                // use special [Type, "create"] syntax to allow factory services
                // in this case Type instance will be obtained from Container and its method "create" will be called
                value = (_a = this.get(service.factory[0]))[service.factory[1]].apply(_a, params);
            }
            else {
                value = service.factory.apply(service, params);
            }
        }
        else {
            if (!type)
                throw new MissingProvidedServiceTypeError_1.MissingProvidedServiceTypeError(identifier);
            params.unshift(null);
            // "extra feature" - always pass container instance as the last argument to the service function
            // this allows us to support javascript where we don't have decorators and emitted metadata about dependencies
            // need to be injected, and user can use provided container to get instances he needs
            params.push(this);
            value = new (type.bind.apply(type, params))();
        }
        if (service && !service.transient && value)
            service.value = value;
        if (type)
            this.applyPropertyHandlers(type, value);
        return value;
        var _a;
    };
    /**
     * Initializes all parameter types for a given target service class.
     */
    ContainerInstance.prototype.initializeParams = function (type, paramTypes) {
        var _this = this;
        return paramTypes.map(function (paramType, index) {
            var paramHandler = Container_1.Container.handlers.find(function (handler) { return handler.object === type && handler.index === index; });
            if (paramHandler)
                return paramHandler.value(_this);
            if (paramType && paramType.name && !_this.isTypePrimitive(paramType.name)) {
                return _this.get(paramType);
            }
            return undefined;
        });
    };
    /**
     * Checks if given type is primitive (e.g. string, boolean, number, object).
     */
    ContainerInstance.prototype.isTypePrimitive = function (param) {
        return ["string", "boolean", "number", "object"].indexOf(param.toLowerCase()) !== -1;
    };
    /**
     * Applies all registered handlers on a given target class.
     */
    ContainerInstance.prototype.applyPropertyHandlers = function (target, instance) {
        var _this = this;
        Container_1.Container.handlers.forEach(function (handler) {
            if (typeof handler.index === "number")
                return;
            if (handler.object.constructor !== target && !(target.prototype instanceof handler.object.constructor))
                return;
            instance[handler.propertyName] = handler.value(_this);
        });
    };
    return ContainerInstance;
}());
exports.ContainerInstance = ContainerInstance;

//# sourceMappingURL=ContainerInstance.js.map