proxydi 0.0.9 → 0.0.11

package/CHANGELOG.md

@@ -0,0 +1,85 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [[0.0.10](https://www.npmjs.com/package/proxydi/v/0.0.11)] - 2025-03-03
+
+### Added
+
+- resolveInjectables() method [#12](https://github.com/proxy-di/proxydi/pull/13)
+
+## [[0.0.10](https://www.npmjs.com/package/proxydi/v/0.0.10)] - 2025-03-02
+
+### Changed
+
+- Renamed @autoInjectable to @injectable
+
+### Added
+
+- Experimental constructor injections via @injectable decorator [#12](https://github.com/proxy-di/proxydi/pull/12)
+
+## [[0.0.9](https://www.npmjs.com/package/proxydi/v/0.0.9)] - 2025-02-27
+
+### Added
+
+- resolveAll() function to find all dependencies of a given kind [#11](https://github.com/proxy-di/proxydi/pull/11)
+
+## [[0.0.8](https://www.npmjs.com/package/proxydi/v/0.0.8)] - 2025-02-26
+
+### Changed
+
+- API improvements [#10](https://github.com/proxy-di/proxydi/pull/10)
+
+### Added
+
+- Added access to child containers
+- PROXYDI_CONTAINER and DEPENDENCY_ID now public
+- Enhanced hierarchy documentation
+
+## [[0.0.7](https://www.npmjs.com/package/proxydi/v/0.0.7)] - 2025-02-21
+
+### Added
+
+- TypeDoc integration [#7](https://github.com/proxy-di/proxydi/pull/7)
+- Action to publish documentation on GitHub Pages
+
+## [[0.0.6](https://www.npmjs.com/package/proxydi/v/0.0.6)] - 2025-02-21
+
+### Changed
+
+- Improved API [#6](https://github.com/proxy-di/proxydi/pull/6)
+
+## [[0.0.5](https://www.npmjs.com/package/proxydi/v/0.0.5)] - 2025-02-20
+
+### Changed
+
+- Baking dependencies [#5](https://github.com/proxy-di/proxydi/pull/5)
+- 100% test coverage
+- Changed API with new terminology
+
+## [[0.0.4](https://www.npmjs.com/package/proxydi/v/0.0.4)] - 2025-02-11
+
+### Changed
+
+- Implemented proxy per instance instead of per container [#2](https://github.com/proxy-di/proxydi/pull/2)
+- Ability to register anything as an instance
+- Changed settings to object format
+- Added settings presets
+
+### Fixed
+
+- Made injectables known
+
+## [[0.0.3](https://www.npmjs.com/package/proxydi/v/0.0.3)] - 2025-02-07
+
+### Added
+
+- Draft DI-container implementation
+- @injectable decorator
+- Basic project setup with CI/CD
+- Testing framework integration
+- Basic package configuration
+- Repository initialization

package/README.md

@@ -12,9 +12,13 @@ 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 +222,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:
 
@@ -239,10 +243,67 @@ In this example, the character activates all its perks, which are registered in
 
 ### Reference to the container
 
-Here you should be wondering, how [resolveAll()](https://proxy-di.github.io/proxydi/functions/resolveAll.html.html) function knows about the container, to which character belongs. The answer - each time when dependency is registered in the ProxyDiContainer, it saves a reference to itself in this dependency instance. So, when you call resolveAll() function, it just takes this reference from the instance and then recursively resolves all asked dependencies from this container and all its children and children of children and so on.
+Here you should be wondering, how [resolveAll()](https://proxy-di.github.io/proxydi/functions/resolveAll.html) function knows about the container, to which character belongs. The answer - each time when dependency is registered in the ProxyDiContainer, it saves a reference to itself in this dependency instance. So, when you call resolveAll() function, it just takes this reference from the instance and then recursively resolves all asked dependencies from this container and all its children and children of children and so on.
 
 Despite this explanation is a little bit complicated, the example is still simple, the character just activates all its perks.
 
+## Injectable classes
+
+Look at the following example:
+
+```typescript
+@injectable()
+class GameEngine {
+    start = () => console.log('Game started');
+}
+
+const container = new ProxyDiContainer();
+
+const gameEngine = container.resolve(GameEngine);
+gameEngine.start();
+```
+
+```shell
+> Game started
+```
+
+Two things happen here:
+
+1. We use the [@injectable()](https://proxy-di.github.io/proxydi/functions/injectable.html) decorator to mark the class as injectable. This allows us to resolve the dependency without registering it in the container.
+
+2. To resolve the dependency instance, we pass the injectable class itself as the dependency identifier. This is possible because ProxyDi automatically uses the class name as the dependency identifier when none is explicitly provided. As an additional bonus, the `gameEngine` has a type `GameEngine`.
+
+### Implicitly resolving injectable() dependencies
+
+There are a few important nuances about the `@injectable()` decorator to keep in mind. The first is how these dependencies are resolved. Consider this example:
+
+```typescript
+const parent = new ProxyDiContainer();
+const child = parent.createChildContainer();
+
+const engine1 = child.resolve(GameEngine);
+const engine2 = parent.resolve(GameEngine);
+
+engine1 === engine2; // false
+```
+
+Here we create a hierarchy of containers and resolve the same dependency from the child container first and then from the parent container. The result is two different instances of the GameEngine class. This happens because during the first resolution, the child container doesn't find GameEngine in either itself or its parent container, so it creates a new instance and stores it in itself. When the parent container resolves GameEngine, it creates another instance since he knowns nothing about child depenencies
+
+There are two ways to avoid this behavior:
+
+1. Don't use the `@injectable()` decorator and always register dependencies explicitly
+2. Use the `registerInjectables()` method to create instances for all injectable dependencies in the container. In this case every time when you resolve injectable dependency, you will get the same instance:
+
+```typescript
+const parent = new ProxyDiContainer().registerInjectables();
+const child = parent.createChildContainer();
+
+const engine1 = child.resolve(GameEngine);
+const engine2 = parent.resolve(GameEngine);
+
+engine1 === engine2; // true now
+```
+
 ## Rewriting dependencies
 
 By default, ProxyDi doesn't allow rewriting dependencies in the container. After a dependency becomes known to the container, any attempt to register a new dependency with the same dependency ID will throw an Error:

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,12 +66,17 @@ 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.
      */
     injectDependenciesTo(injectionsOwner: any): void;
+    /**
+     * Creates instances for all injectable classes and registers them in this container.
+     * @returns This container to allow use along with constructor.
+     */
+    registerInjectables(): this;
     /**
      * Finalizes dependency injections, prevents further rewriting of dependencies,
      * and recursively bakes injections for child containers.

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 PROXYDI_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,
@@ -74,7 +93,7 @@ class InjectionProxy {
     constructor(onwer, container) {
         this[_a] = true;
         this[INJECTION_OWNER] = onwer;
-        this[PROXYDY_CONTAINER] = container;
+        this[PROXYDI_CONTAINER] = container;
     }
 }
 _a = IS_INJECTION_PROXY;
@@ -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;
@@ -173,11 +235,20 @@ class ProxyDiContainer {
             }
         }
         if (typeof dependencyInstance === 'object') {
-            dependencyInstance[PROXYDY_CONTAINER] = this;
+            dependencyInstance[PROXYDI_CONTAINER] = this;
         }
         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[PROXYDI_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.
@@ -244,6 +310,16 @@ class ProxyDiContainer {
             injection.set(injectionsOwner, dependencyProxy);
         });
     }
+    /**
+     * Creates instances for all injectable classes and registers them in this container.
+     * @returns This container to allow use along with constructor.
+     */
+    registerInjectables() {
+        for (const [dependencyId, InjectableClass] of Object.entries(injectableClasses)) {
+            this.register(InjectableClass, dependencyId);
+        }
+        return this;
+    }
     /**
      * Finalizes dependency injections, prevents further rewriting of dependencies,
      * and recursively bakes injections for child containers.
@@ -376,14 +452,10 @@ 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];
+    const container = instance[PROXYDI_CONTAINER];
     if (!container) {
         throw new Error('Instance is not registered in any container');
     }
@@ -401,8 +473,8 @@ function recursiveResolveAll(container, dependencyId) {
 }
 
 exports.DEPENDENCY_ID = DEPENDENCY_ID;
-exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
+exports.PROXYDI_CONTAINER = PROXYDI_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 { Injection, DependencyId, DependencyClass, ContainerSettings, PROXYDY_CONTAINER, DEPENDENCY_ID, } from './types';
+export { injectable } from './injectable';
+export { Injection, DependencyId, DependencyClass, ContainerSettings, PROXYDI_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 PROXYDI_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,
@@ -72,7 +91,7 @@ class InjectionProxy {
     constructor(onwer, container) {
         this[_a] = true;
         this[INJECTION_OWNER] = onwer;
-        this[PROXYDY_CONTAINER] = container;
+        this[PROXYDI_CONTAINER] = container;
     }
 }
 _a = IS_INJECTION_PROXY;
@@ -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;
@@ -171,11 +233,20 @@ class ProxyDiContainer {
             }
         }
         if (typeof dependencyInstance === 'object') {
-            dependencyInstance[PROXYDY_CONTAINER] = this;
+            dependencyInstance[PROXYDI_CONTAINER] = this;
         }
         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[PROXYDI_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.
@@ -242,6 +308,16 @@ class ProxyDiContainer {
             injection.set(injectionsOwner, dependencyProxy);
         });
     }
+    /**
+     * Creates instances for all injectable classes and registers them in this container.
+     * @returns This container to allow use along with constructor.
+     */
+    registerInjectables() {
+        for (const [dependencyId, InjectableClass] of Object.entries(injectableClasses)) {
+            this.register(InjectableClass, dependencyId);
+        }
+        return this;
+    }
     /**
      * Finalizes dependency injections, prevents further rewriting of dependencies,
      * and recursively bakes injections for child containers.
@@ -374,14 +450,10 @@ 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];
+    const container = instance[PROXYDI_CONTAINER];
     if (!container) {
         throw new Error('Instance is not registered in any container');
     }
@@ -398,4 +470,4 @@ function recursiveResolveAll(container, dependencyId) {
     return all;
 }
 
-export { DEPENDENCY_ID, PROXYDY_CONTAINER, ProxyDiContainer, autoInjectable, inject, resolveAll };
+export { DEPENDENCY_ID, PROXYDI_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 PROXYDI_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,
@@ -78,7 +97,7 @@
         constructor(onwer, container) {
             this[_a] = true;
             this[INJECTION_OWNER] = onwer;
-            this[PROXYDY_CONTAINER] = container;
+            this[PROXYDI_CONTAINER] = container;
         }
     }
     _a = IS_INJECTION_PROXY;
@@ -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;
@@ -177,11 +239,20 @@
                 }
             }
             if (typeof dependencyInstance === 'object') {
-                dependencyInstance[PROXYDY_CONTAINER] = this;
+                dependencyInstance[PROXYDI_CONTAINER] = this;
             }
             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[PROXYDI_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.
@@ -248,6 +314,16 @@
                 injection.set(injectionsOwner, dependencyProxy);
             });
         }
+        /**
+         * Creates instances for all injectable classes and registers them in this container.
+         * @returns This container to allow use along with constructor.
+         */
+        registerInjectables() {
+            for (const [dependencyId, InjectableClass] of Object.entries(injectableClasses)) {
+                this.register(InjectableClass, dependencyId);
+            }
+            return this;
+        }
         /**
          * Finalizes dependency injections, prevents further rewriting of dependencies,
          * and recursively bakes injections for child containers.
@@ -380,14 +456,10 @@
 
     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];
+        const container = instance[PROXYDI_CONTAINER];
         if (!container) {
             throw new Error('Instance is not registered in any container');
         }
@@ -405,10 +477,10 @@
     }
 
     exports.DEPENDENCY_ID = DEPENDENCY_ID;
-    exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
+    exports.PROXYDI_CONTAINER = PROXYDI_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

@@ -12,7 +12,7 @@ export type IProxyDiContainer = {
     isKnown: (dependencyId: DependencyId) => boolean;
     injectDependenciesTo: (dependency: any) => void;
     register: (dependency: any, dependencyId: DependencyId) => any;
-    resolve: <T>(dependencyId: DependencyId) => T & ContainerizedDependency;
+    resolve: <T>(dependencyId: DependencyId | DependencyClass<any>) => T & ContainerizedDependency;
     createChildContainer: () => IProxyDiContainer;
     children: IProxyDiContainer[];
     getChild(id: number): IProxyDiContainer;
@@ -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 PROXYDI_CONTAINER: unique symbol;
 export type Injections = Record<string | symbol, Injection>;
 export type Dependency = {
     [INJECTIONS]: Injections;
@@ -31,13 +42,13 @@ 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;
     /**
      * ProxyDi container in which this instance was registered
      */
-    [PROXYDY_CONTAINER]: IProxyDiContainer;
+    [PROXYDI_CONTAINER]: IProxyDiContainer;
 };
 export type ContainerSettings = {
     allowRegisterAnything?: boolean;
@@ -46,10 +57,9 @@ 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;
     [INJECTION_OWNER]: ContainerizedDependency;
-    [PROXYDY_CONTAINER]: IProxyDiContainer;
+    [PROXYDI_CONTAINER]: IProxyDiContainer;
 };

package/package.json

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