ts-ioc-container 31.4.0 → 31.5.0

package/README.md

@@ -33,9 +33,9 @@
     - [Singleton](#singleton) `singleton`
     - [Arguments](#arguments) `args`
     - [Visibility](#visibility) `visible`
+    - [Alias](#alias) `alias`
 - [Registration](#registration) `@register(key('someKey'))`
     - [Scope](#scope) `scope`
-    - [Alias](#alias) `alias`
 - [Module](#module)
 - [Hook](#hook) `@hook`
     - [OnConstruct](#onconstruct) `@onConstruct`
@@ -657,105 +657,28 @@ describe('Visibility', function () {
 
 ```
 
-## Registration
-Registration is provider factory which registers provider in container.
-- `@register(key('logger'))`
-- `Registration.fromClass(Logger).to('logger')`
-- `Registration.fromClass(Logger)`
-- `Registration.fromValue(Logger)`
-- `Registration.fromFn((container, ...args) => container.resolve(Logger, {args}))`
-
-```typescript
-import 'reflect-metadata';
-import { Container, key, MetadataInjector, provider, register, Registration as R, scope, singleton } from 'ts-ioc-container';
-import { DependencyMissingKeyError } from '../../lib/errors/DependencyMissingKeyError';
-
-describe('Registration module', function () {
-  const createContainer = () => new Container(new MetadataInjector(), { tags: ['root'] });
-
-  it('should register class', function () {
-    @register(key('ILogger'), scope((s) => s.hasTag('root')))
-    @provider(singleton())
-    class Logger {}
-
-    const root = createContainer().add(R.fromClass(Logger));
-
-    expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
-  });
-
-  it('should register value', function () {
-    const root = createContainer().add(R.fromValue('smth').to('ISmth'));
-
-    expect(root.resolve('ISmth')).toBe('smth');
-  });
-
-  it('should register fn', function () {
-    const root = createContainer().add(R.fromFn(() => 'smth').to('ISmth'));
-
-    expect(root.resolve('ISmth')).toBe('smth');
-  });
-
-  it('should raise an error if key is not provider', () => {
-    expect(() => {
-      createContainer().add(R.fromValue('smth'));
-    }).toThrowError(DependencyMissingKeyError);
-  });
-
-  it('should register dependency by class name if @key is not provided', function () {
-    class FileLogger {}
-
-    const root = createContainer().add(R.fromClass(FileLogger));
-
-    expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
-  });
-});
-
-```
-
-### Scope
-Sometimes you need to register provider only in scope which matches to certain condition and their sub scopes. Especially if you want to register dependency as singleton for some tags, for example `root`
-- `@register(scope((container) => container.hasTag('root'))` - register provider only in root scope
-- `Registration.fromClass(Logger).when((container) => container.hasTag('root'))`
-
-```typescript
-import 'reflect-metadata';
-import { singleton, Container, key, provider, MetadataInjector, Registration as R, scope, register } from 'ts-ioc-container';
-
-@register(key('ILogger'), scope((s) => s.hasTag('root')))
-@provider(singleton()) // the same as .pipe(singleton(), scope((s) => s.hasTag('root')))
-class Logger {}
-describe('ScopeProvider', function () {
-  it('should return the same instance', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger));
-    const child = root.createScope();
-    expect(root.resolve('ILogger')).toBe(child.resolve('ILogger'));
-  });
-});
-
-```
-
 ### Alias
 Alias is needed to group keys
-- `@register(alias('logger'))` helper assigns `logger` alias to registration.
+- `@provider(alias('logger'))` helper assigns `logger` alias to registration.
 - `by.aliases((it) => it.has('logger') || it.has('a'))` resolves dependencies which have `logger` or `a` aliases
-- `Registration.fromClass(Logger).addAliases('logger')`
+- `Provider.fromClass(Logger).pipe(alias('logger'))`
 
 ```typescript
 import 'reflect-metadata';
 import {
+  alias,
   by,
   Container,
+  DependencyNotFoundError,
   inject,
   MetadataInjector,
+  provider,
   Registration as R,
-  register,
-  alias,
-  DependencyNotFoundError,
 } from 'ts-ioc-container';
 
 describe('alias', () => {
   const IMiddlewareKey = 'IMiddleware';
-  const middleware = register(alias(IMiddlewareKey));
+  const middleware = provider(alias(IMiddlewareKey));
 
   interface IMiddleware {
     applyTo(application: IApplication): void;
@@ -816,7 +739,7 @@ describe('alias', () => {
   });
 
   it('should resolve by some alias', () => {
-    @register(alias('ILogger'))
+    @provider(alias('ILogger'))
     class FileLogger {}
 
     const container = new Container(new MetadataInjector()).add(R.fromClass(FileLogger));
@@ -829,6 +752,83 @@ describe('alias', () => {
 ```
 
 
+## Registration
+Registration is provider factory which registers provider in container.
+- `@register(key('logger'))`
+- `Registration.fromClass(Logger).to('logger')`
+- `Registration.fromClass(Logger)`
+- `Registration.fromValue(Logger)`
+- `Registration.fromFn((container, ...args) => container.resolve(Logger, {args}))`
+
+```typescript
+import 'reflect-metadata';
+import { Container, key, MetadataInjector, provider, register, Registration as R, scope, singleton } from 'ts-ioc-container';
+import { DependencyMissingKeyError } from '../../lib/errors/DependencyMissingKeyError';
+
+describe('Registration module', function () {
+  const createContainer = () => new Container(new MetadataInjector(), { tags: ['root'] });
+
+  it('should register class', function () {
+    @register(key('ILogger'), scope((s) => s.hasTag('root')))
+    @provider(singleton())
+    class Logger {}
+
+    const root = createContainer().add(R.fromClass(Logger));
+
+    expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
+  });
+
+  it('should register value', function () {
+    const root = createContainer().add(R.fromValue('smth').to('ISmth'));
+
+    expect(root.resolve('ISmth')).toBe('smth');
+  });
+
+  it('should register fn', function () {
+    const root = createContainer().add(R.fromFn(() => 'smth').to('ISmth'));
+
+    expect(root.resolve('ISmth')).toBe('smth');
+  });
+
+  it('should raise an error if key is not provider', () => {
+    expect(() => {
+      createContainer().add(R.fromValue('smth'));
+    }).toThrowError(DependencyMissingKeyError);
+  });
+
+  it('should register dependency by class name if @key is not provided', function () {
+    class FileLogger {}
+
+    const root = createContainer().add(R.fromClass(FileLogger));
+
+    expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
+  });
+});
+
+```
+
+### Scope
+Sometimes you need to register provider only in scope which matches to certain condition and their sub scopes. Especially if you want to register dependency as singleton for some tags, for example `root`
+- `@register(scope((container) => container.hasTag('root'))` - register provider only in root scope
+- `Registration.fromClass(Logger).when((container) => container.hasTag('root'))`
+
+```typescript
+import 'reflect-metadata';
+import { singleton, Container, key, provider, MetadataInjector, Registration as R, scope, register } from 'ts-ioc-container';
+
+@register(key('ILogger'), scope((s) => s.hasTag('root')))
+@provider(singleton()) // the same as .pipe(singleton(), scope((s) => s.hasTag('root')))
+class Logger {}
+describe('ScopeProvider', function () {
+  it('should return the same instance', function () {
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger));
+    const child = root.createScope();
+    expect(root.resolve('ILogger')).toBe(child.resolve('ILogger'));
+  });
+});
+
+```
+
 ## Module
 Sometimes you want to encapsulate registration logic in separate module. This is what `IContainerModule` is for.
 

package/cjm/by.js

@@ -1,35 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.by = exports.resolveSilently = exports.isPresent = exports.all = void 0;
-const DependencyNotFoundError_1 = require("./errors/DependencyNotFoundError");
+exports.by = exports.all = void 0;
 const all = () => true;
 exports.all = all;
-const isPresent = (value) => value !== null && value !== undefined;
-exports.isPresent = isPresent;
-const resolveSilently = (c, ...args) => (key) => {
-    try {
-        return c.resolve(key, { args });
-    }
-    catch (e) {
-        if (e instanceof DependencyNotFoundError_1.DependencyNotFoundError) {
-            return undefined;
-        }
-        throw e;
-    }
-};
-exports.resolveSilently = resolveSilently;
 exports.by = {
-    aliases: (predicate) => (c, ...args) => c
-        .getKeysByAlias(predicate)
-        .map((0, exports.resolveSilently)(c, ...args))
-        .filter(exports.isPresent),
+    aliases: (predicate) => (c, ...args) => c.resolveManyByAlias(predicate, { args }).values(),
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
      */
     alias: (predicate) => (c, ...args) => {
-        const key = c.getKeyByAlias(predicate);
-        return c.resolve(key, { args });
+        return c.resolveOneByAlias(predicate, { args });
     },
     /**
      * Get all instances that match the given keys

package/cjm/container/AutoMockedContainer.js

@@ -2,13 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoMockedContainer = void 0;
 const MethodNotImplementedError_1 = require("../errors/MethodNotImplementedError");
+const DependencyNotFoundError_1 = require("../errors/DependencyNotFoundError");
 class AutoMockedContainer {
     constructor() {
         this.isDisposed = false;
     }
-    getKeysByAlias(alias) {
-        return [];
-    }
     hasDependency(key) {
         return false;
     }
@@ -35,8 +33,11 @@ class AutoMockedContainer {
     add(registration) {
         return this;
     }
-    getKeyByAlias(alias) {
-        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    resolveManyByAlias(predicate, options = {}, result = new Map()) {
+        return result;
+    }
+    resolveOneByAlias(predicate, options) {
+        throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find by alias`);
     }
 }
 exports.AutoMockedContainer = AutoMockedContainer;

package/cjm/container/Container.js

@@ -9,7 +9,6 @@ class Container {
         this.injector = injector;
         this.isDisposed = false;
         this.providers = new Map();
-        this.aliases = new Map();
         this.scopes = new Set();
         this.instances = new Set();
         this.registrations = [];
@@ -21,12 +20,9 @@ class Container {
         registration.applyTo(this);
         return this;
     }
-    register(key, provider, aliases) {
+    register(key, provider) {
         this.validateContainer();
         this.providers.set(key, provider);
-        if (aliases && aliases.length > 0) {
-            this.aliases.set(key, new Set(aliases));
-        }
         return this;
     }
     resolve(token, { args = [], child = this } = {}) {
@@ -77,22 +73,21 @@ class Container {
     hasDependency(key) {
         return this.providers.has(key) ?? this.parent.hasDependency(key);
     }
-    getKeysByAlias(predicate) {
-        const result = new Set(this.parent.getKeysByAlias(predicate));
-        for (const [key, aliases] of this.aliases.entries()) {
-            if (predicate(aliases)) {
-                result.add(key);
+    resolveManyByAlias(predicate, { args = [], child = this } = {}, result = new Map()) {
+        for (const [key, provider] of this.providers.entries()) {
+            if (!result.has(key) && provider.matchAliases(predicate) && provider.isVisible(this, child)) {
+                result.set(key, provider.resolve(this, ...args));
             }
         }
-        return Array.from(result);
+        return this.parent.resolveManyByAlias(predicate, { args, child }, result);
     }
-    getKeyByAlias(predicate) {
-        for (const [key, aliases] of this.aliases.entries()) {
-            if (predicate(aliases)) {
-                return key;
+    resolveOneByAlias(predicate, { args = [], child = this } = {}) {
+        for (const [, provider] of this.providers.entries()) {
+            if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
+                return provider.resolve(this, ...args);
             }
         }
-        return this.parent.getKeyByAlias(predicate);
+        return this.parent.resolveOneByAlias(predicate, { args, child });
     }
     /**
      * @private

package/cjm/container/EmptyContainer.js

@@ -7,9 +7,6 @@ class EmptyContainer {
     constructor() {
         this.isDisposed = false;
     }
-    getKeysByAlias(alias) {
-        return [];
-    }
     hasDependency(key) {
         return false;
     }
@@ -41,7 +38,10 @@ class EmptyContainer {
     add(registration) {
         return this;
     }
-    getKeyByAlias(alias) {
+    resolveManyByAlias(predicate, options = {}, result = new Map()) {
+        return result;
+    }
+    resolveOneByAlias(predicate, options) {
         throw new DependencyNotFoundError_1.DependencyNotFoundError(`Cannot find by alias`);
     }
 }

package/cjm/index.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.register = exports.scope = exports.alias = exports.key = exports.Registration = exports.AutoMockedContainer = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.ProviderDecorator = exports.Provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.visible = exports.provider = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
+exports.getParameterMetadata = exports.getMethodMetadata = exports.setMethodMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = exports.hasHooks = exports.hook = exports.getHooks = exports.ProxyInjector = exports.SimpleInjector = exports.inject = exports.MetadataInjector = exports.Registration = exports.register = exports.scope = exports.key = exports.AutoMockedContainer = exports.MultiCache = exports.SingletonProvider = exports.singleton = exports.ArgsProvider = exports.args = exports.argsFn = exports.ProviderDecorator = exports.Provider = exports.alias = exports.visible = exports.provider = exports.ContainerDisposedError = exports.MethodNotImplementedError = exports.DependencyNotFoundError = exports.EmptyContainer = exports.Container = exports.isDependencyKey = void 0;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
 Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return Container_1.Container; } });
 var EmptyContainer_1 = require("./container/EmptyContainer");
 Object.defineProperty(exports, "EmptyContainer", { enumerable: true, get: function () { return EmptyContainer_1.EmptyContainer; } });
-var IProvider_1 = require("./provider/IProvider");
-Object.defineProperty(exports, "provider", { enumerable: true, get: function () { return IProvider_1.provider; } });
-Object.defineProperty(exports, "visible", { enumerable: true, get: function () { return IProvider_1.visible; } });
 var DependencyNotFoundError_1 = require("./errors/DependencyNotFoundError");
 Object.defineProperty(exports, "DependencyNotFoundError", { enumerable: true, get: function () { return DependencyNotFoundError_1.DependencyNotFoundError; } });
 var MethodNotImplementedError_1 = require("./errors/MethodNotImplementedError");
 Object.defineProperty(exports, "MethodNotImplementedError", { enumerable: true, get: function () { return MethodNotImplementedError_1.MethodNotImplementedError; } });
 var ContainerDisposedError_1 = require("./errors/ContainerDisposedError");
 Object.defineProperty(exports, "ContainerDisposedError", { enumerable: true, get: function () { return ContainerDisposedError_1.ContainerDisposedError; } });
+var IProvider_1 = require("./provider/IProvider");
+Object.defineProperty(exports, "provider", { enumerable: true, get: function () { return IProvider_1.provider; } });
+Object.defineProperty(exports, "visible", { enumerable: true, get: function () { return IProvider_1.visible; } });
+Object.defineProperty(exports, "alias", { enumerable: true, get: function () { return IProvider_1.alias; } });
 var Provider_1 = require("./provider/Provider");
 Object.defineProperty(exports, "Provider", { enumerable: true, get: function () { return Provider_1.Provider; } });
 var ProviderDecorator_1 = require("./provider/ProviderDecorator");
@@ -31,13 +32,12 @@ var MultiCache_1 = require("./provider/singleton/MultiCache");
 Object.defineProperty(exports, "MultiCache", { enumerable: true, get: function () { return MultiCache_1.MultiCache; } });
 var AutoMockedContainer_1 = require("./container/AutoMockedContainer");
 Object.defineProperty(exports, "AutoMockedContainer", { enumerable: true, get: function () { return AutoMockedContainer_1.AutoMockedContainer; } });
-var Registration_1 = require("./registration/Registration");
-Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return Registration_1.Registration; } });
 var IRegistration_1 = require("./registration/IRegistration");
 Object.defineProperty(exports, "key", { enumerable: true, get: function () { return IRegistration_1.key; } });
-Object.defineProperty(exports, "alias", { enumerable: true, get: function () { return IRegistration_1.alias; } });
 Object.defineProperty(exports, "scope", { enumerable: true, get: function () { return IRegistration_1.scope; } });
 Object.defineProperty(exports, "register", { enumerable: true, get: function () { return IRegistration_1.register; } });
+var Registration_1 = require("./registration/Registration");
+Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return Registration_1.Registration; } });
 var MetadataInjector_1 = require("./injector/MetadataInjector");
 Object.defineProperty(exports, "MetadataInjector", { enumerable: true, get: function () { return MetadataInjector_1.MetadataInjector; } });
 Object.defineProperty(exports, "inject", { enumerable: true, get: function () { return MetadataInjector_1.inject; } });

package/cjm/provider/IProvider.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visible = exports.getTransformers = exports.provider = void 0;
+exports.visible = exports.alias = exports.getTransformers = exports.provider = void 0;
 const metadata_1 = require("../metadata");
 const METADATA_KEY = 'provider';
 const provider = (...mappers) => (0, metadata_1.setMetadata)(METADATA_KEY, mappers);
 exports.provider = provider;
 const getTransformers = (Target) => (0, metadata_1.getMetadata)(Target, METADATA_KEY) ?? [];
 exports.getTransformers = getTransformers;
+const alias = (...aliases) => (r) => r.addAliases(...aliases);
+exports.alias = alias;
 const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);
 exports.visible = visible;

package/cjm/provider/Provider.js

@@ -15,6 +15,7 @@ class Provider {
     constructor(resolveDependency, isVisibleWhen = () => true) {
         this.resolveDependency = resolveDependency;
         this.isVisibleWhen = isVisibleWhen;
+        this.aliases = new Set();
     }
     pipe(...mappers) {
         return (0, utils_1.pipe)(...mappers)(this);
@@ -29,5 +30,14 @@ class Provider {
     isVisible(parent, child) {
         return this.isVisibleWhen({ child, isParent: child === parent });
     }
+    matchAliases(predicate) {
+        return this.aliases.size > 0 && predicate(this.aliases);
+    }
+    addAliases(...aliases) {
+        for (const alias of aliases) {
+            this.aliases.add(alias);
+        }
+        return this;
+    }
 }
 exports.Provider = Provider;

package/cjm/provider/ProviderDecorator.js

@@ -19,5 +19,12 @@ class ProviderDecorator {
     pipe(...mappers) {
         return (0, utils_1.pipe)(...mappers)(this);
     }
+    matchAliases(predicate) {
+        return this.decorated.matchAliases(predicate);
+    }
+    addAliases(...aliases) {
+        this.decorated.addAliases(...aliases);
+        return this;
+    }
 }
 exports.ProviderDecorator = ProviderDecorator;

package/cjm/registration/IRegistration.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.register = exports.getTransformers = exports.scope = exports.alias = exports.key = void 0;
+exports.register = exports.getTransformers = exports.scope = exports.key = void 0;
 const metadata_1 = require("../metadata");
 const key = (key) => (r) => r.to(key);
 exports.key = key;
-const alias = (...aliases) => (r) => r.addAliases(...aliases);
-exports.alias = alias;
 const scope = (predicate) => (r) => r.when(predicate);
 exports.scope = scope;
 const METADATA_KEY = 'registration';

package/cjm/registration/Registration.js

@@ -24,19 +24,12 @@ class Registration {
         this.createProvider = createProvider;
         this.key = key;
         this.matchScope = matchScope;
-        this.aliases = [];
         this.mappers = [];
     }
     to(key) {
         this.key = key;
         return this;
     }
-    addAliases(...aliases) {
-        for (const alias of aliases) {
-            this.aliases.push(alias);
-        }
-        return this;
-    }
     pipe(...mappers) {
         this.mappers.push(...mappers);
         return this;
@@ -48,7 +41,7 @@ class Registration {
         if (!this.key) {
             throw new DependencyMissingKeyError_1.DependencyMissingKeyError('No key provided for registration');
         }
-        container.register(this.key, this.createProvider().pipe(...this.mappers), this.aliases);
+        container.register(this.key, this.createProvider().pipe(...this.mappers));
     }
     when(isValidWhen) {
         this.matchScope = isValidWhen;

package/esm/by.js

@@ -1,29 +1,12 @@
-import { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export const all = () => true;
-export const isPresent = (value) => value !== null && value !== undefined;
-export const resolveSilently = (c, ...args) => (key) => {
-    try {
-        return c.resolve(key, { args });
-    }
-    catch (e) {
-        if (e instanceof DependencyNotFoundError) {
-            return undefined;
-        }
-        throw e;
-    }
-};
 export const by = {
-    aliases: (predicate) => (c, ...args) => c
-        .getKeysByAlias(predicate)
-        .map(resolveSilently(c, ...args))
-        .filter(isPresent),
+    aliases: (predicate) => (c, ...args) => c.resolveManyByAlias(predicate, { args }).values(),
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate
      */
     alias: (predicate) => (c, ...args) => {
-        const key = c.getKeyByAlias(predicate);
-        return c.resolve(key, { args });
+        return c.resolveOneByAlias(predicate, { args });
     },
     /**
      * Get all instances that match the given keys

package/esm/container/AutoMockedContainer.js

@@ -1,11 +1,9 @@
 import { MethodNotImplementedError } from '../errors/MethodNotImplementedError';
+import { DependencyNotFoundError } from '../errors/DependencyNotFoundError';
 export class AutoMockedContainer {
     constructor() {
         this.isDisposed = false;
     }
-    getKeysByAlias(alias) {
-        return [];
-    }
     hasDependency(key) {
         return false;
     }
@@ -32,7 +30,10 @@ export class AutoMockedContainer {
     add(registration) {
         return this;
     }
-    getKeyByAlias(alias) {
-        throw new MethodNotImplementedError();
+    resolveManyByAlias(predicate, options = {}, result = new Map()) {
+        return result;
+    }
+    resolveOneByAlias(predicate, options) {
+        throw new DependencyNotFoundError(`Cannot find by alias`);
     }
 }

package/esm/container/Container.js

@@ -6,7 +6,6 @@ export class Container {
         this.injector = injector;
         this.isDisposed = false;
         this.providers = new Map();
-        this.aliases = new Map();
         this.scopes = new Set();
         this.instances = new Set();
         this.registrations = [];
@@ -18,12 +17,9 @@ export class Container {
         registration.applyTo(this);
         return this;
     }
-    register(key, provider, aliases) {
+    register(key, provider) {
         this.validateContainer();
         this.providers.set(key, provider);
-        if (aliases && aliases.length > 0) {
-            this.aliases.set(key, new Set(aliases));
-        }
         return this;
     }
     resolve(token, { args = [], child = this } = {}) {
@@ -74,22 +70,21 @@ export class Container {
     hasDependency(key) {
         return this.providers.has(key) ?? this.parent.hasDependency(key);
     }
-    getKeysByAlias(predicate) {
-        const result = new Set(this.parent.getKeysByAlias(predicate));
-        for (const [key, aliases] of this.aliases.entries()) {
-            if (predicate(aliases)) {
-                result.add(key);
+    resolveManyByAlias(predicate, { args = [], child = this } = {}, result = new Map()) {
+        for (const [key, provider] of this.providers.entries()) {
+            if (!result.has(key) && provider.matchAliases(predicate) && provider.isVisible(this, child)) {
+                result.set(key, provider.resolve(this, ...args));
             }
         }
-        return Array.from(result);
+        return this.parent.resolveManyByAlias(predicate, { args, child }, result);
     }
-    getKeyByAlias(predicate) {
-        for (const [key, aliases] of this.aliases.entries()) {
-            if (predicate(aliases)) {
-                return key;
+    resolveOneByAlias(predicate, { args = [], child = this } = {}) {
+        for (const [, provider] of this.providers.entries()) {
+            if (provider.matchAliases(predicate) && provider.isVisible(this, child)) {
+                return provider.resolve(this, ...args);
             }
         }
-        return this.parent.getKeyByAlias(predicate);
+        return this.parent.resolveOneByAlias(predicate, { args, child });
     }
     /**
      * @private

package/esm/container/EmptyContainer.js

@@ -4,9 +4,6 @@ export class EmptyContainer {
     constructor() {
         this.isDisposed = false;
     }
-    getKeysByAlias(alias) {
-        return [];
-    }
     hasDependency(key) {
         return false;
     }
@@ -38,7 +35,10 @@ export class EmptyContainer {
     add(registration) {
         return this;
     }
-    getKeyByAlias(alias) {
+    resolveManyByAlias(predicate, options = {}, result = new Map()) {
+        return result;
+    }
+    resolveOneByAlias(predicate, options) {
         throw new DependencyNotFoundError(`Cannot find by alias`);
     }
 }

package/esm/index.js

@@ -1,18 +1,18 @@
 export { isDependencyKey, } from './container/IContainer';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
-export { provider, visible } from './provider/IProvider';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
+export { provider, visible, alias } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { ProviderDecorator } from './provider/ProviderDecorator';
 export { argsFn, args, ArgsProvider } from './provider/ArgsProvider';
 export { singleton, SingletonProvider } from './provider/singleton/SingletonProvider';
 export { MultiCache } from './provider/singleton/MultiCache';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
+export { key, scope, register } from './registration/IRegistration';
 export { Registration } from './registration/Registration';
-export { key, alias, scope, register } from './registration/IRegistration';
 export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';

package/esm/provider/IProvider.js

@@ -2,4 +2,5 @@ import { getMetadata, setMetadata } from '../metadata';
 const METADATA_KEY = 'provider';
 export const provider = (...mappers) => setMetadata(METADATA_KEY, mappers);
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
+export const alias = (...aliases) => (r) => r.addAliases(...aliases);
 export const visible = (isVisibleWhen) => (p) => p.setVisibility(isVisibleWhen);

package/esm/provider/Provider.js

@@ -12,6 +12,7 @@ export class Provider {
     constructor(resolveDependency, isVisibleWhen = () => true) {
         this.resolveDependency = resolveDependency;
         this.isVisibleWhen = isVisibleWhen;
+        this.aliases = new Set();
     }
     pipe(...mappers) {
         return pipe(...mappers)(this);
@@ -26,4 +27,13 @@ export class Provider {
     isVisible(parent, child) {
         return this.isVisibleWhen({ child, isParent: child === parent });
     }
+    matchAliases(predicate) {
+        return this.aliases.size > 0 && predicate(this.aliases);
+    }
+    addAliases(...aliases) {
+        for (const alias of aliases) {
+            this.aliases.add(alias);
+        }
+        return this;
+    }
 }

package/esm/provider/ProviderDecorator.js

@@ -16,4 +16,11 @@ export class ProviderDecorator {
     pipe(...mappers) {
         return pipe(...mappers)(this);
     }
+    matchAliases(predicate) {
+        return this.decorated.matchAliases(predicate);
+    }
+    addAliases(...aliases) {
+        this.decorated.addAliases(...aliases);
+        return this;
+    }
 }

package/esm/registration/IRegistration.js

@@ -1,6 +1,5 @@
 import { getMetadata, setMetadata } from '../metadata';
 export const key = (key) => (r) => r.to(key);
-export const alias = (...aliases) => (r) => r.addAliases(...aliases);
 export const scope = (predicate) => (r) => r.when(predicate);
 const METADATA_KEY = 'registration';
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];

package/esm/registration/Registration.js

@@ -21,19 +21,12 @@ export class Registration {
         this.createProvider = createProvider;
         this.key = key;
         this.matchScope = matchScope;
-        this.aliases = [];
         this.mappers = [];
     }
     to(key) {
         this.key = key;
         return this;
     }
-    addAliases(...aliases) {
-        for (const alias of aliases) {
-            this.aliases.push(alias);
-        }
-        return this;
-    }
     pipe(...mappers) {
         this.mappers.push(...mappers);
         return this;
@@ -45,7 +38,7 @@ export class Registration {
         if (!this.key) {
             throw new DependencyMissingKeyError('No key provided for registration');
         }
-        container.register(this.key, this.createProvider().pipe(...this.mappers), this.aliases);
+        container.register(this.key, this.createProvider().pipe(...this.mappers));
     }
     when(isValidWhen) {
         this.matchScope = isValidWhen;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "31.4.0",
+  "version": "31.5.0",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "1374fb632851b79d7f7e119f7ea854037894d72f"
+  "gitHead": "85beba059c9dada4836d784ab8f7ffec08299308"
 }

package/typings/by.d.ts

@@ -1,10 +1,8 @@
-import { AliasPredicate, DependencyKey, IContainer, InjectionToken } from './container/IContainer';
+import { AliasPredicate, IContainer, InjectionToken } from './container/IContainer';
 export type InstancePredicate = (dep: unknown) => boolean;
 export declare const all: InstancePredicate;
-export declare const isPresent: <T>(value: T | null | undefined) => value is T;
-export declare const resolveSilently: (c: IContainer, ...args: unknown[]) => (key: DependencyKey) => unknown;
 export declare const by: {
-    aliases: (predicate: AliasPredicate) => (c: IContainer, ...args: unknown[]) => unknown[];
+    aliases: (predicate: AliasPredicate) => (c: IContainer, ...args: unknown[]) => IterableIterator<unknown>;
     /**
      * Get the instance that matches the given alias or fail
      * @param predicate

package/typings/container/AutoMockedContainer.d.ts

@@ -2,7 +2,6 @@ import { AliasPredicate, DependencyKey, IContainer, InjectionToken, ResolveOptio
 import { IRegistration } from '../registration/IRegistration';
 export declare abstract class AutoMockedContainer implements IContainer {
     isDisposed: boolean;
-    getKeysByAlias(alias: AliasPredicate): DependencyKey[];
     hasDependency(key: string): boolean;
     createScope(): IContainer;
     abstract resolve<T>(key: InjectionToken<T>, options?: ResolveOptions): T;
@@ -14,5 +13,6 @@ export declare abstract class AutoMockedContainer implements IContainer {
     getRegistrations(): never[];
     hasTag(): boolean;
     add(registration: IRegistration): this;
-    getKeyByAlias(alias: AliasPredicate): DependencyKey;
+    resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
 }

package/typings/container/Container.d.ts

@@ -1,4 +1,4 @@
-import { Alias, AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, ResolveOptions, Tag } from './IContainer';
+import { AliasPredicate, DependencyKey, IContainer, IContainerModule, InjectionToken, ResolveOptions, Tag } from './IContainer';
 import { IInjector } from '../injector/IInjector';
 import { IProvider } from '../provider/IProvider';
 import { IRegistration } from '../registration/IRegistration';
@@ -6,7 +6,6 @@ export declare class Container implements IContainer {
     private readonly injector;
     isDisposed: boolean;
     private readonly providers;
-    private readonly aliases;
     private tags;
     private parent;
     private scopes;
@@ -17,7 +16,7 @@ export declare class Container implements IContainer {
         tags?: Tag[];
     });
     add(registration: IRegistration): this;
-    register(key: DependencyKey, provider: IProvider, aliases?: Alias[]): this;
+    register(key: DependencyKey, provider: IProvider): this;
     resolve<T>(token: InjectionToken<T>, { args, child }?: ResolveOptions): T;
     createScope(...tags: Tag[]): Container;
     dispose(): void;
@@ -25,8 +24,8 @@ export declare class Container implements IContainer {
     hasTag(tag: Tag): boolean;
     use(module: IContainerModule): this;
     hasDependency(key: DependencyKey): boolean;
-    getKeysByAlias(predicate: AliasPredicate): DependencyKey[];
-    getKeyByAlias(predicate: AliasPredicate): DependencyKey;
+    resolveManyByAlias(predicate: AliasPredicate, { args, child }?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
+    resolveOneByAlias<T>(predicate: AliasPredicate, { args, child }?: ResolveOptions): T;
     /**
      * @private
      */

package/typings/container/EmptyContainer.d.ts

@@ -3,7 +3,6 @@ import { IProvider } from '../provider/IProvider';
 import { IRegistration } from '../registration/IRegistration';
 export declare class EmptyContainer implements IContainer {
     isDisposed: boolean;
-    getKeysByAlias(alias: AliasPredicate): DependencyKey[];
     hasDependency(key: string): boolean;
     hasTag(): boolean;
     createScope(): IContainer;
@@ -15,5 +14,6 @@ export declare class EmptyContainer implements IContainer {
     removeScope(): void;
     use(module: IContainerModule): this;
     add(registration: IRegistration): this;
-    getKeyByAlias(alias: AliasPredicate): DependencyKey;
+    resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
 }

package/typings/container/IContainer.d.ts

@@ -24,7 +24,7 @@ export type AliasPredicate = (aliases: Set<Alias>) => boolean;
 export interface IContainer extends Resolvable, Tagged {
     readonly isDisposed: boolean;
     createScope(...tags: Tag[]): IContainer;
-    register(key: DependencyKey, value: IProvider, aliases?: Alias[]): this;
+    register(key: DependencyKey, value: IProvider): this;
     add(registration: IRegistration): this;
     removeScope(child: IContainer): void;
     getInstances(): unknown[];
@@ -32,6 +32,6 @@ export interface IContainer extends Resolvable, Tagged {
     use(module: IContainerModule): this;
     getRegistrations(): IRegistration[];
     hasDependency(key: DependencyKey): boolean;
-    getKeysByAlias(alias: AliasPredicate): DependencyKey[];
-    getKeyByAlias(alias: AliasPredicate): DependencyKey;
+    resolveManyByAlias(predicate: AliasPredicate, options?: ResolveOptions, result?: Map<DependencyKey, unknown>): Map<DependencyKey, unknown>;
+    resolveOneByAlias<T>(predicate: AliasPredicate, options?: ResolveOptions): T;
 }

package/typings/index.d.ts

@@ -2,11 +2,11 @@ export { IContainer, Resolvable, IContainerModule, isDependencyKey, DependencyKe
 export { constructor } from './utils';
 export { Container } from './container/Container';
 export { EmptyContainer } from './container/EmptyContainer';
-export { ResolveDependency, IProvider, provider, visible } from './provider/IProvider';
 export { IInjector } from './injector/IInjector';
 export { DependencyNotFoundError } from './errors/DependencyNotFoundError';
 export { MethodNotImplementedError } from './errors/MethodNotImplementedError';
 export { ContainerDisposedError } from './errors/ContainerDisposedError';
+export { ResolveDependency, IProvider, provider, visible, alias } from './provider/IProvider';
 export { Provider } from './provider/Provider';
 export { ProviderDecorator } from './provider/ProviderDecorator';
 export { ArgsFn, argsFn, args, ArgsProvider } from './provider/ArgsProvider';
@@ -14,8 +14,8 @@ export { singleton, SingletonProvider } from './provider/singleton/SingletonProv
 export { MultiCache } from './provider/singleton/MultiCache';
 export { Cache } from './provider/singleton/Cache';
 export { AutoMockedContainer } from './container/AutoMockedContainer';
+export { key, IRegistration, scope, register } from './registration/IRegistration';
 export { Registration } from './registration/Registration';
-export { key, alias, IRegistration, scope, register } from './registration/IRegistration';
 export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';

package/typings/provider/IProvider.d.ts

@@ -1,4 +1,4 @@
-import { IContainer, Tagged } from '../container/IContainer';
+import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 export type ResolveDependency<T = unknown> = (container: IContainer, ...args: unknown[]) => T;
 export type ChildrenVisibilityPredicate = (options: {
@@ -10,7 +10,10 @@ export interface IProvider<T = unknown> {
     isVisible(parent: Tagged, child: Tagged): boolean;
     pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
     setVisibility(isVisibleWhen: ChildrenVisibilityPredicate): this;
+    matchAliases(predicate: AliasPredicate): boolean;
+    addAliases(...aliases: Alias[]): this;
 }
 export declare const provider: (...mappers: MapFn<IProvider>[]) => ClassDecorator;
 export declare const getTransformers: <T>(Target: constructor<T>) => MapFn<IProvider<T>>[];
+export declare const alias: (...aliases: Alias[]) => MapFn<IProvider>;
 export declare const visible: (isVisibleWhen: ChildrenVisibilityPredicate) => MapFn<IProvider>;

package/typings/provider/Provider.d.ts

@@ -1,9 +1,10 @@
 import { ChildrenVisibilityPredicate, IProvider, ResolveDependency } from './IProvider';
-import { IContainer, Tagged } from '../container/IContainer';
+import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 export declare class Provider<T> implements IProvider<T> {
     private readonly resolveDependency;
     private isVisibleWhen;
+    private aliases;
     static fromClass<T>(Target: constructor<T>): IProvider<T>;
     static fromValue<T>(value: T): IProvider<T>;
     constructor(resolveDependency: ResolveDependency<T>, isVisibleWhen?: ChildrenVisibilityPredicate);
@@ -11,4 +12,6 @@ export declare class Provider<T> implements IProvider<T> {
     resolve(container: IContainer, ...args: unknown[]): T;
     setVisibility(predicate: ChildrenVisibilityPredicate): this;
     isVisible(parent: Tagged, child: Tagged): boolean;
+    matchAliases(predicate: AliasPredicate): boolean;
+    addAliases(...aliases: Alias[]): this;
 }

package/typings/provider/ProviderDecorator.d.ts

@@ -1,4 +1,4 @@
-import { IContainer, Tagged } from '../container/IContainer';
+import { Alias, AliasPredicate, IContainer, Tagged } from '../container/IContainer';
 import { ChildrenVisibilityPredicate, IProvider } from './IProvider';
 import { MapFn } from '../utils';
 export declare abstract class ProviderDecorator<T> implements IProvider<T> {
@@ -8,4 +8,6 @@ export declare abstract class ProviderDecorator<T> implements IProvider<T> {
     isVisible(parent: IContainer, child: Tagged): boolean;
     resolve(container: IContainer, ...args: unknown[]): T;
     pipe(...mappers: MapFn<IProvider<T>>[]): IProvider<T>;
+    matchAliases(predicate: AliasPredicate): boolean;
+    addAliases(...aliases: Alias[]): this;
 }

package/typings/registration/IRegistration.d.ts

@@ -1,15 +1,13 @@
-import { Alias, DependencyKey, IContainerModule, Tagged } from '../container/IContainer';
+import { DependencyKey, IContainerModule, Tagged } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 import { IProvider } from '../provider/IProvider';
 export type ScopePredicate = (c: Tagged) => boolean;
 export interface IRegistration<T = unknown> extends IContainerModule {
-    addAliases(...aliases: Alias[]): this;
     when(isValidWhen: ScopePredicate): this;
     to(key: DependencyKey): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
 }
 export declare const key: (key: DependencyKey) => MapFn<IRegistration>;
-export declare const alias: (...aliases: Alias[]) => MapFn<IRegistration>;
 export declare const scope: (predicate: ScopePredicate) => MapFn<IRegistration>;
 export declare const getTransformers: (Target: constructor<unknown>) => MapFn<IRegistration<unknown>>[];
 export declare const register: (...mappers: MapFn<IRegistration>[]) => ClassDecorator;

package/typings/registration/Registration.d.ts

@@ -1,4 +1,4 @@
-import { Alias, DependencyKey, IContainer } from '../container/IContainer';
+import { DependencyKey, IContainer } from '../container/IContainer';
 import { constructor, MapFn } from '../utils';
 import { IProvider, ResolveDependency } from '../provider/IProvider';
 import { IRegistration, ScopePredicate } from './IRegistration';
@@ -9,11 +9,9 @@ export declare class Registration<T = unknown> implements IRegistration<T> {
     static fromClass<T>(Target: constructor<T>): IRegistration<unknown>;
     static fromValue<T>(value: T): IRegistration<unknown>;
     static fromFn<T>(fn: ResolveDependency<T>): Registration<T>;
-    private aliases;
     private mappers;
     constructor(createProvider: () => IProvider<T>, key?: DependencyKey | undefined, matchScope?: ScopePredicate);
     to(key: DependencyKey): this;
-    addAliases(...aliases: Alias[]): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
     applyTo(container: IContainer): void;
     when(isValidWhen: ScopePredicate): this;