@spinajs/di 1.1.7 → 1.2.20

package/lib/container.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = void 0;
 const exceptions_1 = require("@spinajs/exceptions");
-const _ = require("lodash");
 require("reflect-metadata");
 const array_1 = require("./array");
 const decorators_1 = require("./decorators");
@@ -10,17 +9,18 @@ const enums_1 = require("./enums");
 const helpers_1 = require("./helpers");
 const interfaces_1 = require("./interfaces");
 const events_1 = require("events");
-const exceptions_2 = require("./exceptions");
+const binder_1 = require("./binder");
+const registry_1 = require("./registry");
+const container_cache_1 = require("./container-cache");
 /**
  * Dependency injection container implementation
  */
 class Container extends events_1.EventEmitter {
     constructor(parent) {
         super();
-        this.registry = new Map();
-        this.cache = new Map();
+        this.registry = new registry_1.Registry(this);
+        this.cache = new container_cache_1.ContainerCache(this);
         this.parent = parent || undefined;
-        this.registerSelf();
     }
     /**
      * Returns container cache - map object with resolved classes as singletons
@@ -31,6 +31,9 @@ class Container extends events_1.EventEmitter {
     get Registry() {
         return this.registry;
     }
+    get Parent() {
+        return this.parent;
+    }
     /**
      * Clears container registry and cache. shorthand for container.clearCache() && container.clearRegistry()
      */
@@ -42,54 +45,23 @@ class Container extends events_1.EventEmitter {
      */
     clearCache() {
         this.cache.clear();
-        this.cache = new Map();
     }
     /**
      * Clears container resolved types
      */
     clearRegistry() {
-        this.registry.clear();
-        this.registerSelf();
+        this.Registry.clear();
     }
     /**
      * Register class/interface to DI.
      * @param type - interface object to register
-     * @throws { InvalidArgument } if type is null or undefined
+     * @throws {@link InvalidArgument} if type is null or undefined
      */
     register(implementation) {
-        if (_.isNil(implementation)) {
+        if (!implementation) {
             throw new exceptions_1.InvalidArgument('argument `type` cannot be null or undefined');
         }
-        const self = this;
-        return {
-            _impl: null,
-            as(type) {
-                this._impl = implementation;
-                const tname = typeof type === 'string' ? type : type.name;
-                if (!self._hasRegisteredType(tname, implementation)) {
-                    if (self.registry.has(tname)) {
-                        self.registry.get(tname).push(implementation);
-                    }
-                    else {
-                        self.registry.set(tname, [implementation]);
-                    }
-                }
-                return this;
-            },
-            asSelf() {
-                this._impl = implementation;
-                self.registry.set(implementation.name, [implementation]);
-                return this;
-            },
-            singleInstance() {
-                const descriptor = {
-                    inject: [],
-                    resolver: enums_1.ResolveType.Singleton,
-                };
-                this._impl[decorators_1.DI_DESCRIPTION_SYMBOL] = descriptor;
-                return this;
-            },
-        };
+        return new binder_1.Binder(implementation, this);
     }
     /**
      * Creates child DI container.
@@ -99,294 +71,276 @@ class Container extends events_1.EventEmitter {
         return new Container(this);
     }
     get(service, parent = true) {
-        const self = this;
-        const identifier = typeof service === 'string'
-            ? this.Registry.get(service) || service
-            : service instanceof array_1.TypedArray
-                ? this.Registry.get(service.Type.name)
-                : this.Registry.get(service.name) || service.name;
-        if (!identifier) {
-            return null;
-        }
-        if (typeof identifier === 'string') {
-            return _get(identifier);
-        }
-        /**
-         * When we try to get type by factory func, always return null
-         * It's technically an arror becouse factory func in in charge now
-         * of managing intances of created objects (eg. creating cache)
-         *
-         * We do not track of any instances created by factory funcions.
-         */
-        const isFactory = !(0, helpers_1.isConstructor)(identifier[identifier.length - 1]) && _.isFunction(identifier[identifier.length - 1]);
-        if (isFactory) {
-            return null;
-        }
+        // get value registered as TypedArray ( mean to return all created instances )
         if (service instanceof array_1.TypedArray) {
-            return identifier.map(t => _get(t.name));
-        }
-        return _get(identifier[identifier.length - 1].name);
-        function _get(i) {
-            if (self.cache.has(i)) {
-                return self.cache.get(i);
-            }
-            else if (self.parent && parent) {
-                return self.parent.get(i, parent);
-            }
-            return null;
-        }
-    }
-    getRegistered(service, parent = true) {
-        if (!service) {
-            throw new exceptions_1.InvalidArgument('argument "service" cannot be null or empty');
-        }
-        const name = typeof service === 'string' ? service : service.constructor.name;
-        if (this.registry.has(name)) {
-            return this.registry.get(name);
-        }
-        if (this.parent && parent) {
-            return this.parent.getRegistered(service, parent);
+            return this.cache.get((0, helpers_1.getTypeName)(service.Type));
         }
-        return null;
+        const r = this.cache.get(service, parent);
+        return r[r.length - 1];
     }
     hasRegistered(service, parent = true) {
-        if (this.registry.has(typeof service === 'string' ? service : service.name)) {
-            return true;
-        }
-        else if (this.parent && parent) {
-            return this.parent.hasRegistered(service);
-        }
-        return false;
+        return this.Registry.hasRegistered(service, parent);
     }
     /**
      * Checks if service is already resolved and exists in container cache.
      * NOTE: check is only valid for classes that are singletons.
      *
      * @param service - service name or class to check
-     * @returns { boolean } - true if service instance already exists, otherwise false.
-     * @throws { InvalidArgument } when service is null or empty
+     * @returns true if service instance already exists, otherwise false.
+     * @throws {@link InvalidArgument} when service is null or empty
      */
-    has(service, parent = true) {
-        if (!service) {
-            throw new exceptions_1.InvalidArgument('argument cannot be null or empty');
-        }
-        const name = typeof service === 'string' ? service : service.name;
-        if (this.cache.has(name)) {
-            return true;
-        }
-        if (this.parent && parent) {
-            return this.parent.has(name);
-        }
-        return false;
+    isResolved(service, parent = true) {
+        return this.Cache.has(service, parent);
     }
     /**
      *
-     * @param type type to resolve
-     * @param options options passed to constructor / factory
-     * @param check strict check if serivice is registered in container before resolving. Default behavior is to not check and resolve
+     * @param type - type to resolve
+     * @param options - options passed to constructor / factory
+     * @param check - strict check if serivice is registered in container before resolving. Default behavior is to not check and resolve
      */
     resolve(type, options, check) {
-        const sourceType = type instanceof array_1.TypedArray ? type.Type : type;
-        if (_.isNil(type)) {
+        if (!type) {
             throw new exceptions_1.InvalidArgument('argument `type` cannot be null or undefined');
         }
-        if ((typeof options === 'boolean' && options === true) || check === true) {
-            if (!this.hasRegistered(typeof sourceType === 'string' ? sourceType : sourceType.name)) {
-                throw new Error(`Type ${sourceType} is not registered at container`);
-            }
-        }
+        const sourceType = type instanceof array_1.TypedArray ? type.Type : type;
+        const sourceName = (0, helpers_1.getTypeName)(type);
         const opt = typeof options === 'boolean' ? null : options;
-        const isArray = type.constructor.name === 'TypedArray';
-        const targetType = isArray
-            ? this.getRegistered(type.Type.name) || [type.Type]
-            : typeof type === 'string'
-                ? this.getRegistered(type)
-                : this.getRegistered(type.name) || [type];
-        if (!targetType) {
-            throw new Error(`cannot resolve type ${type} becouse is not registered in container`);
-        }
-        if (typeof sourceType === 'string') {
-            return this.resolveType(sourceType, targetType[targetType.length - 1], opt);
+        const setCache = (r) => {
+            this.Cache.add(type, r);
+            return r;
+        };
+        const emit = (target) => {
+            // firs event to emit that particular type was resolved
+            this.emit(`di.resolved.${(0, helpers_1.getTypeName)(target)}`, this, target);
+            // emit that source type was resolved
+            this.emit(`di.resolved.${sourceName}`, this, target);
+        };
+        if (options === true || check === true) {
+            if (!this.hasRegistered(sourceType)) {
+                throw new Error(`Type ${sourceName} is not registered at container`);
+            }
         }
-        if (isArray) {
-            const resolved = targetType.map(r => this.resolveArrayType(sourceType, r, opt));
-            if (resolved.some(r => r instanceof Promise)) {
-                return Promise.all(resolved);
+        if ((0, helpers_1.isTypedArray)(type)) {
+            // special case for arrays
+            // if we have in cache, retunr all we got
+            // TODO: fix this and every time check if theres is any
+            // new registerd type
+            if (this.Cache.has(type)) {
+                return this.Cache.get(type);
+            }
+            // if its array type, resolve all registered types or throw exception
+            const targetType = this.getRegisteredTypes(type);
+            if (!targetType) {
+                return [];
             }
+            const resolved = targetType.map((r) => this.resolveType(type, r, opt));
+            if (resolved.some((r) => r instanceof Promise)) {
+                return Promise.all(resolved).then((value) => {
+                    value.forEach((v) => {
+                        setCache(v);
+                        emit(v);
+                    });
+                    return value;
+                });
+            }
+            // special case, we dont want to cache multiple times
+            resolved.forEach((v) => {
+                setCache(v);
+                emit(v);
+            });
             return resolved;
         }
-        return this.resolveType(sourceType, targetType[targetType.length - 1], opt);
-    }
-    resolveArrayType(sourceType, targetType, options) {
-        const tname = typeof sourceType === 'string' ? sourceType : sourceType.name;
-        if (!this.Registry.has(tname)) {
-            throw new exceptions_2.ResolveException(`Cannot resolve array of type ${tname}, no types are registered in container.`);
+        else {
+            // finaly resolve single type:
+            // 1. last registered type OR
+            // 2. if non is registered - type itself
+            let targetType = this.getRegisteredTypes(type);
+            if (!targetType) {
+                // if nothing is register under string identifier, then return null
+                if (typeof type === 'string') {
+                    return null;
+                }
+                else {
+                    targetType = [type];
+                }
+            }
+            // resolve last registered type ( newest )
+            const rValue = this.resolveType(sourceType, targetType[targetType.length - 1], opt);
+            if ((0, helpers_1.isPromise)(rValue)) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                return rValue.then((v) => {
+                    setCache(v);
+                    emit(v);
+                    return v;
+                });
+            }
+            setCache(rValue);
+            emit(rValue);
+            return rValue;
         }
-        return this.resolveType(sourceType, targetType, options);
+    }
+    getRegisteredTypes(service, parent) {
+        return this.Registry.getTypes(service, parent);
     }
     resolveType(sourceType, targetType, options) {
-        const self = this;
-        const descriptor = _extractDescriptor(targetType);
-        const isFactory = !(0, helpers_1.isConstructor)(targetType) && _.isFunction(targetType);
         /**
          * If its a factory func, always resolve as new instance
          */
-        if (isFactory) {
-            return _getNewInstance(targetType);
-        }
+        if ((0, helpers_1.isFactory)(targetType)) {
+            return this.getNewInstance(targetType, null, options);
+        }
+        // we now know its not factory func
+        // but typescript complains about this
+        // becouse isFactory is custom type check
+        const tType = targetType;
+        const sName = (0, helpers_1.getTypeName)(sourceType);
+        const descriptor = this.extractDescriptor(tType);
+        // check if is singleton,
+        // resolving strategy per container is treatead as singleton
+        // in this particular container
+        const isSingletonInChild = descriptor.resolver === enums_1.ResolveType.PerChildContainer;
+        const isSingleton = descriptor.resolver === enums_1.ResolveType.Singleton;
+        const getCachedInstance = (e, parent) => {
+            if (this.isResolved(e, parent)) {
+                return this.get(e, parent);
+            }
+            return null;
+        };
+        const resolve = (d, t, i) => {
+            if (d.resolver === enums_1.ResolveType.NewInstance) {
+                return this.getNewInstance(t, i, options);
+            }
+            this.Registry.register(sName, t);
+            return getCachedInstance(tType, d.resolver === enums_1.ResolveType.Singleton ? true : false) || this.getNewInstance(t, i, options);
+        };
         // check cache if needed
-        if (descriptor.resolver === enums_1.ResolveType.Singleton || descriptor.resolver === enums_1.ResolveType.PerChildContainer) {
-            if (this.has(targetType, descriptor.resolver === enums_1.ResolveType.Singleton)) {
-                return this.get(targetType);
+        if (isSingletonInChild || isSingleton) {
+            // if its singleton ( not per child container )
+            // check also in parent containers
+            // ------- IMPORTANT ------------
+            // TODO: in future allow to check in runtime if target type is cashed,
+            // now, if for example we resolve array of some type,
+            // when we later register another type of base class used in typed array
+            // we will not resolve it, becaouse contaienr will not check
+            // if in cache this new type exists ( only check if type in array exists )
+            const cached = getCachedInstance(sourceType, isSingleton);
+            if (cached) {
+                return cached;
             }
         }
-        const deps = _resolveDeps(descriptor.inject);
+        const deps = this.resolveDependencies(descriptor.inject);
         if (deps instanceof Promise) {
-            return deps
-                .then(resolvedDependencies => {
-                return _resolve(descriptor, targetType, resolvedDependencies);
-            }).then(_setCache);
+            return deps.then((resolvedDependencies) => {
+                return resolve(descriptor, tType, resolvedDependencies);
+            });
         }
         else {
-            const resInstance = _resolve(descriptor, targetType, deps);
+            const resInstance = resolve(descriptor, tType, deps);
             if (resInstance instanceof Promise) {
-                return resInstance.then(_setCache);
+                return resInstance;
             }
-            _setCache(resInstance);
             return resInstance;
         }
-        function _getNameOfResolvedType() {
-            return targetType.name;
-        }
-        function _setCache(r) {
-            const checkParent = descriptor.resolver === enums_1.ResolveType.Singleton;
-            const toCheck = _getNameOfResolvedType();
-            if (!self.has(toCheck, checkParent)) {
-                self.Cache.set(toCheck, r);
-            }
-            return r;
+    }
+    getNewInstance(typeToCreate, a, options) {
+        let args = [null];
+        let newInstance = null;
+        /**
+         * If type is not Constructable, we assume its factory function,
+         * just call it with `this` container.
+         */
+        if ((0, helpers_1.isFactory)(typeToCreate)) {
+            newInstance = typeToCreate(this, ...(options !== null && options !== void 0 ? options : []));
         }
-        function _resolve(d, t, i) {
-            const tname = typeof sourceType === 'string' ? sourceType : sourceType.name;
-            if (d.resolver === enums_1.ResolveType.NewInstance) {
-                return _getNewInstance(t, i);
+        else {
+            if (a.constructor.name === 'Array') {
+                args = args.concat(a.filter((i) => !i.autoinject).map((i) => i.instance));
             }
-            if (!self.Registry.has(tname)) {
-                self.Registry.set(tname, [t]);
+            if (options && options.length !== 0) {
+                args = args.concat(options);
             }
-            else {
-                if (!self._hasRegisteredType(sourceType, t)) {
-                    self.Registry.set(tname, self.Registry.get(tname).concat(t));
-                }
+            /* eslint-disable */
+            newInstance = new (Function.prototype.bind.apply(typeToCreate, args))();
+            for (const ai of a.filter((i) => i.autoinject)) {
+                // TYPE HACK to tell typescript we dont care type
+                /* eslint-disable */
+                newInstance[`${ai.autoinjectKey}`] = ai.instance;
             }
-            return (_getCachedInstance(targetType, d.resolver === enums_1.ResolveType.Singleton ? true : false) || _getNewInstance(t, i));
-        }
-        function _extractDescriptor(type) {
-            const descriptor = {
-                inject: [],
-                resolver: enums_1.ResolveType.Singleton,
-            };
-            reduce(type);
-            descriptor.inject = _.uniqWith(descriptor.inject, (a, b) => {
-                return a.inject.name === b.inject.name;
-            });
-            return descriptor;
-            function reduce(t) {
-                if (!t) {
-                    return;
-                }
-                reduce(t.prototype);
-                reduce(t.__proto__);
-                if (t[decorators_1.DI_DESCRIPTION_SYMBOL]) {
-                    descriptor.inject = descriptor.inject.concat(t[decorators_1.DI_DESCRIPTION_SYMBOL].inject);
-                    descriptor.resolver = t[decorators_1.DI_DESCRIPTION_SYMBOL].resolver;
-                }
+            if ((0, helpers_1.isAsyncModule)(newInstance)) {
+                return new Promise((res, rej) => {
+                    newInstance
+                        .resolveAsync()
+                        .then(() => { })
+                        .then(() => {
+                        res(newInstance);
+                    })
+                        .catch((err) => rej(err));
+                });
             }
-        }
-        function _resolveDeps(toInject) {
-            const dependencies = toInject.map(t => {
-                const promiseOrVal = self.resolve(t.inject);
-                if (promiseOrVal instanceof Promise) {
-                    return new Promise((res, _) => {
-                        res(promiseOrVal);
-                    }).then((val) => {
-                        return {
-                            autoinject: t.autoinject,
-                            autoinjectKey: t.autoinjectKey,
-                            instance: val,
-                        };
-                    });
+            else {
+                if (newInstance instanceof interfaces_1.SyncModule) {
+                    newInstance.resolve();
                 }
-                return {
-                    autoinject: t.autoinject,
-                    autoinjectKey: t.autoinjectKey,
-                    instance: promiseOrVal,
-                };
-            });
-            if (dependencies.some(p => p instanceof Promise)) {
-                return Promise.all(dependencies);
             }
-            return dependencies;
         }
-        function _getCachedInstance(e, parent) {
-            if (self.has(e, parent)) {
-                return self.get(e, parent);
+        return newInstance;
+    }
+    hasRegisteredType(source, type, parent) {
+        return this.Registry.hasRegisteredType(source, type, parent);
+    }
+    resolveDependencies(toInject) {
+        const dependencies = toInject.map((t) => {
+            const promiseOrVal = this.resolve(t.inject);
+            if (promiseOrVal instanceof Promise) {
+                return new Promise((res, _) => {
+                    res(promiseOrVal);
+                }).then((val) => {
+                    return {
+                        autoinject: t.autoinject,
+                        autoinjectKey: t.autoinjectKey,
+                        instance: val,
+                    };
+                });
             }
-            return null;
+            return {
+                autoinject: t.autoinject,
+                autoinjectKey: t.autoinjectKey,
+                instance: promiseOrVal,
+            };
+        });
+        if (dependencies.some((p) => p instanceof Promise)) {
+            return Promise.all(dependencies);
         }
-        function _getNewInstance(typeToCreate, a) {
-            let args = [null];
-            let newInstance = null;
-            /**
-             * If type is not Constructable, we assume its factory function,
-             * just call it with `this` container.
-             */
-            if (!(0, helpers_1.isConstructor)(typeToCreate) && _.isFunction(typeToCreate)) {
-                newInstance = typeToCreate(self, ...[].concat(options));
+        return dependencies;
+    }
+    extractDescriptor(type) {
+        const descriptor = {
+            inject: [],
+            resolver: enums_1.ResolveType.Singleton,
+        };
+        reduce(type);
+        descriptor.inject = (0, helpers_1.uniqBy)(descriptor.inject, (a, b) => {
+            if (a.inject instanceof array_1.TypedArray && b.inject instanceof array_1.TypedArray) {
+                return (0, helpers_1.getTypeName)(a.inject.Type) === (0, helpers_1.getTypeName)(b.inject.Type);
             }
             else {
-                if (_.isArray(a)) {
-                    args = args.concat(a.filter(i => !i.autoinject).map(i => i.instance));
-                }
-                if (!_.isEmpty(options)) {
-                    args = args.concat(options);
-                }
-                newInstance = new (Function.prototype.bind.apply(typeToCreate, args))();
-                for (const ai of a.filter(i => i.autoinject)) {
-                    newInstance[ai.autoinjectKey] = ai.instance;
-                }
-                if (newInstance instanceof interfaces_1.AsyncModule) {
-                    return new Promise(res => {
-                        newInstance.resolveAsync(self).then(() => {
-                            self.emit(`di.resolved.${_getNameOfResolvedType()}`);
-                        }).then(() => {
-                            res(newInstance);
-                        });
-                    });
-                }
-                else {
-                    if (newInstance instanceof interfaces_1.SyncModule) {
-                        newInstance.resolve(self);
-                    }
-                    self.emit(`di.resolved.${_getNameOfResolvedType()}`);
+                return a.inject.name === b.inject.name;
+            }
+        });
+        return descriptor;
+        function reduce(t) {
+            if (t) {
+                // for descriptors defined on class declarations
+                reduce(t.prototype);
+                // for descriptors defined on class properties eg. @Autoinject()
+                reduce(t.__proto__);
+                if (t[`${decorators_1.DI_DESCRIPTION_SYMBOL}`]) {
+                    descriptor.inject = descriptor.inject.concat(t[`${decorators_1.DI_DESCRIPTION_SYMBOL}`].inject);
+                    descriptor.resolver = t[`${decorators_1.DI_DESCRIPTION_SYMBOL}`].resolver;
                 }
             }
-            return newInstance;
         }
     }
-    _hasRegisteredType(source, type) {
-        const sourceName = typeof source === 'string' ? source : source.name;
-        const targetName = typeof type === 'string' ? type : type.name;
-        if (this.registry.has(sourceName)) {
-            return this.registry.get(sourceName).find(s => s.name === targetName) !== undefined;
-        }
-        return false;
-    }
-    //
-    // allows container instance to be resolved
-    registerSelf() {
-        this.cache.set('Container', this);
-    }
 }
 exports.Container = Container;
 //# sourceMappingURL=container.js.map