proxydi 0.0.9 → 0.0.10

package/README.md

@@ -12,9 +12,12 @@ Core features:
 - Automatically resolves circular dependencies with no performance impact
 - Resolves dependencies in the context of a particular container
 - Supports hierarchical containers with the ability to resolve dependencies in both directions
-- Matches dependencies by unique identifiers or automatically using class names and property names
 - Currently under active development, the API may change until version 0.1.0
 
+Eperimemntal features:
+- Construtor injections (see unit tests for examples)
+- Matches dependencies by unique identifiers or automatically using class names and property names
+
 ## Quick start
 
 > If you are using React, you should use the React wrapper for ProxyDi instead of this library directly: [@proxydi/react](https://github.com/proxy-di/proxydi-react)
@@ -218,7 +221,7 @@ class UnderwaterShield {
 
 In this example, the shield perk increases character health if it is underwater. The perk receives both level and character using the @inject() decorator, the same way as we have seen so far.
 
-## Resolving dependencies from children
+### Resolving dependencies from children
 
 Backward bonus of containers hierarchy, each top level dependency is free to use all dependency from the bottom:
 

package/dist/ProxyDiContainer.d.ts

@@ -46,6 +46,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      */
     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;
     /**
      * Internal method that implements registeration of dependency and prepare it for injection.
      * @param dependencyId The unique identifier of the dependency.
@@ -65,7 +66,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * @throws Error if the dependency cannot be found or is not auto injectable.
      */
     resolve<T>(dependencyId: DependencyId): T & ContainerizedDependency;
-    resolve<T extends new (...args: any[]) => any>(SomeClass: T): InstanceType<T> & ContainerizedDependency;
+    resolve<T extends DependencyClass<any>>(SomeClass: T): InstanceType<T> & ContainerizedDependency;
     /**
      * 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/index.cjs

@@ -1,10 +1,20 @@
 'use strict';
 
 const INJECTIONS = Symbol('injections');
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores the dependency identifier that should be used to resolve dependency from the container where it was registered.
+ */
 const DEPENDENCY_ID = Symbol('DependencyId');
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores a reference to the ProxyDiContainer in which the dependency was registered.
+ */
+const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
 const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
 const INJECTION_OWNER = Symbol('injectionOwner');
-const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
 const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
 
 /**
@@ -37,31 +47,40 @@ const inject = (dependencyId) => {
     };
 };
 
-const autoInjectableClasses = {};
-/**
- * Registers a class as an auto-injectable for dependency injection.
- *
- * @param dependencyId - Optional dependency 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 dependency 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.
- */
-const autoInjectable = (dependencyId) => {
+const injectableClasses = {};
+const constructorInjections = {};
+function injectable(dependencyOrDependencies, autoInjecions) {
     return function (value, context) {
-        if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
-            const name = dependencyId ? dependencyId : context.name;
-            if (autoInjectableClasses[name]) {
-                throw new Error(`ProxyDi autoInjectable already has dependency ID: ${String(name)}`);
-            }
-            autoInjectableClasses[name] = value;
+        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+            throw new Error('@injectable decorator should decorate classes');
         }
-        else {
-            throw new Error('@autoInjectable 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,
@@ -128,6 +147,49 @@ 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 {
+            throw new Error(`Unknown dependency: ${String(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();
+            return Reflect.has(dependency, prop);
+        },
+    });
+}
+
 /**
  * A dependency injection container
  */
@@ -163,7 +225,7 @@ class ProxyDiContainer {
         let dependencyInstance;
         const isClass = typeof dependency === 'function';
         if (isClass) {
-            dependencyInstance = new dependency();
+            dependencyInstance = this.createInstance(dependency, dependencyId);
         }
         else {
             dependencyInstance = dependency;
@@ -178,6 +240,15 @@ class ProxyDiContainer {
         this.registerImpl(dependencyInstance, dependencyId);
         return dependencyInstance;
     }
+    createInstance(Dependency, dependencyId) {
+        const paramIds = constructorInjections[dependencyId] || [];
+        const params = [];
+        for (const id of paramIds) {
+            const param = makeConstructorDependencyProxy(this, id);
+            params.push(param);
+        }
+        return new Dependency(...params);
+    }
     /**
      * Internal method that implements registeration of dependency and prepare it for injection.
      * @param dependencyId The unique identifier of the dependency.
@@ -199,39 +270,34 @@ class ProxyDiContainer {
         return !!(this.parentDependencyProxies[dependencyId] ||
             this.dependencies[dependencyId] ||
             (this.parent && this.parent.isKnown(dependencyId)) ||
-            autoInjectableClasses[dependencyId]);
+            injectableClasses[dependencyId]);
     }
-    resolve(param) {
-        if (typeof param === 'function') {
-            for (const [dependencyId, DependencyClass] of Object.entries(autoInjectableClasses)) {
-                if (DependencyClass === param) {
-                    return this.resolve(dependencyId);
-                }
-            }
-            throw new Error(`Class is not auto injectable: ${param.name}`);
+    resolve(dependency) {
+        if (typeof dependency === 'function') {
+            const id = findInjectableId(dependency);
+            return this.resolve(id);
         }
-        if (!this.isKnown(param)) {
-            throw new Error(`Can't resolve unknown dependency: ${String(param)}`);
+        if (!this.isKnown(dependency)) {
+            throw new Error(`Can't resolve unknown dependency: ${String(dependency)}`);
         }
-        const proxy = this.parentDependencyProxies[param];
+        const proxy = this.parentDependencyProxies[dependency];
         if (proxy) {
             return proxy;
         }
-        const dependency = this.findDependency(param);
-        if (dependency) {
-            if (dependency[PROXYDY_CONTAINER] !== this &&
-                typeof dependency === 'object' &&
+        const instance = this.findDependency(dependency);
+        if (instance) {
+            if (instance[PROXYDY_CONTAINER] !== this &&
+                typeof instance === 'object' &&
                 this.settings.resolveInContainerContext) {
-                const proxy = makeDependencyProxy(dependency);
+                const proxy = makeDependencyProxy(instance);
                 this.injectDependenciesTo(proxy);
-                this.parentDependencyProxies[param] = proxy;
+                this.parentDependencyProxies[dependency] = proxy;
                 return proxy;
             }
-            return dependency;
+            return instance;
         }
-        const AutoInjectableClass = autoInjectableClasses[param];
-        const autoDependency = new AutoInjectableClass();
-        return this.register(autoDependency, param);
+        const InjectableClass = injectableClasses[dependency];
+        return this.register(InjectableClass, dependency);
     }
     /**
      * Injects dependencies to the given object based on its defined injections metadata. Does not affect the container.
@@ -376,12 +442,8 @@ function isDependency(dependencyOrId) {
 
 function resolveAll(instance, dependencyId) {
     if (typeof dependencyId === 'function') {
-        for (const [id, DependencyClass] of Object.entries(autoInjectableClasses)) {
-            if (DependencyClass === dependencyId) {
-                return resolveAll(instance, id);
-            }
-        }
-        throw new Error(`Class is not auto injectable: ${dependencyId.name}`);
+        const id = findInjectableId(dependencyId);
+        return resolveAll(instance, id);
     }
     const container = instance[PROXYDY_CONTAINER];
     if (!container) {
@@ -403,6 +465,6 @@ function recursiveResolveAll(container, dependencyId) {
 exports.DEPENDENCY_ID = DEPENDENCY_ID;
 exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
 exports.ProxyDiContainer = ProxyDiContainer;
-exports.autoInjectable = autoInjectable;
 exports.inject = inject;
+exports.injectable = injectable;
 exports.resolveAll = resolveAll;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { inject } from './inject';
 export { ProxyDiContainer } from './ProxyDiContainer';
-export { autoInjectable } from './autoInjectable';
+export { injectable } from './injectable';
 export { Injection, DependencyId, DependencyClass, ContainerSettings, PROXYDY_CONTAINER, DEPENDENCY_ID, } from './types';
 export { resolveAll } from './resolveAll';

package/dist/index.js

@@ -1,8 +1,18 @@
 const INJECTIONS = Symbol('injections');
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores the dependency identifier that should be used to resolve dependency from the container where it was registered.
+ */
 const DEPENDENCY_ID = Symbol('DependencyId');
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores a reference to the ProxyDiContainer in which the dependency was registered.
+ */
+const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
 const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
 const INJECTION_OWNER = Symbol('injectionOwner');
-const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
 const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
 
 /**
@@ -35,31 +45,40 @@ const inject = (dependencyId) => {
     };
 };
 
-const autoInjectableClasses = {};
-/**
- * Registers a class as an auto-injectable for dependency injection.
- *
- * @param dependencyId - Optional dependency 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 dependency 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.
- */
-const autoInjectable = (dependencyId) => {
+const injectableClasses = {};
+const constructorInjections = {};
+function injectable(dependencyOrDependencies, autoInjecions) {
     return function (value, context) {
-        if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
-            const name = dependencyId ? dependencyId : context.name;
-            if (autoInjectableClasses[name]) {
-                throw new Error(`ProxyDi autoInjectable already has dependency ID: ${String(name)}`);
-            }
-            autoInjectableClasses[name] = value;
+        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+            throw new Error('@injectable decorator should decorate classes');
         }
-        else {
-            throw new Error('@autoInjectable 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,
@@ -126,6 +145,49 @@ 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 {
+            throw new Error(`Unknown dependency: ${String(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();
+            return Reflect.has(dependency, prop);
+        },
+    });
+}
+
 /**
  * A dependency injection container
  */
@@ -161,7 +223,7 @@ class ProxyDiContainer {
         let dependencyInstance;
         const isClass = typeof dependency === 'function';
         if (isClass) {
-            dependencyInstance = new dependency();
+            dependencyInstance = this.createInstance(dependency, dependencyId);
         }
         else {
             dependencyInstance = dependency;
@@ -176,6 +238,15 @@ class ProxyDiContainer {
         this.registerImpl(dependencyInstance, dependencyId);
         return dependencyInstance;
     }
+    createInstance(Dependency, dependencyId) {
+        const paramIds = constructorInjections[dependencyId] || [];
+        const params = [];
+        for (const id of paramIds) {
+            const param = makeConstructorDependencyProxy(this, id);
+            params.push(param);
+        }
+        return new Dependency(...params);
+    }
     /**
      * Internal method that implements registeration of dependency and prepare it for injection.
      * @param dependencyId The unique identifier of the dependency.
@@ -197,39 +268,34 @@ class ProxyDiContainer {
         return !!(this.parentDependencyProxies[dependencyId] ||
             this.dependencies[dependencyId] ||
             (this.parent && this.parent.isKnown(dependencyId)) ||
-            autoInjectableClasses[dependencyId]);
+            injectableClasses[dependencyId]);
     }
-    resolve(param) {
-        if (typeof param === 'function') {
-            for (const [dependencyId, DependencyClass] of Object.entries(autoInjectableClasses)) {
-                if (DependencyClass === param) {
-                    return this.resolve(dependencyId);
-                }
-            }
-            throw new Error(`Class is not auto injectable: ${param.name}`);
+    resolve(dependency) {
+        if (typeof dependency === 'function') {
+            const id = findInjectableId(dependency);
+            return this.resolve(id);
         }
-        if (!this.isKnown(param)) {
-            throw new Error(`Can't resolve unknown dependency: ${String(param)}`);
+        if (!this.isKnown(dependency)) {
+            throw new Error(`Can't resolve unknown dependency: ${String(dependency)}`);
         }
-        const proxy = this.parentDependencyProxies[param];
+        const proxy = this.parentDependencyProxies[dependency];
         if (proxy) {
             return proxy;
         }
-        const dependency = this.findDependency(param);
-        if (dependency) {
-            if (dependency[PROXYDY_CONTAINER] !== this &&
-                typeof dependency === 'object' &&
+        const instance = this.findDependency(dependency);
+        if (instance) {
+            if (instance[PROXYDY_CONTAINER] !== this &&
+                typeof instance === 'object' &&
                 this.settings.resolveInContainerContext) {
-                const proxy = makeDependencyProxy(dependency);
+                const proxy = makeDependencyProxy(instance);
                 this.injectDependenciesTo(proxy);
-                this.parentDependencyProxies[param] = proxy;
+                this.parentDependencyProxies[dependency] = proxy;
                 return proxy;
             }
-            return dependency;
+            return instance;
         }
-        const AutoInjectableClass = autoInjectableClasses[param];
-        const autoDependency = new AutoInjectableClass();
-        return this.register(autoDependency, param);
+        const InjectableClass = injectableClasses[dependency];
+        return this.register(InjectableClass, dependency);
     }
     /**
      * Injects dependencies to the given object based on its defined injections metadata. Does not affect the container.
@@ -374,12 +440,8 @@ function isDependency(dependencyOrId) {
 
 function resolveAll(instance, dependencyId) {
     if (typeof dependencyId === 'function') {
-        for (const [id, DependencyClass] of Object.entries(autoInjectableClasses)) {
-            if (DependencyClass === dependencyId) {
-                return resolveAll(instance, id);
-            }
-        }
-        throw new Error(`Class is not auto injectable: ${dependencyId.name}`);
+        const id = findInjectableId(dependencyId);
+        return resolveAll(instance, id);
     }
     const container = instance[PROXYDY_CONTAINER];
     if (!container) {
@@ -398,4 +460,4 @@ function recursiveResolveAll(container, dependencyId) {
     return all;
 }
 
-export { DEPENDENCY_ID, PROXYDY_CONTAINER, ProxyDiContainer, autoInjectable, inject, resolveAll };
+export { DEPENDENCY_ID, PROXYDY_CONTAINER, ProxyDiContainer, inject, injectable, resolveAll };

package/dist/index.umd.js

@@ -5,10 +5,20 @@
 })(this, (function (exports) { 'use strict';
 
     const INJECTIONS = Symbol('injections');
+    /**
+     * This symbol constant defines a property name.
+     * This property is present in each dependency instance that was registered in ProxyDiContainer.
+     * The property stores the dependency identifier that should be used to resolve dependency from the container where it was registered.
+     */
     const DEPENDENCY_ID = Symbol('DependencyId');
+    /**
+     * This symbol constant defines a property name.
+     * This property is present in each dependency instance that was registered in ProxyDiContainer.
+     * The property stores a reference to the ProxyDiContainer in which the dependency was registered.
+     */
+    const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
     const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
     const INJECTION_OWNER = Symbol('injectionOwner');
-    const PROXYDY_CONTAINER = Symbol('proxyDiContainer');
     const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
 
     /**
@@ -41,31 +51,40 @@
         };
     };
 
-    const autoInjectableClasses = {};
-    /**
-     * Registers a class as an auto-injectable for dependency injection.
-     *
-     * @param dependencyId - Optional dependency 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 dependency 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.
-     */
-    const autoInjectable = (dependencyId) => {
+    const injectableClasses = {};
+    const constructorInjections = {};
+    function injectable(dependencyOrDependencies, autoInjecions) {
         return function (value, context) {
-            if ((context === null || context === undefined ? undefined : context.kind) === 'class') {
-                const name = dependencyId ? dependencyId : context.name;
-                if (autoInjectableClasses[name]) {
-                    throw new Error(`ProxyDi autoInjectable already has dependency ID: ${String(name)}`);
-                }
-                autoInjectableClasses[name] = value;
+            if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+                throw new Error('@injectable decorator should decorate classes');
             }
-            else {
-                throw new Error('@autoInjectable 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,
@@ -132,6 +151,49 @@
         });
     }
 
+    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 {
+                throw new Error(`Unknown dependency: ${String(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();
+                return Reflect.has(dependency, prop);
+            },
+        });
+    }
+
     /**
      * A dependency injection container
      */
@@ -167,7 +229,7 @@
             let dependencyInstance;
             const isClass = typeof dependency === 'function';
             if (isClass) {
-                dependencyInstance = new dependency();
+                dependencyInstance = this.createInstance(dependency, dependencyId);
             }
             else {
                 dependencyInstance = dependency;
@@ -182,6 +244,15 @@
             this.registerImpl(dependencyInstance, dependencyId);
             return dependencyInstance;
         }
+        createInstance(Dependency, dependencyId) {
+            const paramIds = constructorInjections[dependencyId] || [];
+            const params = [];
+            for (const id of paramIds) {
+                const param = makeConstructorDependencyProxy(this, id);
+                params.push(param);
+            }
+            return new Dependency(...params);
+        }
         /**
          * Internal method that implements registeration of dependency and prepare it for injection.
          * @param dependencyId The unique identifier of the dependency.
@@ -203,39 +274,34 @@
             return !!(this.parentDependencyProxies[dependencyId] ||
                 this.dependencies[dependencyId] ||
                 (this.parent && this.parent.isKnown(dependencyId)) ||
-                autoInjectableClasses[dependencyId]);
+                injectableClasses[dependencyId]);
         }
-        resolve(param) {
-            if (typeof param === 'function') {
-                for (const [dependencyId, DependencyClass] of Object.entries(autoInjectableClasses)) {
-                    if (DependencyClass === param) {
-                        return this.resolve(dependencyId);
-                    }
-                }
-                throw new Error(`Class is not auto injectable: ${param.name}`);
+        resolve(dependency) {
+            if (typeof dependency === 'function') {
+                const id = findInjectableId(dependency);
+                return this.resolve(id);
             }
-            if (!this.isKnown(param)) {
-                throw new Error(`Can't resolve unknown dependency: ${String(param)}`);
+            if (!this.isKnown(dependency)) {
+                throw new Error(`Can't resolve unknown dependency: ${String(dependency)}`);
             }
-            const proxy = this.parentDependencyProxies[param];
+            const proxy = this.parentDependencyProxies[dependency];
             if (proxy) {
                 return proxy;
             }
-            const dependency = this.findDependency(param);
-            if (dependency) {
-                if (dependency[PROXYDY_CONTAINER] !== this &&
-                    typeof dependency === 'object' &&
+            const instance = this.findDependency(dependency);
+            if (instance) {
+                if (instance[PROXYDY_CONTAINER] !== this &&
+                    typeof instance === 'object' &&
                     this.settings.resolveInContainerContext) {
-                    const proxy = makeDependencyProxy(dependency);
+                    const proxy = makeDependencyProxy(instance);
                     this.injectDependenciesTo(proxy);
-                    this.parentDependencyProxies[param] = proxy;
+                    this.parentDependencyProxies[dependency] = proxy;
                     return proxy;
                 }
-                return dependency;
+                return instance;
             }
-            const AutoInjectableClass = autoInjectableClasses[param];
-            const autoDependency = new AutoInjectableClass();
-            return this.register(autoDependency, param);
+            const InjectableClass = injectableClasses[dependency];
+            return this.register(InjectableClass, dependency);
         }
         /**
          * Injects dependencies to the given object based on its defined injections metadata. Does not affect the container.
@@ -380,12 +446,8 @@
 
     function resolveAll(instance, dependencyId) {
         if (typeof dependencyId === 'function') {
-            for (const [id, DependencyClass] of Object.entries(autoInjectableClasses)) {
-                if (DependencyClass === dependencyId) {
-                    return resolveAll(instance, id);
-                }
-            }
-            throw new Error(`Class is not auto injectable: ${dependencyId.name}`);
+            const id = findInjectableId(dependencyId);
+            return resolveAll(instance, id);
         }
         const container = instance[PROXYDY_CONTAINER];
         if (!container) {
@@ -407,8 +469,8 @@
     exports.DEPENDENCY_ID = DEPENDENCY_ID;
     exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
     exports.ProxyDiContainer = ProxyDiContainer;
-    exports.autoInjectable = autoInjectable;
     exports.inject = inject;
+    exports.injectable = injectable;
     exports.resolveAll = resolveAll;
 
 }));

package/dist/injectable.d.ts

@@ -0,0 +1,17 @@
+import { DependencyClass, DependencyId } from './types';
+export declare const injectableClasses: Record<DependencyId, DependencyClass<any>>;
+export declare const constructorInjections: Record<DependencyId, DependencyId[]>;
+/**
+ * Registers a class as an automatically injectable for dependency injection container.
+ *
+ * @param dependencyId - Optional dependency identifier. If omitted, the class name is used.
+ * @param autoInjecions - injections that should be injected to dependency constructor while it creates
+ * @returns A class decorator function.
+ *
+ * Note: During dependency resolution, any container that does not have an instance for the specified dependency 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 function injectable(autoInjecions: DependencyId[]): any;
+export declare function injectable(dependencyId?: DependencyId, autoInjecions?: DependencyId[]): any;
+export declare function findInjectableId(injectable: DependencyClass<any>): DependencyId;

package/dist/proxy.constuctor.d.ts

@@ -0,0 +1,2 @@
+import { DependencyId, IProxyDiContainer } from './types';
+export declare function makeConstructorDependencyProxy<T>(container: IProxyDiContainer, dependencyId: DependencyId): T;

package/dist/types.d.ts

@@ -21,7 +21,18 @@ export type IProxyDiContainer = {
     destroy: () => void;
 };
 export declare const INJECTIONS: unique symbol;
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores the dependency identifier that should be used to resolve dependency from the container where it was registered.
+ */
 export declare const DEPENDENCY_ID: unique symbol;
+/**
+ * This symbol constant defines a property name.
+ * This property is present in each dependency instance that was registered in ProxyDiContainer.
+ * The property stores a reference to the ProxyDiContainer in which the dependency was registered.
+ */
+export declare const PROXYDY_CONTAINER: unique symbol;
 export type Injections = Record<string | symbol, Injection>;
 export type Dependency = {
     [INJECTIONS]: Injections;
@@ -31,7 +42,7 @@ export type Dependency = {
  */
 export type ContainerizedDependency = Dependency & {
     /**
-     * Unique identifier that could use to resolve this instance
+     * Unique identifier that could use to resolve this instance from container where it was registered
      */
     [DEPENDENCY_ID]: DependencyId;
     /**
@@ -46,7 +57,6 @@ export type ContainerSettings = {
 };
 export declare const IS_INJECTION_PROXY: unique symbol;
 export declare const INJECTION_OWNER: unique symbol;
-export declare const PROXYDY_CONTAINER: unique symbol;
 export declare const IS_INSTANCE_PROXY: unique symbol;
 export type InjectionProxy = {
     [IS_INJECTION_PROXY]: true;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "proxydi",
-    "version": "0.0.9",
+    "version": "0.0.10",
     "description": "A typed hierarchical DI container that resolves circular dependencies via Proxy",
     "type": "module",
     "main": "./dist/index.cjs",