proxydi 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -4,9 +4,19 @@ 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.3.0](https://www.npmjs.com/package/proxydi/v/0.3.0)] - 2026-01-02
+
 ### Added
 
-- Added test coverage for Symbol-based dependency IDs with `@injectable`, `@inject`, and `@injectAll` decorators
+- `@injectable` accepts multiple dependency identifiers and always registers under the class name as a default ID
+- `register()` can directly bind a single dependency to multiple dependency IDs
+- `@inject` accepts `ResolveScope` to resolve dependencies from children/parent/current containers
+- `resolve()` and `resolveAll()` accept optional `ResolveScope` to define where dependencies are searched
+- Robust removal logic for multi-ID registrations; removing by ID leaves other IDs intact, removing by instance clears all IDs
+
+### Breaking
+
+- One dependency ID can now have multiple registrations; `resolve()` returns the first registered instance, while `resolveAll()`/`@injectAll` return all matching instances.
 
 ## [[0.2.0](https://www.npmjs.com/package/proxydi/v/0.2.0)] - 2026-01-01
 
@@ -20,9 +30,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 - Fixed bug where passing class constructor as `dependencyId` in `register()` would store dependency under function reference instead of class name, making it impossible to resolve with `resolve(Class)`
 
-### Removed
+### Breaking
 
-- **BREAKING:** Constructor injection support removed from `@injectable` decorator. This experimental feature caused issues with circular dependencies and added unnecessary complexity. Use field injection with `@inject` decorator instead.
+- Constructor injection support removed from `@injectable` decorator. This experimental feature caused issues with circular dependencies and added unnecessary complexity. Use field injection with `@inject` decorator instead.
 
 ## [[0.1.3](https://www.npmjs.com/package/proxydi/v/0.1.3)] - 2025-03-26
 

package/README.md

@@ -345,6 +345,77 @@ Therefore, after the container has been baked, the performance impact becomes ze
 
 To be continued...
 
+## Multiple Dependencies (v0.3.0+)
+
+Sometimes you need to register multiple instances for the same dependency ID (e.g., plugins, event handlers).
+
+### Registering multiple instances
+
+You can register multiple dependencies with the same ID using `DuplicateStrategy.AlwaysAdd`. By default, `register()` uses `DuplicateStrategy.ReplaceIfSingleElseAdd` which maintains backward compatibility (single instance replaces existing).
+
+```typescript
+import { DuplicateStrategy } from 'proxydi';
+
+const container = new ProxyDiContainer();
+
+// Register multiple handlers
+container.register(new Handler1(), {
+    dependencyId: 'EventHandler',
+    duplicateStrategy: DuplicateStrategy.AlwaysAdd,
+});
+container.register(new Handler2(), {
+    dependencyId: 'EventHandler',
+    duplicateStrategy: DuplicateStrategy.AlwaysAdd,
+});
+```
+
+### Resolving multiple instances
+
+Use `@injectAll` or `resolveAll` to retrieve all registered instances:
+
+```typescript
+class EventService {
+    @injectAll('EventHandler') private handlers: EventHandler[];
+
+    emit(event) {
+        this.handlers.forEach((h) => h.handle(event));
+    }
+}
+```
+
+> **Note:** `resolve('EventHandler')` or `@inject('EventHandler')` will return the **first** registered instance and log a warning if multiple instances exist.
+
+### Auto-injectable arrays
+
+You can also use `@injectable` with an array of IDs. These classes will be automatically discovered and registered when using `resolveAll`.
+
+```typescript
+@injectable(['EventHandler'])
+class Handler1 {}
+
+@injectable(['EventHandler'])
+class Handler2 {}
+
+// ... later ...
+const handlers = container.resolveAll('EventHandler'); // [Handler1, Handler2]
+```
+
+## Resolve Scope
+
+You can control where dependencies are searched using `ResolveScope` in both `@inject` and `@injectAll`.
+
+```typescript
+import { ResolveScope } from 'proxydi';
+
+// Search only in children containers
+@injectAll('Plugin', ResolveScope.Children)
+private plugins: Plugin[];
+
+// Search only in the current container (ignore parent)
+@inject('Config', ResolveScope.Current)
+private localConfig: Config;
+```
+
 ## Motivation
 
 The world and software changes, they become more complex over time. But the main imperative in software development stays the same - managing the complexity. Despite the tendency that software is written more often by artificial intelligence than humans, complexity stays complexity. The less complex conceptions any kind of intelligence should operate, the more efficient it will be.

package/dist/ProxyDiContainer.d.ts

@@ -1,5 +1,5 @@
-import { IProxyDiContainer as IProxyDiContainer, ContainerizedDependency as ContainerizedDependency, DependencyClass } from './types';
-import { ContainerSettings as ContainerSettings, DependencyId } from './types';
+import { IProxyDiContainer as IProxyDiContainer, ContainerizedDependency as ContainerizedDependency, DependencyClass, ResolveScope, DependencyId, RegisterOptions } from './types';
+import { ContainerSettings as ContainerSettings } from './types';
 import { MiddlewareRegistrator, MiddlewareRemover, MiddlewareResolver } from './middleware/middleware.api';
 /**
  * A dependency injection container
@@ -26,6 +26,10 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * Holds proxies for dependencies registered in parent containers to provide for it dependencies from this container
      */
     private inContextProxies;
+    /**
+     * Mapping from dependency instance to all IDs under which it was registered
+     */
+    private dependencyIds;
     /**
      * Settings that control the behavior of the container and it's children
      */
@@ -44,18 +48,18 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * In case of class, it will be instantiated without any parameters.
      *
      * @param dependency The dependency instance or dependency class.
-     * @param dependencyId The unique identifier for the dependency in this container. Can be a string, symbol, or class constructor (which will be normalized to class name).
-     * @throws Error if dependency is already registered and rewriting is not allowed or if invalid dependency (not object) is provided and this it now allowed.
+     * @param dependencyId The unique identifier(s) for the dependency in this container. Can be a string, symbol, array or class constructor (which will be normalized to class name or @injectable IDs).
      * @returns Dependency instance, registered in container
      */
-    register<T>(DependencyClass: DependencyClass<T>, dependencyId?: DependencyId | DependencyClass<any>): T & ContainerizedDependency;
-    register<T>(dependency: T extends new (...args: any[]) => any ? never : T, dependencyId?: DependencyId | DependencyClass<any>): T & ContainerizedDependency;
+    register<T>(DependencyClass: DependencyClass<T>, options?: RegisterOptions | DependencyId | DependencyId[] | DependencyClass<any>): T & ContainerizedDependency;
+    register<T>(dependency: T extends new (...args: any[]) => any ? never : T, options?: RegisterOptions | DependencyId | DependencyId[] | DependencyClass<any>): T & ContainerizedDependency;
     /**
      * 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. Can be a string, symbol, or class constructor (which will be normalized to class name).
      * @returns True if the dependency is known, false otherwise.
      */
-    isKnown(dependencyId: DependencyId | DependencyClass<any>): boolean;
+    isKnown(dependencyId: DependencyId | DependencyClass<any>, scope?: ResolveScope): boolean;
+    private isKnownById;
     /**
      * Checks if a dependency with the given ID exists in this container only (does not check parents)
      * @param dependencyId The identifier of the dependency. Can be a string, symbol, or class constructor (which will be normalized to class name).
@@ -68,9 +72,17 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * @returns The resolved dependency instance with container metadata.
      * @throws Error if the dependency cannot be found or is not auto injectable.
      */
-    resolve<T>(dependencyId: DependencyId): T & ContainerizedDependency;
-    resolve<T extends DependencyClass<any>>(SomeClass: T): InstanceType<T> & ContainerizedDependency;
-    private resolveImpl;
+    resolve<T>(dependency: DependencyId, scope?: ResolveScope): T & ContainerizedDependency;
+    resolve<T extends DependencyClass<any>>(dependency: T, scope?: ResolveScope): InstanceType<T> & ContainerizedDependency;
+    resolveAll<T>(dependencyId: DependencyId, scope?: ResolveScope): (T & ContainerizedDependency)[];
+    resolveAll<T extends DependencyClass<any>>(dependencyId: T, scope?: ResolveScope): (InstanceType<T> & ContainerizedDependency)[];
+    private resolveById;
+    private autoRegisterInjectable;
+    private autoRegisterAllInjectables;
+    private getContextProxy;
+    private recursiveResolveAll;
+    private findFirstInScope;
+    private dedupe;
     /**
      * 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.
@@ -82,8 +94,7 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      */
     registerInjectables(): this;
     /**
-     * Finalizes dependency injections, prevents further rewriting of dependencies,
-     * and recursively bakes injections for child containers.
+     * Finalizes dependency injections and recursively bakes injections for child containers.
      */
     bakeInjections(): void;
     /**
@@ -101,18 +112,6 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * recursively destroying child containers and removing itself from its parent.
      */
     destroy(): void;
-    /**
-     * Recursively finds a dependency by its ID from this container or its parent.
-     * @param dependencyId The identifier of the dependency to find.
-     * @returns The dependency if found, otherwise undefined.
-     */
-    private findDependency;
-    /**
-     * Normalizes dependency identifier by converting class constructors to their names.
-     * @param id The dependency identifier (string, symbol, or class constructor).
-     * @returns Normalized dependency identifier (string or symbol).
-     */
-    private normalizeDependencyId;
     /**
      * All direct descendants of this container
      */
@@ -134,4 +133,13 @@ export declare class ProxyDiContainer implements IProxyDiContainer {
      * @param id The identifier of the child container to remove.
      */
     private removeChild;
+    private normalizeDependencyIds;
+    private normalizeRegisterOptions;
+    private normalizeToIds;
+    private addDependencyInstance;
+    private notifyOnRegister;
+    private getAllOwnDependencies;
+    private removeById;
+    private removeByInstance;
+    private removeDependencyBinding;
 }