proxydi 0.0.12 → 0.1.0

package/dist/ProxyDI.d.ts

@@ -0,0 +1,27 @@
+import { IProxyDiContainer as IProxyDiContainer, ContainerizedServiceInstance, ServiceInstanced, ServiceClass } from './types';
+import { ProxyDiSettings, ServiceId } from './types';
+export declare class ProxyDiContainer implements IProxyDiContainer {
+    private static idCounter;
+    readonly id: number;
+    readonly parent?: ProxyDiContainer;
+    private children;
+    /**
+     * Holds instances of services registered in particular this container
+     */
+    private serviceInstances;
+    private parentInstanceProxies;
+    private settings;
+    constructor(settings?: ProxyDiSettings, parent?: ProxyDiContainer);
+    registerService<T>(serviceId: ServiceId, instance: ServiceInstanced<T>): void;
+    private registerInstanceImplementation;
+    createService<T>(serviceId: ServiceId, ServiceClass: ServiceClass<T>): void;
+    isKnown(serviceId: ServiceId): boolean;
+    resolve<T>(serviceId: ServiceId): T & ContainerizedServiceInstance;
+    injectDependencies(injectionsOwner: any): void;
+    createChildContainer(): ProxyDiContainer;
+    removeService(serviceId: ServiceId | ContainerizedServiceInstance): void;
+    destroy(): void;
+    private findInstance;
+    private addChild;
+    private removeChild;
+}

package/dist/ProxyDiContainer.d.ts

@@ -1,5 +1,6 @@
 import { IProxyDiContainer as IProxyDiContainer, ContainerizedDependency as ContainerizedDependency, DependencyClass } from './types';
 import { ContainerSettings as ContainerSettings, DependencyId } from './types';
+import { MiddlewareRegistrator, MiddlewareRemover, MiddlewareResolver } from './middleware/middleware.api';
 /**
  * A dependency injection container
  */
@@ -24,18 +25,20 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
     /**
      * Holds proxies for dependencies registered in parent containers to provide for it dependencies from this container
      */
-    private parentDependencyProxies;
+    private inContextProxies;
     /**
      * Settings that control the behavior of the container and it's children
      */
     readonly settings: Required<ContainerSettings>;
-    private middlewareListener;
+    private middlewareManager;
     /**
      * Creates a new instance of ProxyDiContainer.
      * @param settings Optional container settings to override defaults.
      * @param parent Optional parent container.
      */
     constructor(settings?: ContainerSettings, parent?: ProxyDiContainer);
+    registerMiddleware(middleware: MiddlewareRegistrator | MiddlewareRemover | MiddlewareResolver): void;
+    removeMiddleware(middleware: MiddlewareRegistrator | MiddlewareRemover | MiddlewareResolver): void;
     /**
      * Registers a dependency in the container. Could register eacher class or instance.
      * In case of class, it will be instantiated without any parameters.
@@ -45,7 +48,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * @throws Error if dependency is already registered and rewriting is not allowed or if invalid dependency (not object) is provided and this it now allowed.
      * @returns Dependency instance, registered in container
      */
-    register<T>(DependencyClass: DependencyClass<T>, dependencyId: DependencyId): T & ContainerizedDependency;
+    register<T>(DependencyClass: DependencyClass<T>, dependencyId?: DependencyId): T & ContainerizedDependency;
     register<T>(dependency: T extends new (...args: any[]) => any ? never : T, dependencyId: DependencyId): T & ContainerizedDependency;
     private createInstance;
     /**
@@ -62,6 +65,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      */
     resolve<T>(dependencyId: DependencyId): T & ContainerizedDependency;
     resolve<T extends DependencyClass<any>>(SomeClass: T): InstanceType<T> & ContainerizedDependency;
