proxydi 0.0.12 → 0.1.0

package/dist/index.js

@@ -1,3 +1,38 @@
+const injectableClasses = {};
+const constructorInjections = {};
+function injectable(dependencyOrDependencies, autoInjecions) {
+    return function (value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+            throw new Error('@injectable decorator should decorate classes');
+        }
+        const name = dependencyOrDependencies
+            ? Array.isArray(dependencyOrDependencies)
+                ? context.name
+                : dependencyOrDependencies
+            : context.name;
+        const injectToConstructor = dependencyOrDependencies
+            ? Array.isArray(dependencyOrDependencies)
+                ? dependencyOrDependencies
+                : autoInjecions
+            : autoInjecions;
+        if (injectableClasses[name]) {
+            throw new Error(`ProxyDi has already regisered dependency ${String(name)} by @injectable`);
+        }
+        injectableClasses[name] = value;
+        if (injectToConstructor) {
+            constructorInjections[name] = injectToConstructor;
+        }
+    };
+}
+function findInjectableId(injectable) {
+    for (const [id, DependencyClass] of Object.entries(injectableClasses)) {
+        if (DependencyClass === injectable) {
+            return id;
+        }
+    }
+    throw new Error(`Class is not @injectable: ${injectable.name}`);
+}
+
 const INJECTIONS = Symbol('injections');
 /**
  * This symbol constant defines a property name.
@@ -26,7 +61,11 @@ const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
 const inject = (dependencyId) => {
     return function (_value, context) {
         if ((context === null || context === undefined ? undefined : context.kind) === 'field') {
-            const id = dependencyId ? dependencyId : context.name;
+            const id = dependencyId
+                ? typeof dependencyId === 'function'
+                    ? findInjectableId(dependencyId)
+                    : dependencyId
+                : context.name;
             const injection = {
                 property: context.name,
                 dependencyId: id,
@@ -45,41 +84,6 @@ const inject = (dependencyId) => {
     };
 };
 
-const injectableClasses = {};
-const constructorInjections = {};
-function injectable(dependencyOrDependencies, autoInjecions) {
-    return function (value, context) {
-        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
-            throw new Error('@injectable decorator should decorate classes');
-        }
-        const name = dependencyOrDependencies
-            ? Array.isArray(dependencyOrDependencies)
-                ? context.name
-                : dependencyOrDependencies
-            : context.name;
-        const injectToConstructor = dependencyOrDependencies
-            ? Array.isArray(dependencyOrDependencies)
-                ? dependencyOrDependencies
-                : autoInjecions
-            : autoInjecions;
-        if (injectableClasses[name]) {
-            throw new Error(`ProxyDi has already regisered dependency ${String(name)} by @injectable`);
-        }
-        injectableClasses[name] = value;
-        if (injectToConstructor) {
-            constructorInjections[name] = injectToConstructor;
-        }
-    };
-}
-function findInjectableId(injectable) {
-    for (const [id, DependencyClass] of Object.entries(injectableClasses)) {
-        if (DependencyClass === injectable) {
-            return id;
-        }
-    }
-    throw new Error(`Class is not @injectable: ${injectable.name}`);
-}
-
 const DEFAULT_SETTINGS = {
     allowRegisterAnything: false,
     allowRewriteDependencies: false,
@@ -126,6 +130,7 @@ const makeInjectionProxy = (injection, injectionOwner, container) => {
         },
     });
 };
+
 function makeDependencyProxy(dependency) {
     const injectionValues = {};
     return new Proxy(dependency, {
@@ -146,18 +151,9 @@ function makeDependencyProxy(dependency) {
 }
 
 function makeConstructorDependencyProxy(container, dependencyId) {
-    // let values: Record<string | symbol, any> = {};
-    // let wasResolved = false;
     function getDependency() {
         if (container.isKnown(dependencyId)) {
             const dependency = container.resolve(dependencyId);
-            // if (!wasResolved) {
-            //     for (const key in values) {
-            //         dependency[key] = values[key];
-            //     }
-            //     values = {};
-            //     wasResolved = true;
-            // }
             return dependency;
         }
         else {
@@ -166,20 +162,12 @@ function makeConstructorDependencyProxy(container, dependencyId) {
     }
     return new Proxy({}, {
         get: function (target, prop, receiver) {
-            // if (values[prop]) {
-            //     return values[prop];
-            // }
             const dependency = getDependency();
             return Reflect.get(dependency, prop, receiver);
         },
         set: function (_target, prop, value) {
-            // if (!container.isKnown(dependencyId)) {
-            //     values[prop] = value;
-            //     return true;
-            // } else {
             const dependency = getDependency();
             return Reflect.set(dependency, prop, value);
-            //}
         },
         has: function (_target, prop) {
             const dependency = getDependency();
@@ -202,56 +190,73 @@ function middleware() {
     };
 }
 
-class MiddlewareListener {
+class MiddlewareManager {
     constructor(parent) {
         this.parent = parent;
-        this.listeners = {
+        this.handlers = {
             register: [],
             remove: [],
+            resolve: [],
         };
     }
     add(middleware) {
-        if (isRegistingMiddleware(middleware)) {
+        if (isRegistrator(middleware)) {
             middleware.onRegister && this.on('register', middleware.onRegister);
         }
-        if (isRemovingMiddleware(middleware)) {
+        if (isRemover(middleware)) {
             middleware.onRemove && this.on('remove', middleware.onRemove);
         }
+        if (isResolver(middleware)) {
+            middleware.onResolve && this.on('resolve', middleware.onResolve);
+        }
     }
     remove(middleware) {
-        if (isRegistingMiddleware(middleware)) {
+        if (isRegistrator(middleware)) {
             middleware.onRegister &&
                 this.off('register', middleware.onRegister);
         }
-        if (isRemovingMiddleware(middleware)) {
+        if (isRemover(middleware)) {
             middleware.onRemove && this.off('remove', middleware.onRemove);
         }
+        if (isResolver(middleware)) {
+            middleware.onResolve && this.off('resolve', middleware.onResolve);
+        }
     }
     on(event, listener) {
-        this.listeners[event].push(listener);
+        this.handlers[event].push(listener);
     }
-    onRegister(container, dependencyId, dependency) {
+    onRegister(context) {
         var _a;
-        this.listeners.register.forEach((listener) => listener(container, dependencyId, dependency));
-        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRegister(container, dependencyId, dependency);
+        this.handlers.register.forEach((listener) => listener(context));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRegister(context);
     }
-    onRemove(container, dependencyId) {
+    onRemove(context) {
         var _a;
-        this.listeners.remove.forEach((listener) => listener(container, dependencyId));
-        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRemove(container, dependencyId);
+        this.handlers.remove.forEach((listener) => listener(context));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRemove(context);
+    }
+    onResolve(context) {
+        let result = context;
+        this.handlers.resolve.forEach((listener) => {
+            result = listener(result);
+        });
+        return result;
     }
     off(event, listener) {
-        const index = this.listeners[event].indexOf(listener);
+        const index = this.handlers[event].indexOf(listener);
         if (index !== -1) {
-            this.listeners[event].splice(index, 1);
+            this.handlers[event].splice(index, 1);
         }
     }
 }
-function isRegistingMiddleware(middleware) {
-    return middleware.onRegister;
+function isRegistrator(middleware) {
+    return !!middleware.onRegister;
 }
-function isRemovingMiddleware(middleware) {
-    return middleware.onRemove;
+function isRemover(middleware) {
+    return !!middleware.onRemove;
+}
+function isResolver(middleware) {
+    return !!middleware.onResolve;
 }
 
 /**
@@ -272,26 +277,63 @@ class ProxyDiContainer {
         /**
          * Holds proxies for dependencies registered in parent containers to provide for it dependencies from this container
          */
