proxydi 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -0,0 +1,91 @@
+# 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.12](https://www.npmjs.com/package/proxydi/v/0.0.12)] - 2025-03-04
+
+### Added
+
+- Experimental @middleware [#14](https://github.com/proxy-di/proxydi/pull/14)
+
+## [[0.0.11](https://www.npmjs.com/package/proxydi/v/0.0.11)] - 2025-03-03
+
+### Added
+
+- resolveInjectables() method [#13](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

@@ -15,7 +15,9 @@ Core features:
 - Currently under active development, the API may change until version 0.1.0
 
 Eperimemntal features:
+
 - Construtor injections (see unit tests for examples)
+- Middleware listeners (see unit tests for examples)
 - Matches dependencies by unique identifiers or automatically using class names and property names
 
 ## Quick start
@@ -242,10 +244,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

@@ -29,6 +29,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * Settings that control the behavior of the container and it's children
      */
     readonly settings: Required<ContainerSettings>;
+    private middlewareListener;
     /**
      * Creates a new instance of ProxyDiContainer.
      * @param settings Optional container settings to override defaults.
@@ -47,12 +48,6 @@ 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.
-     * @param dependency The dependency instance.
-     */
-    private registerImpl;
     /**
      * Checks if a dependency with the given ID is known to the container or its ancestors which means that it can be resolved by this container
      * @param dependencyId The identifier of the dependency.
@@ -72,6 +67,11 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * @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

@@ -12,7 +12,7 @@ const DEPENDENCY_ID = Symbol('DependencyId');
  * 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 PROXYDI_CONTAINER = Symbol('proxyDiContainer');
 const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
 const INJECTION_OWNER = Symbol('injectionOwner');
 const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
@@ -93,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;
@@ -190,6 +190,72 @@ function makeConstructorDependencyProxy(container, dependencyId) {
     });
 }
 
+const middlewaresClasses = {};
+function middleware() {
+    return function (value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+            throw new Error('@middleware decorator should decorate classes');
+        }
+        const name = context.name;
+        if (middlewaresClasses[name]) {
+            throw new Error(`ProxyDi has already regisered middleware ${String(name)} by @middleware`);
+        }
+        middlewaresClasses[name] = value;
+    };
+}
+
+class MiddlewareListener {
+    constructor(parent) {
+        this.parent = parent;
+        this.listeners = {
+            register: [],
+            remove: [],
+        };
+    }
+    add(middleware) {
+        if (isRegistingMiddleware(middleware)) {
+            middleware.onRegister && this.on('register', middleware.onRegister);
+        }
+        if (isRemovingMiddleware(middleware)) {
+            middleware.onRemove && this.on('remove', middleware.onRemove);
+        }
+    }
+    remove(middleware) {
+        if (isRegistingMiddleware(middleware)) {
+            middleware.onRegister &&
+                this.off('register', middleware.onRegister);
+        }
+        if (isRemovingMiddleware(middleware)) {
+            middleware.onRemove && this.off('remove', middleware.onRemove);
+        }
+    }
+    on(event, listener) {
+        this.listeners[event].push(listener);
+    }
+    onRegister(container, dependencyId, dependency) {
+        var _a;
+        this.listeners.register.forEach((listener) => listener(container, dependencyId, dependency));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRegister(container, dependencyId, dependency);
+    }
+    onRemove(container, dependencyId) {
+        var _a;
+        this.listeners.remove.forEach((listener) => listener(container, dependencyId));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRemove(container, dependencyId);
+    }
+    off(event, listener) {
+        const index = this.listeners[event].indexOf(listener);
+        if (index !== -1) {
+            this.listeners[event].splice(index, 1);
+        }
+    }
+}
+function isRegistingMiddleware(middleware) {
+    return middleware.onRegister;
+}
+function isRemovingMiddleware(middleware) {
+    return middleware.onRemove;
+}
+
 /**
  * A dependency injection container
  */
@@ -210,6 +276,7 @@ class ProxyDiContainer {
          */
         this.parentDependencyProxies = {};
         this.id = ProxyDiContainer.idCounter++;
+        this.middlewareListener = new MiddlewareListener(parent === null || parent === undefined ? undefined : parent.middlewareListener);
         if (parent) {
             this.parent = parent;
             this.parent.addChild(this);
@@ -217,28 +284,36 @@ class ProxyDiContainer {
         this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
     }
     register(dependency, dependencyId) {
+        var _a;
         if (this.dependencies[dependencyId]) {
             if (!this.settings.allowRewriteDependencies) {
                 throw new Error(`ProxyDi already has dependency for ${String(dependencyId)}`);
             }
         }
-        let dependencyInstance;
+        let instance;
         const isClass = typeof dependency === 'function';
         if (isClass) {
-            dependencyInstance = this.createInstance(dependency, dependencyId);
+            instance = this.createInstance(dependency, dependencyId);
         }
         else {
-            dependencyInstance = dependency;
-            if (!(typeof dependencyInstance === 'object') &&
-                !this.settings.allowRegisterAnything) {
-                throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${dependencyInstance}`);
-            }
+            instance = dependency;
+        }
+        const isObject = typeof instance === 'object';
+        if (!isObject && !this.settings.allowRegisterAnything) {
+            throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${instance}`);
         }
-        if (typeof dependencyInstance === 'object') {
-            dependencyInstance[PROXYDY_CONTAINER] = this;
+        if (isObject) {
+            instance[PROXYDI_CONTAINER] = this;
+            instance[DEPENDENCY_ID] = dependencyId;
         }
-        this.registerImpl(dependencyInstance, dependencyId);
-        return dependencyInstance;
+        this.injectDependenciesTo(instance);
+        this.dependencies[dependencyId] = instance;
+        const constructorName = (_a = instance.constructor) === null || _a === undefined ? undefined : _a.name;
+        if (constructorName && middlewaresClasses[constructorName]) {
+            this.middlewareListener.add(instance);
+        }
+        this.middlewareListener.onRegister(this, dependencyId, instance);
+        return instance;
     }
     createInstance(Dependency, dependencyId) {
         const paramIds = constructorInjections[dependencyId] || [];
@@ -249,18 +324,6 @@ class ProxyDiContainer {
         }
         return new Dependency(...params);
     }
-    /**
-     * Internal method that implements registeration of dependency and prepare it for injection.
-     * @param dependencyId The unique identifier of the dependency.
-     * @param dependency The dependency instance.
-     */
-    registerImpl(dependency, dependencyId) {
-        this.injectDependenciesTo(dependency);
-        if (typeof dependency === 'object') {
-            dependency[DEPENDENCY_ID] = dependencyId;
-        }
-        this.dependencies[dependencyId] = dependency;
-    }
     /**
      * Checks if a dependency with the given ID is known to the container or its ancestors which means that it can be resolved by this container
      * @param dependencyId The identifier of the dependency.
@@ -286,7 +349,7 @@ class ProxyDiContainer {
         }
         const instance = this.findDependency(dependency);
         if (instance) {
-            if (instance[PROXYDY_CONTAINER] !== this &&
+            if (instance[PROXYDI_CONTAINER] !== this &&
                 typeof instance === 'object' &&
                 this.settings.resolveInContainerContext) {
                 const proxy = makeDependencyProxy(instance);
@@ -310,6 +373,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.
@@ -339,11 +412,16 @@ class ProxyDiContainer {
      * @param dependencyOrId The dependency instance or dependency identifier to remove.
      */
     remove(dependencyOrId) {
+        var _a;
         const id = isDependency(dependencyOrId)
             ? dependencyOrId[DEPENDENCY_ID]
             : dependencyOrId;
         const dependency = this.dependencies[id];
         if (dependency) {
+            const constructorName = (_a = dependency.constructor) === null || _a === undefined ? undefined : _a.name;
+            if (constructorName && middlewaresClasses[constructorName]) {
+                this.middlewareListener.remove(dependency);
+            }
             const dependencyInjects = dependency[INJECTIONS]
                 ? dependency[INJECTIONS]
                 : {};
@@ -352,6 +430,7 @@ class ProxyDiContainer {
             });
             delete dependency[DEPENDENCY_ID];
             delete this.dependencies[id];
+            this.middlewareListener.onRemove(this, id);
         }
     }
     /**
@@ -445,7 +524,7 @@ function resolveAll(instance, dependencyId) {
         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');
     }
@@ -463,8 +542,9 @@ function recursiveResolveAll(container, dependencyId) {
 }
 
 exports.DEPENDENCY_ID = DEPENDENCY_ID;
-exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
+exports.PROXYDI_CONTAINER = PROXYDI_CONTAINER;
 exports.ProxyDiContainer = ProxyDiContainer;
 exports.inject = inject;
 exports.injectable = injectable;
+exports.middleware = middleware;
 exports.resolveAll = resolveAll;

package/dist/index.d.ts

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

package/dist/index.js

@@ -10,7 +10,7 @@ const DEPENDENCY_ID = Symbol('DependencyId');
  * 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 PROXYDI_CONTAINER = Symbol('proxyDiContainer');
 const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
 const INJECTION_OWNER = Symbol('injectionOwner');
 const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
@@ -91,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;
@@ -188,6 +188,72 @@ function makeConstructorDependencyProxy(container, dependencyId) {
     });
 }
 
+const middlewaresClasses = {};
+function middleware() {
+    return function (value, context) {
+        if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+            throw new Error('@middleware decorator should decorate classes');
+        }
+        const name = context.name;
+        if (middlewaresClasses[name]) {
+            throw new Error(`ProxyDi has already regisered middleware ${String(name)} by @middleware`);
+        }
+        middlewaresClasses[name] = value;
+    };
+}
+
+class MiddlewareListener {
+    constructor(parent) {
+        this.parent = parent;
+        this.listeners = {
+            register: [],
+            remove: [],
+        };
+    }
+    add(middleware) {
+        if (isRegistingMiddleware(middleware)) {
+            middleware.onRegister && this.on('register', middleware.onRegister);
+        }
+        if (isRemovingMiddleware(middleware)) {
+            middleware.onRemove && this.on('remove', middleware.onRemove);
+        }
+    }
+    remove(middleware) {
+        if (isRegistingMiddleware(middleware)) {
+            middleware.onRegister &&
+                this.off('register', middleware.onRegister);
+        }
+        if (isRemovingMiddleware(middleware)) {
+            middleware.onRemove && this.off('remove', middleware.onRemove);
+        }
+    }
+    on(event, listener) {
+        this.listeners[event].push(listener);
+    }
+    onRegister(container, dependencyId, dependency) {
+        var _a;
+        this.listeners.register.forEach((listener) => listener(container, dependencyId, dependency));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRegister(container, dependencyId, dependency);
+    }
+    onRemove(container, dependencyId) {
+        var _a;
+        this.listeners.remove.forEach((listener) => listener(container, dependencyId));
+        (_a = this.parent) === null || _a === undefined ? undefined : _a.onRemove(container, dependencyId);
+    }
+    off(event, listener) {
+        const index = this.listeners[event].indexOf(listener);
+        if (index !== -1) {
+            this.listeners[event].splice(index, 1);
+        }
+    }
+}
+function isRegistingMiddleware(middleware) {
+    return middleware.onRegister;
+}
+function isRemovingMiddleware(middleware) {
+    return middleware.onRemove;
+}
+
 /**
  * A dependency injection container
  */
@@ -208,6 +274,7 @@ class ProxyDiContainer {
          */
         this.parentDependencyProxies = {};
         this.id = ProxyDiContainer.idCounter++;
+        this.middlewareListener = new MiddlewareListener(parent === null || parent === undefined ? undefined : parent.middlewareListener);
         if (parent) {
             this.parent = parent;
             this.parent.addChild(this);
@@ -215,28 +282,36 @@ class ProxyDiContainer {
         this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
     }
     register(dependency, dependencyId) {
+        var _a;
         if (this.dependencies[dependencyId]) {
             if (!this.settings.allowRewriteDependencies) {
                 throw new Error(`ProxyDi already has dependency for ${String(dependencyId)}`);
             }
         }
-        let dependencyInstance;
+        let instance;
         const isClass = typeof dependency === 'function';
         if (isClass) {
-            dependencyInstance = this.createInstance(dependency, dependencyId);
+            instance = this.createInstance(dependency, dependencyId);
         }
         else {
-            dependencyInstance = dependency;
-            if (!(typeof dependencyInstance === 'object') &&
-                !this.settings.allowRegisterAnything) {
-                throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${dependencyInstance}`);
-            }
+            instance = dependency;
+        }
+        const isObject = typeof instance === 'object';
+        if (!isObject && !this.settings.allowRegisterAnything) {
+            throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${instance}`);
         }
-        if (typeof dependencyInstance === 'object') {
-            dependencyInstance[PROXYDY_CONTAINER] = this;
+        if (isObject) {
+            instance[PROXYDI_CONTAINER] = this;
+            instance[DEPENDENCY_ID] = dependencyId;
         }
-        this.registerImpl(dependencyInstance, dependencyId);
-        return dependencyInstance;
+        this.injectDependenciesTo(instance);
+        this.dependencies[dependencyId] = instance;
+        const constructorName = (_a = instance.constructor) === null || _a === undefined ? undefined : _a.name;
+        if (constructorName && middlewaresClasses[constructorName]) {
+            this.middlewareListener.add(instance);
+        }
+        this.middlewareListener.onRegister(this, dependencyId, instance);
+        return instance;
     }
     createInstance(Dependency, dependencyId) {
         const paramIds = constructorInjections[dependencyId] || [];
@@ -247,18 +322,6 @@ class ProxyDiContainer {
         }
         return new Dependency(...params);
     }
-    /**
-     * Internal method that implements registeration of dependency and prepare it for injection.
-     * @param dependencyId The unique identifier of the dependency.
-     * @param dependency The dependency instance.
-     */
-    registerImpl(dependency, dependencyId) {
-        this.injectDependenciesTo(dependency);
-        if (typeof dependency === 'object') {
-            dependency[DEPENDENCY_ID] = dependencyId;
-        }
-        this.dependencies[dependencyId] = dependency;
-    }
     /**
      * Checks if a dependency with the given ID is known to the container or its ancestors which means that it can be resolved by this container
      * @param dependencyId The identifier of the dependency.
@@ -284,7 +347,7 @@ class ProxyDiContainer {
         }
         const instance = this.findDependency(dependency);
         if (instance) {
-            if (instance[PROXYDY_CONTAINER] !== this &&
+            if (instance[PROXYDI_CONTAINER] !== this &&
                 typeof instance === 'object' &&
                 this.settings.resolveInContainerContext) {
                 const proxy = makeDependencyProxy(instance);
@@ -308,6 +371,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.
@@ -337,11 +410,16 @@ class ProxyDiContainer {
      * @param dependencyOrId The dependency instance or dependency identifier to remove.
      */
     remove(dependencyOrId) {
+        var _a;
         const id = isDependency(dependencyOrId)
             ? dependencyOrId[DEPENDENCY_ID]
             : dependencyOrId;
         const dependency = this.dependencies[id];
         if (dependency) {
+            const constructorName = (_a = dependency.constructor) === null || _a === undefined ? undefined : _a.name;
+            if (constructorName && middlewaresClasses[constructorName]) {
+                this.middlewareListener.remove(dependency);
+            }
             const dependencyInjects = dependency[INJECTIONS]
                 ? dependency[INJECTIONS]
                 : {};
@@ -350,6 +428,7 @@ class ProxyDiContainer {
             });
             delete dependency[DEPENDENCY_ID];
             delete this.dependencies[id];
+            this.middlewareListener.onRemove(this, id);
         }
     }
     /**
@@ -443,7 +522,7 @@ function resolveAll(instance, dependencyId) {
         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');
     }
@@ -460,4 +539,4 @@ function recursiveResolveAll(container, dependencyId) {
     return all;
 }
 
-export { DEPENDENCY_ID, PROXYDY_CONTAINER, ProxyDiContainer, inject, injectable, resolveAll };
+export { DEPENDENCY_ID, PROXYDI_CONTAINER, ProxyDiContainer, inject, injectable, middleware, resolveAll };

package/dist/index.umd.js

@@ -16,7 +16,7 @@
      * 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 PROXYDI_CONTAINER = Symbol('proxyDiContainer');
     const IS_INJECTION_PROXY = Symbol('isInjectionProxy');
     const INJECTION_OWNER = Symbol('injectionOwner');
     const IS_INSTANCE_PROXY = Symbol('isInstanceProxy');
@@ -97,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;
@@ -194,6 +194,72 @@
         });
     }
 
+    const middlewaresClasses = {};
+    function middleware() {
+        return function (value, context) {
+            if ((context === null || context === undefined ? undefined : context.kind) !== 'class') {
+                throw new Error('@middleware decorator should decorate classes');
+            }
+            const name = context.name;
+            if (middlewaresClasses[name]) {
+                throw new Error(`ProxyDi has already regisered middleware ${String(name)} by @middleware`);
+            }
+            middlewaresClasses[name] = value;
+        };
+    }
+
+    class MiddlewareListener {
+        constructor(parent) {
+            this.parent = parent;
+            this.listeners = {
+                register: [],
+                remove: [],
+            };
+        }
+        add(middleware) {
+            if (isRegistingMiddleware(middleware)) {
+                middleware.onRegister && this.on('register', middleware.onRegister);
+            }
+            if (isRemovingMiddleware(middleware)) {
+                middleware.onRemove && this.on('remove', middleware.onRemove);
+            }
+        }
+        remove(middleware) {
+            if (isRegistingMiddleware(middleware)) {
+                middleware.onRegister &&
+                    this.off('register', middleware.onRegister);
+            }
+            if (isRemovingMiddleware(middleware)) {
+                middleware.onRemove && this.off('remove', middleware.onRemove);
+            }
+        }
+        on(event, listener) {
+            this.listeners[event].push(listener);
+        }
+        onRegister(container, dependencyId, dependency) {
+            var _a;
+            this.listeners.register.forEach((listener) => listener(container, dependencyId, dependency));
+            (_a = this.parent) === null || _a === undefined ? undefined : _a.onRegister(container, dependencyId, dependency);
+        }
+        onRemove(container, dependencyId) {
+            var _a;
+            this.listeners.remove.forEach((listener) => listener(container, dependencyId));
+            (_a = this.parent) === null || _a === undefined ? undefined : _a.onRemove(container, dependencyId);
+        }
+        off(event, listener) {
+            const index = this.listeners[event].indexOf(listener);
+            if (index !== -1) {
+                this.listeners[event].splice(index, 1);
+            }
+        }
+    }
+    function isRegistingMiddleware(middleware) {
+        return middleware.onRegister;
+    }
+    function isRemovingMiddleware(middleware) {
+        return middleware.onRemove;
+    }
+
     /**
      * A dependency injection container
      */
@@ -214,6 +280,7 @@
              */
             this.parentDependencyProxies = {};
             this.id = ProxyDiContainer.idCounter++;
+            this.middlewareListener = new MiddlewareListener(parent === null || parent === undefined ? undefined : parent.middlewareListener);
             if (parent) {
                 this.parent = parent;
                 this.parent.addChild(this);
@@ -221,28 +288,36 @@
             this.settings = Object.assign(Object.assign({}, DEFAULT_SETTINGS), settings);
         }
         register(dependency, dependencyId) {
+            var _a;
             if (this.dependencies[dependencyId]) {
                 if (!this.settings.allowRewriteDependencies) {
                     throw new Error(`ProxyDi already has dependency for ${String(dependencyId)}`);
                 }
             }
-            let dependencyInstance;
+            let instance;
             const isClass = typeof dependency === 'function';
             if (isClass) {
-                dependencyInstance = this.createInstance(dependency, dependencyId);
+                instance = this.createInstance(dependency, dependencyId);
             }
             else {
-                dependencyInstance = dependency;
-                if (!(typeof dependencyInstance === 'object') &&
-                    !this.settings.allowRegisterAnything) {
-                    throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${dependencyInstance}`);
-                }
+                instance = dependency;
+            }
+            const isObject = typeof instance === 'object';
+            if (!isObject && !this.settings.allowRegisterAnything) {
+                throw new Error(`Can't register as dependency (allowRegisterAnything is off for this contatiner): ${instance}`);
             }
-            if (typeof dependencyInstance === 'object') {
-                dependencyInstance[PROXYDY_CONTAINER] = this;
+            if (isObject) {
+                instance[PROXYDI_CONTAINER] = this;
+                instance[DEPENDENCY_ID] = dependencyId;
             }
-            this.registerImpl(dependencyInstance, dependencyId);
-            return dependencyInstance;
+            this.injectDependenciesTo(instance);
+            this.dependencies[dependencyId] = instance;
+            const constructorName = (_a = instance.constructor) === null || _a === undefined ? undefined : _a.name;
+            if (constructorName && middlewaresClasses[constructorName]) {
+                this.middlewareListener.add(instance);
+            }
+            this.middlewareListener.onRegister(this, dependencyId, instance);
+            return instance;
         }
         createInstance(Dependency, dependencyId) {
             const paramIds = constructorInjections[dependencyId] || [];
@@ -253,18 +328,6 @@
             }
             return new Dependency(...params);
         }
-        /**
-         * Internal method that implements registeration of dependency and prepare it for injection.
-         * @param dependencyId The unique identifier of the dependency.
-         * @param dependency The dependency instance.
-         */
-        registerImpl(dependency, dependencyId) {
-            this.injectDependenciesTo(dependency);
-            if (typeof dependency === 'object') {
-                dependency[DEPENDENCY_ID] = dependencyId;
-            }
-            this.dependencies[dependencyId] = dependency;
-        }
         /**
          * Checks if a dependency with the given ID is known to the container or its ancestors which means that it can be resolved by this container
          * @param dependencyId The identifier of the dependency.
@@ -290,7 +353,7 @@
             }
             const instance = this.findDependency(dependency);
             if (instance) {
-                if (instance[PROXYDY_CONTAINER] !== this &&
+                if (instance[PROXYDI_CONTAINER] !== this &&
                     typeof instance === 'object' &&
                     this.settings.resolveInContainerContext) {
                     const proxy = makeDependencyProxy(instance);
@@ -314,6 +377,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.
@@ -343,11 +416,16 @@
          * @param dependencyOrId The dependency instance or dependency identifier to remove.
          */
         remove(dependencyOrId) {
+            var _a;
             const id = isDependency(dependencyOrId)
                 ? dependencyOrId[DEPENDENCY_ID]
                 : dependencyOrId;
             const dependency = this.dependencies[id];
             if (dependency) {
+                const constructorName = (_a = dependency.constructor) === null || _a === undefined ? undefined : _a.name;
+                if (constructorName && middlewaresClasses[constructorName]) {
+                    this.middlewareListener.remove(dependency);
+                }
                 const dependencyInjects = dependency[INJECTIONS]
                     ? dependency[INJECTIONS]
                     : {};
@@ -356,6 +434,7 @@
                 });
                 delete dependency[DEPENDENCY_ID];
                 delete this.dependencies[id];
+                this.middlewareListener.onRemove(this, id);
             }
         }
         /**
@@ -449,7 +528,7 @@
             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');
         }
@@ -467,10 +546,11 @@
     }
 
     exports.DEPENDENCY_ID = DEPENDENCY_ID;
-    exports.PROXYDY_CONTAINER = PROXYDY_CONTAINER;
+    exports.PROXYDI_CONTAINER = PROXYDI_CONTAINER;
     exports.ProxyDiContainer = ProxyDiContainer;
     exports.inject = inject;
     exports.injectable = injectable;
+    exports.middleware = middleware;
     exports.resolveAll = resolveAll;
 
 }));

package/dist/middleware/MiddlewareListener.d.ts

@@ -0,0 +1,29 @@
+import { ProxyDiContainer } from '../ProxyDiContainer';
+import { DependencyId } from '../types';
+export interface MiddlewareListenerEvent {
+    register: (container: ProxyDiContainer, dependencyId: DependencyId, dependency: any) => void;
+    remove: (container: ProxyDiContainer, dependencyId: DependencyId) => void;
+}
+/**
+ * Describe the middleware that able to listen to the registering of a dependency in containers hierarchy
+ */
+export interface MiddlewareRegisteringListener {
+    onRegister(container: ProxyDiContainer, dependencyId: DependencyId, dependency: any): void;
+}
+/**
+ * Describe the middleware that able to listen to the removing of a dependency in containers hierarchy
+ */
+export interface MiddlewareRemovingListener {
+    onRemove(container: ProxyDiContainer, dependencyId: DependencyId): void;
+}
+export declare class MiddlewareListener {
+    private parent?;
+    private listeners;
+    constructor(parent?: MiddlewareListener | undefined);
+    add(middleware: any): void;
+    remove(middleware: any): void;
+    private on;
+    onRegister(container: ProxyDiContainer, dependencyId: DependencyId, dependency: any): void;
+    onRemove(container: ProxyDiContainer, dependencyId: DependencyId): void;
+    private off;
+}

package/dist/middleware/middleware.d.ts

@@ -0,0 +1,3 @@
+import { DependencyClass, DependencyId } from '../types';
+export declare const middlewaresClasses: Record<DependencyId, DependencyClass<any>>;
+export declare function middleware(): any;

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;
@@ -32,7 +32,7 @@ export declare const DEPENDENCY_ID: unique symbol;
  * 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 declare const PROXYDI_CONTAINER: unique symbol;
 export type Injections = Record<string | symbol, Injection>;
 export type Dependency = {
     [INJECTIONS]: Injections;
@@ -48,7 +48,7 @@ export type ContainerizedDependency = Dependency & {
     /**
      * ProxyDi container in which this instance was registered
      */
-    [PROXYDY_CONTAINER]: IProxyDiContainer;
+    [PROXYDI_CONTAINER]: IProxyDiContainer;
 };
 export type ContainerSettings = {
     allowRegisterAnything?: boolean;
@@ -61,5 +61,5 @@ 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.10",
+    "version": "0.0.12",
     "description": "A typed hierarchical DI container that resolves circular dependencies via Proxy",
     "type": "module",
     "main": "./dist/index.cjs",