+    private resolveImpl;
     /**
      * Injects dependencies to the given object based on its defined injections metadata. Does not affect the container.
      * @param injectionsOwner The object to inject dependencies into.

package/dist/ProxyFactory.d.ts

@@ -0,0 +1,8 @@
+import { ProxyDI } from './ProxyDI';
+import { ServiceId } from './types';
+export declare class ProxyFactory {
+    private container;
+    constructor(container: ProxyDI);
+    makeProxy<T>(serviceId: ServiceId): T;
+}
+export declare function isProxy(value: any): boolean;

package/dist/__tests__/TestableProxyDiContainer.mock.d.ts

@@ -0,0 +1,5 @@
+import { ProxyDiContainer } from '../ProxyDiContainer';
+export declare class TestableProxyDiContainer extends ProxyDiContainer {
+    getChildren(): any;
+    desreaseIdCounter(): void;
+}

package/dist/__tests__/mock/King.d.ts

@@ -0,0 +1,6 @@
+import { KindomQueen } from './Queen';
+export declare class KindomKing {
+    readonly queen: KindomQueen;
+    readonly name = "I'm a king";
+    constructor(queen: KindomQueen);
+}

package/dist/__tests__/mock/Queen.d.ts

@@ -0,0 +1,6 @@
+import { KindomKing } from './King';
+export declare class KindomQueen {
+    readonly king: KindomKing;
+    readonly name = "I'm a queen";
+    constructor(king: KindomKing);
+}

package/dist/autoInjectable.d.ts

@@ -1,5 +1,5 @@
-import { DependencyClass, DependencyId } from './types';
-export declare const autoInjectableClasses: Record<DependencyId, DependencyClass<any>>;
+import { InstancedDependency, DependencyId } from './types';
+export declare const autoInjectableClasses: Record<DependencyId, InstancedDependency<any>>;
 /**
  * Registers a class as an auto-injectable for dependency injection.
  *
@@ -10,4 +10,4 @@ export declare const autoInjectableClasses: Record<DependencyId, DependencyClass
  * will create an instance of the decorated class. However, if a container already has an instance with that identifier
  * prior to resolution, the decorated class will be ignored by that container.
  */
-export declare const autoInjectable: (dependencyId?: DependencyId) => (value: DependencyClass<any>, context: ClassDecoratorContext) => void;
+export declare const autoInjectable: (dependencyId?: DependencyId) => (value: InstancedDependency<any>, context: ClassDecoratorContext) => void;

package/dist/autoInjectableService.d.ts

@@ -0,0 +1,13 @@
+import { InstancedServiceClass, ServiceId } from './types';
+export declare const autoInjectableServices: Record<ServiceId, InstancedServiceClass<any>>;
+/**
+ * Decorator that registers a class as an auto-injectable service for dependency injection.
+ *
+ * @param serviceId - Optional service identifier. If omitted, the class name is used.
+ * @returns A class decorator function.
+ *
+ * Note: During dependency resolution, any container that does not have an instance for the specified service identifier
+ * will create an instance of the decorated class. However, if a container already has an instance with that identifier
+ * prior to resolution, the decorated class will be ignored by that container.
+ */
+export declare const autoInjectableService: (serviceId?: ServiceId) => (value: InstancedServiceClass<any>, context: ClassDecoratorContext) => void;

package/dist/index.cjs

@@ -1,5 +1,40 @@
 'use strict';
 
+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.
@@ -28,7 +63,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,
@@ -47,41 +86,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,
@@ -128,6 +132,7 @@ const makeInjectionProxy = (injection, injectionOwner, container) => {
         },
     });
 };
+
 function makeDependencyProxy(dependency) {
     const injectionValues = {};
     return new Proxy(dependency, {
@@ -148,18 +153,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 {
@@ -168,20 +164,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();
@@ -204,56 +192,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;
 }
 
 /**
@@ -274,26 +279,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;
@@ -304,15 +346,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) {
@@ -330,37 +377,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.
@@ -420,7 +462,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]
@@ -430,7 +472,11 @@ class ProxyDiContainer {
             });
             delete dependency[DEPENDENCY_ID];
             delete this.dependencies[id];
-            this.middlewareListener.onRemove(this, id);
+            this.middlewareManager.onRemove({
+                container: this,
+                dependencyId: id,
+                dependency,
+            });
         }
     }
     /**

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-export { inject } from './inject';
+export { inject } from './inject.decorator';
 export { ProxyDiContainer } from './ProxyDiContainer';
-export { injectable } from './injectable';
-export { middleware } from './middleware/middleware';
-export { MiddlewareRegisteringListener, MiddlewareRemovingListener, } from './middleware/MiddlewareListener';
+export { injectable } from './injectable.decorator';
+export { middleware } from './middleware/middleware.decorator';
+export { MiddlewareRegistrator, MiddlewareRemover, MiddlewareResolver, } from './middleware/middleware.api';
 export { Injection, DependencyId, DependencyClass, ContainerSettings, PROXYDI_CONTAINER, DEPENDENCY_ID, } from './types';
 export { resolveAll } from './resolveAll';