-        this.parentDependencyProxies = {};
+        this.inContextProxies = {};
+        this.resolveImpl = (dependencyId) => {
+            const proxy = this.inContextProxies[dependencyId];
+            if (proxy) {
+                return proxy;
+            }
+            const instance = this.findDependency(dependencyId);
+            if (instance) {
+                if (instance[PROXYDI_CONTAINER] !== this &&
+                    typeof instance === 'object' &&
+                    this.settings.resolveInContainerContext) {
+                    const proxy = makeDependencyProxy(instance);
+                    this.injectDependenciesTo(proxy);
+                    this.inContextProxies[dependencyId] = proxy;
+                    return proxy;
+                }
+                return instance;
+            }
+            const InjectableClass = injectableClasses[dependencyId];
+            return this.register(InjectableClass, dependencyId);
+        };
         this.id = ProxyDiContainer.idCounter++;
-        this.middlewareListener = new MiddlewareListener(parent === null || parent === undefined ? undefined : parent.middlewareListener);
+        this.middlewareManager = new MiddlewareManager(parent === null || parent === undefined ? undefined : parent.middlewareManager);
         if (parent) {
             this.parent = parent;
             this.parent.addChild(this);
         }
         this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
     }
-    register(dependency, dependencyId) {
+    registerMiddleware(middleware) {
+        this.middlewareManager.add(middleware);
+    }
+    removeMiddleware(middleware) {
+        this.middlewareManager.remove(middleware);
+    }
+    register(dependency, dependecyId) {
         var _a;
-        if (this.dependencies[dependencyId]) {
+        let id = dependecyId;
+        if (!id) {
+            if (typeof dependency === 'function') {
+                try {
+                    id = findInjectableId(dependency);
+                }
+                catch (_b) {
+                    id = dependency.name;
+                }
+            }
+        }
+        if (this.dependencies[id]) {
             if (!this.settings.allowRewriteDependencies) {
-                throw new Error(`ProxyDi already has dependency for ${String(dependencyId)}`);
+                throw new Error(`ProxyDi already has dependency for ${String(id)}`);
             }
         }
         let instance;
         const isClass = typeof dependency === 'function';
         if (isClass) {
-            instance = this.createInstance(dependency, dependencyId);
+            instance = this.createInstance(dependency, id);
         }
         else {
             instance = dependency;
@@ -302,15 +344,20 @@ class ProxyDiContainer {
         }
         if (isObject) {
             instance[PROXYDI_CONTAINER] = this;
-            instance[DEPENDENCY_ID] = dependencyId;
+            instance[DEPENDENCY_ID] = id;
         }
         this.injectDependenciesTo(instance);
-        this.dependencies[dependencyId] = instance;
+        this.dependencies[id] = instance;
         const constructorName = (_a = instance.constructor) === null || _a === undefined ? undefined : _a.name;
         if (constructorName && middlewaresClasses[constructorName]) {
-            this.middlewareListener.add(instance);
+            this.middlewareManager.add(instance);
         }
-        this.middlewareListener.onRegister(this, dependencyId, instance);
+        let context = {
+            container: this,
+            dependencyId: id,
+            dependency: instance,
+        };
+        this.middlewareManager.onRegister(context);
         return instance;
     }
     createInstance(Dependency, dependencyId) {
@@ -328,37 +375,32 @@ class ProxyDiContainer {
      * @returns True if the dependency is known, false otherwise.
      */
     isKnown(dependencyId) {
-        return !!(this.parentDependencyProxies[dependencyId] ||
+        return !!(this.inContextProxies[dependencyId] ||
             this.dependencies[dependencyId] ||
             (this.parent && this.parent.isKnown(dependencyId)) ||
             injectableClasses[dependencyId]);
     }
     resolve(dependency) {
         if (typeof dependency === 'function') {
-            const id = findInjectableId(dependency);
+            let id;
+            try {
+                id = findInjectableId(dependency);
+            }
+            catch (_a) {
+                id = dependency.name;
+            }
             return this.resolve(id);
         }
         if (!this.isKnown(dependency)) {
             throw new Error(`Can't resolve unknown dependency: ${String(dependency)}`);
         }
-        const proxy = this.parentDependencyProxies[dependency];
-        if (proxy) {
-            return proxy;
-        }
-        const instance = this.findDependency(dependency);
-        if (instance) {
-            if (instance[PROXYDI_CONTAINER] !== this &&
-                typeof instance === 'object' &&
-                this.settings.resolveInContainerContext) {
-                const proxy = makeDependencyProxy(instance);
-                this.injectDependenciesTo(proxy);
-                this.parentDependencyProxies[dependency] = proxy;
-                return proxy;
-            }
-            return instance;
-        }
-        const InjectableClass = injectableClasses[dependency];
-        return this.register(InjectableClass, dependency);
+        let context = {
+            container: this,
+            dependencyId: dependency,
+            dependency: this.resolveImpl(dependency),
+        };
+        context = this.middlewareManager.onResolve(context);
+        return context.dependency;
     }
     /**
      * Injects dependencies to the given object based on its defined injections metadata. Does not affect the container.
@@ -418,7 +460,7 @@ class ProxyDiContainer {
         if (dependency) {
             const constructorName = (_a = dependency.constructor) === null || _a === undefined ? undefined : _a.name;
             if (constructorName && middlewaresClasses[constructorName]) {
-                this.middlewareListener.remove(dependency);
+                this.middlewareManager.remove(dependency);
             }
             const dependencyInjects = dependency[INJECTIONS]
                 ? dependency[INJECTIONS]
@@ -428,7 +470,11 @@ class ProxyDiContainer {
             });
             delete dependency[DEPENDENCY_ID];
             delete this.dependencies[id];
-            this.middlewareListener.onRemove(this, id);
+            this.middlewareManager.onRemove({
+                container: this,
+                dependencyId: id,
+                dependency,
+            });
         }
     }
     /**