ts-ioc-container 31.1.2 → 31.1.4

package/README.md

@@ -22,26 +22,26 @@
 - [Setup](#setup)
 - [Container](#container)
     - [Basic usage](#basic-usage)
-    - [Scopes](#scopes)
+    - [Scope](#scope) `tags`
     - [Instances](#instances)
-    - [Disposing](#disposing)
-- [Injectors](#injectors)
-    - [Metadata injector](#metadata-injector) `@inject`
-    - [Simple injector](#simple-injector)
-    - [Proxy injector](#proxy-injector)
-- [Providers](#providers)
-    - [Registration module (Provider + DependencyKey)](#registration-and-providers) `@key`
-    - [Provider](#provider) `@provider`
-    - [Singleton provider](#singleton-provider)
-    - [Scope provider](#scope-provider)
-    - [Args provider](#args-provider)
-    - [Aliases](#aliases) `alias`
-- [Container modules](#container-modules)
-- [Hooks](#hooks) `@hook`
+    - [Dispose](#dispose)
+- [Injector](#injector)
+    - [Metadata](#metadata) `@inject`
+    - [Simple](#simple)
+    - [Proxy](#proxy)
+    - [Visibility](#visibility) `visible`
+- [Provider](#provider) `@provider`
+    - [Singleton](#singleton) `singleton`
+    - [Arguments](#arguments) `args`
+- [Registration](#registration) `@registration`
+    - [Scope](#scope) `scope`
+    - [Alias](#alias) `alias`
+- [Module](#module)
+- [Hook](#hook) `@hook`
     - [OnConstruct](#onconstruct) `@onConstruct`
     - [OnDispose](#ondispose) `@onDispose`
-- [Tests and Mocks](#tests-and-mocks)
-- [Errors](#errors)
+- [Mock](#mock)
+- [Error](#error)
 
 ## Setup
 
@@ -68,10 +68,11 @@ And `tsconfig.json` should have next options:
 ```
 
 ## Container
-`IContainer` consists of 2 main parts:
+`IContainer` consists of:
 
-- Providers - describes how to create instances of dependencies
-- Injector - describes how to inject dependencies to constructor
+- Provider is dependency factory which creates dependency
+- Injector describes how to inject dependencies to constructor
+- Registration is provider factory which registers provider in container
 
 ### Basic usage
 
@@ -89,7 +90,7 @@ describe('Basic usage', function () {
       constructor(@inject(by.key('ILogger')) public logger: Logger) {}
     }
 
-    const container = new Container(new MetadataInjector()).addRegistration(R.fromClass(Logger).to('ILogger'));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger).to('ILogger'));
 
     expect(container.resolve(App).logger.name).toBe('Logger');
   });
@@ -100,8 +101,8 @@ describe('Basic usage', function () {
     }
 
     const container = new Container(new MetadataInjector())
-      .addRegistration(R.fromClass(Logger).to('ILogger1'))
-      .addRegistration(R.fromClass(Logger).to('ILogger2'));
+      .add(R.fromClass(Logger).to('ILogger1'))
+      .add(R.fromClass(Logger).to('ILogger2'));
 
     expect(container.resolve(App).loggers).toHaveLength(2);
   });
@@ -121,7 +122,7 @@ describe('Basic usage', function () {
 
 ```
 
-### Scopes
+### Scope
 Sometimes you need to create a scope of container. For example, when you want to create a scope per request in web application. You can assign tags to scope and provider and resolve dependencies only from certain scope.
 
 - NOTICE: remember that when scope doesn't have dependency then it will be resolved from parent container
@@ -151,7 +152,7 @@ class Logger {}
 
 describe('Scopes', function () {
   it('should resolve dependencies from scope', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).addRegistration(R.fromClass(Logger));
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger));
     const child = root.createScope('child');
 
     expect(child.resolve('ILogger')).toBe(child.resolve('ILogger'));
@@ -188,7 +189,7 @@ describe('Instances', function () {
   class Logger {}
 
   it('should return injected instances', () => {
-    const container = new Container(new MetadataInjector()).addRegistration(R.fromClass(Logger));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger));
     const scope = container.createScope();
 
     const logger1 = container.resolve('ILogger');
@@ -205,7 +206,7 @@ describe('Instances', function () {
       constructor(@inject(by.instances(isLogger)) public loggers: Logger[]) {}
     }
 
-    const container = new Container(new MetadataInjector()).addRegistration(R.fromClass(Logger));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger));
 
     const logger0 = container.resolve('ILogger');
     const logger1 = container.resolve('ILogger');
@@ -219,7 +220,7 @@ describe('Instances', function () {
 
 ```
 
-### Disposing
+### Dispose
 Sometimes you want to dispose container and all its scopes. For example, when you want to prevent memory leaks. Or you want to ensure that nobody can use container after it was disposed.
 
 - container can be disposed
@@ -234,9 +235,7 @@ class Logger {}
 
 describe('Disposing', function () {
   it('should container and make it unavailable for the further usage', function () {
-    const root = new Container(new MetadataInjector(), { tags: ['root'] }).addRegistration(
-      R.fromClass(Logger).to('ILogger'),
-    );
+    const root = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(Logger).to('ILogger'));
     const child = root.createScope('child');
 
     const logger = child.resolve('ILogger');
@@ -250,14 +249,14 @@ describe('Disposing', function () {
 
 ```
 
-## Injectors
+## Injector
 `IInjector` is used to describe how dependencies should be injected to constructor.
 
 - `MetadataInjector` - injects dependencies using `@inject` decorator
 - `ProxyInjector` - injects dependencies as dictionary `Record<string, unknown>`
 - `SimpleInjector` - just passes container to constructor with others arguments
 
-### Metadata injector
+### Metadata
 This type of injector uses `@inject` decorator to mark where dependencies should be injected. It's bases on `reflect-metadata` package. That's why I call it `MetadataInjector`.
 
 ```typescript
@@ -282,7 +281,7 @@ class App {
 
 describe('Reflection Injector', function () {
   it('should inject dependencies by @inject decorator', function () {
-    const container = new Container(new MetadataInjector()).addRegistration(R.fromClass(Logger).to('ILogger'));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger).to('ILogger'));
 
     const app = container.resolve(App);
 
@@ -292,7 +291,7 @@ describe('Reflection Injector', function () {
 
 ```
 
-### Simple injector
+### Simple
 This type of injector just passes container to constructor with others arguments.
 
 ```typescript
@@ -305,7 +304,7 @@ describe('SimpleInjector', function () {
       constructor(public container: IContainer) {}
     }
 
-    const container = new Container(new SimpleInjector()).addRegistration(R.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).add(R.fromClass(App).to('App'));
     const app = container.resolve<App>('App');
 
     expect(app.container).toBeInstanceOf(Container);
@@ -319,7 +318,7 @@ describe('SimpleInjector', function () {
       ) {}
     }
 
-    const container = new Container(new SimpleInjector()).addRegistration(R.fromClass(App).to('App'));
+    const container = new Container(new SimpleInjector()).add(R.fromClass(App).to('App'));
     const app = container.resolve<App>('App', { args: ['Hello world'] });
 
     expect(app.greeting).toBe('Hello world');
@@ -328,7 +327,7 @@ describe('SimpleInjector', function () {
 
 ```
 
-### Proxy injector
+### Proxy
 This type of injector injects dependencies as dictionary `Record<string, unknown>`.
 
 ```typescript
@@ -347,7 +346,7 @@ describe('ProxyInjector', function () {
       }
     }
 
-    const container = new Container(new ProxyInjector()).addRegistration(R.fromClass(Logger).to('logger'));
+    const container = new Container(new ProxyInjector()).add(R.fromClass(Logger).to('logger'));
 
     const app = container.resolve(App);
     expect(app.logger).toBeInstanceOf(Logger);
@@ -377,8 +376,8 @@ describe('ProxyInjector', function () {
     const greetingTemplate = (name: string) => `Hello ${name}`;
 
     const container = new Container(new ProxyInjector())
-      .addRegistration(R.fromClass(App).to('App').pipe(args({ greetingTemplate })))
-      .addRegistration(R.fromClass(Logger).to('logger'));
+      .add(R.fromClass(App).to('App').pipe(args({ greetingTemplate })))
+      .add(R.fromClass(Logger).to('logger'));
 
     const app = container.resolve<App>('App', { args: [{ name: `world` }] });
     expect(app.greeting).toBe('Hello world');
@@ -387,71 +386,13 @@ describe('ProxyInjector', function () {
 
 ```
 
-## Registration and Providers
-`IProvider<T>` is used to describe how instances should be created. It has next basic methods:
-- `resolve` - creates instance with passed arguments
-- `clone` - we invoke it when we create a scope. It clones provider to new scope.
-- `isValid` - checks if provider can be resolved from container or cloned to container with certain tags
-
-There are next types of providers:
-- `Provider` - basic provider. It can be used with `@provider` decorator
-- `SingletonProvider` - provider that creates only one instance in every scope where it's resolved
-- `ScopeProvider` - provider that can be resolved only from container with certain tags and their sub scopes
-- `ArgsProvider` - provider that encapsulates arguments to pass it to constructor.
-
-`Registration` - just a helper to register provider with certain key. `(preferrably to use)`
+## Provider
+Provider is dependency factory which creates dependency.
 
-### Registration (Provider + DependencyKey)
-Sometimes you need to keep dependency key with class together. For example, you want to register class with key 'ILogger' and you want to keep this key with class. This is what `Registration` is for.
-
-```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().addRegistration(R.fromClass(Logger));
-
-    expect(root.resolve('ILogger')).toBeInstanceOf(Logger);
-  });
-
-  it('should register value', function () {
-    const root = createContainer().addRegistration(R.fromValue('smth').to('ISmth'));
-
-    expect(root.resolve('ISmth')).toBe('smth');
-  });
-
-  it('should register fn', function () {
-    const root = createContainer().addRegistration(R.fromFn(() => 'smth').to('ISmth'));
-
-    expect(root.resolve('ISmth')).toBe('smth');
-  });
-
-  it('should raise an error if key is not provider', () => {
-    expect(() => {
-      createContainer().addRegistration(R.fromValue('smth'));
-    }).toThrowError(DependencyMissingKeyError);
-  });
-
-  it('should register dependency by class name if @key is not provided', function () {
-    class FileLogger {}
-
-    const root = createContainer().addRegistration(R.fromClass(FileLogger));
-
-    expect(root.resolve('FileLogger')).toBeInstanceOf(FileLogger);
-  });
-});
-
-```
-
-### Provider
+- `@provider()`
+- `Provider.fromClass(Logger)`
+- `Provider.fromValue(logger)`
+- `new Provider((container, ...args) => container.resolve(Logger, {args}))`
 
 ```typescript
 import 'reflect-metadata';
@@ -490,7 +431,7 @@ describe('Provider', function () {
 
 ```
 
-### Singleton provider
+### Singleton
 Sometimes you need to create only one instance of dependency per scope. For example, you want to create only one logger per scope.
 
 - Singleton provider creates only one instance in every scope where it's resolved.
@@ -510,20 +451,20 @@ describe('Singleton', function () {
   }
 
   it('should resolve the same container per every request', function () {
-    const container = createContainer().addRegistration(R.fromClass(Logger));
+    const container = createContainer().add(R.fromClass(Logger));
 
     expect(container.resolve('logger')).toBe(container.resolve('logger'));
   });
 
   it('should resolve different dependency per scope', function () {
-    const container = createContainer().addRegistration(R.fromClass(Logger));
+    const container = createContainer().add(R.fromClass(Logger));
     const child = container.createScope();
 
     expect(container.resolve('logger')).not.toBe(child.resolve('logger'));
   });
 
   it('should resolve the same dependency for scope', function () {
-    const container = createContainer().addRegistration(R.fromClass(Logger));
+    const container = createContainer().add(R.fromClass(Logger));
     const child = container.createScope();
 
     expect(child.resolve('logger')).toBe(child.resolve('logger'));
@@ -532,29 +473,11 @@ describe('Singleton', function () {
 
 ```
 
-### Scope provider
-Sometimes you need to resolve provider only from 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`
-- NOTICE: It doesn't make clones in not predicate-matched scopes. Usually it's used with `SingletonProvider`.
-
-```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'] }).addRegistration(R.fromClass(Logger));
-    const child = root.createScope();
-    expect(root.resolve('ILogger')).toBe(child.resolve('ILogger'));
-  });
-});
-
-```
-
-### Args provider
+### Arguments
 Sometimes you want to bind some arguments to provider. This is what `ArgsProvider` is for.
+- `@provider(args('someArgument'))`
+- `@provider(argsFn((container) => [container.resolve(Logger), 'someValue']))`
+- `Provider.fromClass(Logger).pipe(args('someArgument'))`
 - NOTICE: args from this provider has higher priority than args from `resolve` method.
 
 ```typescript
@@ -575,21 +498,21 @@ describe('ArgsProvider', function () {
   }
 
   it('can assign argument function to provider', function () {
-    const root = createContainer().addRegistration(R.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
+    const root = createContainer().add(R.fromClass(Logger).pipe(argsFn((container, ...args) => ['name'])));
 
     const logger = root.createScope().resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('can assign argument to provider', function () {
-    const root = createContainer().addRegistration(R.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().add(R.fromClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger');
     expect(logger.name).toBe('name');
   });
 
   it('should set provider arguments with highest priority in compare to resolve arguments', function () {
-    const root = createContainer().addRegistration(R.fromClass(Logger).pipe(args('name')));
+    const root = createContainer().add(R.fromClass(Logger).pipe(args('name')));
 
     const logger = root.resolve<Logger>('logger', { args: ['file'] });
 
@@ -600,11 +523,125 @@ describe('ArgsProvider', function () {
 
 ```
 
-### Aliases
-Sometimes you want to register the same provider with different keys. This is what `Aliases` is for.
-- `@provider(alias('logger'))` helper assigns `logger` alias to provider.
-- `by.alias.some('logger', 'a')` method resolves the same provider with different keys. (logger OR a)
-- `by.alias.all('logger', 'a')` method resolves to resolve the same provider with different keys. (logger AND a)
+### Visibility
+Sometimes you want to hide dependency if somebody wants to resolve it from certain scope
+- `@provider(visible(({ isParent, child }) => isParent || child.hasTag('root')))` - dependency will be accessible from scope `root` or from scope where it's registered
+- `Provider.fromClass(Logger).pipe(visible(({ isParent, child }) => isParent || child.hasTag('root')))`
+
+```typescript
+import 'reflect-metadata';
+import {
+  Container,
+  DependencyNotFoundError,
+  key,
+  MetadataInjector,
+  provider,
+  register,
+  Registration as R,
+  scope,
+  singleton,
+  visible,
+} from 'ts-ioc-container';
+
+describe('Visibility', function () {
+  it('should hide from children', () => {
+    @register(key('logger'), scope((s) => s.hasTag('root')))
+    @provider(singleton(), visible(({ isParent }) => isParent))
+    class FileLogger {}
+
+    const parent = new Container(new MetadataInjector(), { tags: ['root'] }).add(R.fromClass(FileLogger));
+
+    const child = parent.createScope('child');
+
+    expect(() => child.resolve('logger')).toThrowError(DependencyNotFoundError);
+    expect(parent.resolve('logger')).toBeInstanceOf(FileLogger);
+  });
+});
+
+```
+
+## Registration
+Registration is provider factory which registers provider in container.
+- `@registration(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`
+- `@registration(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
+- `@registration(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')`
 
 ```typescript
 import 'reflect-metadata';
@@ -649,7 +686,7 @@ describe('alias', () => {
   it('should resolve by some alias', () => {
     class App implements IApplication {
       private appliedMiddleware: Set<string> = new Set();
-      constructor(@inject(by.aliases((it) => it.includes(IMiddlewareKey))) public middleware: IMiddleware[]) {}
+      constructor(@inject(by.aliases((it) => it.has(IMiddlewareKey))) public middleware: IMiddleware[]) {}
 
       markMiddlewareAsApplied(name: string): void {
         this.appliedMiddleware.add(name);
@@ -671,8 +708,8 @@ describe('alias', () => {
     }
 
     const container = new Container(new MetadataInjector())
-      .addRegistration(R.fromClass(LoggerMiddleware))
-      .addRegistration(R.fromClass(ErrorHandlerMiddleware));
+      .add(R.fromClass(LoggerMiddleware))
+      .add(R.fromClass(ErrorHandlerMiddleware));
 
     const app = container.resolve(App);
     app.run();
@@ -685,16 +722,17 @@ describe('alias', () => {
     @register(alias('ILogger'))
     class FileLogger {}
 
-    const container = new Container(new MetadataInjector()).addRegistration(R.fromClass(FileLogger));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(FileLogger));
 
-    expect(by.alias((aliases) => aliases.includes('ILogger'))(container)).toBeInstanceOf(FileLogger);
-    expect(() => by.alias((aliases) => aliases.includes('logger'))(container)).toThrowError(DependencyNotFoundError);
+    expect(by.alias((aliases) => aliases.has('ILogger'))(container)).toBeInstanceOf(FileLogger);
+    expect(() => by.alias((aliases) => aliases.has('logger'))(container)).toThrowError(DependencyNotFoundError);
   });
 });
 
 ```
 
-## Container modules
+
+## Module
 Sometimes you want to encapsulate registration logic in separate module. This is what `IContainerModule` is for.
 
 ```typescript
@@ -709,13 +747,13 @@ class TestLogger {}
 
 class Production implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.addRegistration(R.fromClass(Logger));
+    container.add(R.fromClass(Logger));
   }
 }
 
 class Development implements IContainerModule {
   applyTo(container: IContainer): void {
-    container.addRegistration(R.fromClass(TestLogger));
+    container.add(R.fromClass(TestLogger));
   }
 }
 
@@ -739,7 +777,7 @@ describe('Container Modules', function () {
 
 ```
 
-## Hooks
+## Hook
 Sometimes you need to invoke methods after construct or dispose of class. This is what hooks are for.
 
 ### OnConstruct
@@ -764,7 +802,7 @@ class MyInjector implements IInjector {
   resolve<T>(container: IContainer, value: constructor<T>, ...deps: unknown[]): T {
     const instance = this.injector.resolve(container, value, ...deps);
     // eslint-disable-next-line @typescript-eslint/ban-types
-    for (const h of getHooks(instance as object, 'onConstruct')) {
+    for (const [h] of getHooks(instance as object, 'onConstruct')) {
       // @ts-ignore
       instance[h]();
     }
@@ -788,7 +826,7 @@ class Logger {
 
 describe('onConstruct', function () {
   it('should make logger be ready on resolve', function () {
-    const container = new Container(new MyInjector()).addRegistration(R.fromClass(Logger));
+    const container = new Container(new MyInjector()).add(R.fromClass(Logger));
 
     const logger = container.resolve<Logger>('logger');
 
@@ -814,6 +852,7 @@ import {
   MetadataInjector,
   register,
 } from 'ts-ioc-container';
+import * as console from 'node:console';
 
 @register(key('logsRepo'))
 @provider(singleton())
@@ -844,16 +883,14 @@ class Logger {
 
 describe('onDispose', function () {
   it('should invoke hooks on all instances', async function () {
-    const container = new Container(new MetadataInjector())
-      .addRegistration(R.fromClass(Logger))
-      .addRegistration(R.fromClass(LogsRepo));
+    const container = new Container(new MetadataInjector()).add(R.fromClass(Logger)).add(R.fromClass(LogsRepo));
 
     const logger = container.resolve<Logger>('logger');
     logger.log('Hello');
 
     for (const instance of container.getInstances()) {
       // eslint-disable-next-line @typescript-eslint/ban-types
-      for (const h of getHooks(instance as object, 'onDispose')) {
+      for (const [h] of getHooks(instance as object, 'onDispose')) {
         // @ts-ignore
         await instance[h]();
       }
@@ -865,7 +902,7 @@ describe('onDispose', function () {
 
 ```
 
-## Tests and Mocks
+## Mock
 Sometimes you need to automatically mock all dependencies in container. This is what `AutoMockedContainer` is for.
 
 ```typescript
@@ -907,9 +944,10 @@ describe('Mocking', () => {
 
 ```
 
-## Errors
+## Error
 
-- [DependencyNotFoundError.ts](lib%2Fcontainer%2FDependencyNotFoundError.ts)
-- [MethodNotImplementedError.ts](lib%2FMethodNotImplementedError.ts)
-- [ContainerDisposedError.ts](lib%2Fcontainer%2FContainerDisposedError.ts)
+- [DependencyNotFoundError.ts](..%2F..%2Flib%2Ferrors%2FDependencyNotFoundError.ts)
+- [MethodNotImplementedError.ts](..%2F..%2Flib%2Ferrors%2FMethodNotImplementedError.ts)
+- [DependencyMissingKeyError.ts](..%2F..%2Flib%2Ferrors%2FDependencyMissingKeyError.ts)
+- [ContainerDisposedError.ts](..%2F..%2Flib%2Ferrors%2FContainerDisposedError.ts)
 

package/cjm/container/AutoMockedContainer.js

@@ -32,7 +32,7 @@ class AutoMockedContainer {
     hasTag() {
         return false;
     }
-    addRegistration(registration) {
+    add(registration) {
         return this;
     }
     getKeyByAlias(alias) {

package/cjm/container/Container.js

@@ -16,7 +16,7 @@ class Container {
         this.parent = options.parent ?? new EmptyContainer_1.EmptyContainer();
         this.tags = new Set(options.tags ?? []);
     }
-    addRegistration(registration) {
+    add(registration) {
         this.registrations.push(registration);
         registration.applyTo(this);
         return this;
@@ -25,7 +25,7 @@ class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         if (aliases && aliases.length > 0) {
-            this.aliases.set(key, aliases);
+            this.aliases.set(key, new Set(aliases));
         }
         return this;
     }
@@ -70,10 +70,8 @@ class Container {
     hasTag(tag) {
         return this.tags.has(tag);
     }
-    use(...modules) {
-        for (const module of modules) {
-            module.applyTo(this);
-        }
+    use(module) {
+        module.applyTo(this);
         return this;
     }
     hasDependency(key) {
@@ -108,9 +106,8 @@ class Container {
      * @private
      */
     getRegistrations() {
-        return this.registrations.length
-            ? this.parent.getRegistrations().concat(this.registrations)
-            : this.parent.getRegistrations();
+        const registrations = this.parent.getRegistrations();
+        return this.registrations.length > 0 ? registrations.concat(this.registrations) : registrations;
     }
     /**
      * @private

package/cjm/container/EmptyContainer.js

@@ -38,7 +38,7 @@ class EmptyContainer {
     use(module) {
         throw new MethodNotImplementedError_1.MethodNotImplementedError();
     }
-    addRegistration(registration) {
+    add(registration) {
         return this;
     }
     getKeyByAlias(alias) {

package/cjm/hook.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHooks = exports.hook = void 0;
-const hook = (key) => (target, propertyKey) => {
-    const hooks = Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : [];
-    Reflect.defineMetadata(key, [...hooks, propertyKey], target.constructor); // eslint-disable-line @typescript-eslint/ban-types
+exports.hasHooks = exports.getHooks = exports.hook = void 0;
+const hook = (key, fn = () => []) => (target, propertyKey) => {
+    const hooks = Reflect.hasMetadata(key, target.constructor)
+        ? Reflect.getMetadata(key, target.constructor)
+        : new Map();
+    hooks.set(propertyKey, fn);
+    Reflect.defineMetadata(key, hooks, target.constructor); // eslint-disable-line @typescript-eslint/ban-types
 };
 exports.hook = hook;
-// eslint-disable-next-line @typescript-eslint/ban-types
 function getHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : [];
+    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : new Map();
 }
 exports.getHooks = getHooks;
+function hasHooks(target, key) {
+    return Reflect.hasMetadata(key, target.constructor);
+}
+exports.hasHooks = hasHooks;

package/cjm/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = exports.by = 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.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.register = exports.scope = exports.alias = exports.key = exports.Registration = exports.AutoMockedContainer = 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;
 var IContainer_1 = require("./container/IContainer");
 Object.defineProperty(exports, "isDependencyKey", { enumerable: true, get: function () { return IContainer_1.isDependencyKey; } });
 var Container_1 = require("./container/Container");
@@ -46,9 +46,13 @@ Object.defineProperty(exports, "ProxyInjector", { enumerable: true, get: functio
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "getHooks", { enumerable: true, get: function () { return hook_1.getHooks; } });
 Object.defineProperty(exports, "hook", { enumerable: true, get: function () { return hook_1.hook; } });
+Object.defineProperty(exports, "hasHooks", { enumerable: true, get: function () { return hook_1.hasHooks; } });
 var by_1 = require("./by");
 Object.defineProperty(exports, "by", { enumerable: true, get: function () { return by_1.by; } });
 var metadata_1 = require("./metadata");
 Object.defineProperty(exports, "setMetadata", { enumerable: true, get: function () { return metadata_1.setMetadata; } });
 Object.defineProperty(exports, "getMetadata", { enumerable: true, get: function () { return metadata_1.getMetadata; } });
 Object.defineProperty(exports, "setParameterMetadata", { enumerable: true, get: function () { return metadata_1.setParameterMetadata; } });
+Object.defineProperty(exports, "setMethodMetadata", { enumerable: true, get: function () { return metadata_1.setMethodMetadata; } });
+Object.defineProperty(exports, "getMethodMetadata", { enumerable: true, get: function () { return metadata_1.getMethodMetadata; } });
+Object.defineProperty(exports, "getParameterMetadata", { enumerable: true, get: function () { return metadata_1.getParameterMetadata; } });

package/cjm/metadata.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = void 0;
+exports.getMethodMetadata = exports.setMethodMetadata = exports.getParameterMetadata = exports.setParameterMetadata = exports.getMetadata = exports.setMetadata = void 0;
 const setMetadata = (key, value) => (target) => {
     Reflect.defineMetadata(key, value, target);
 };
@@ -19,3 +19,9 @@ const getParameterMetadata = (key, target) => {
     return Reflect.getOwnMetadata(key, target) ?? [];
 };
 exports.getParameterMetadata = getParameterMetadata;
+const setMethodMetadata = (key, value) => (target, propertyKey) => {
+    Reflect.defineMetadata(key, value, target.constructor, propertyKey);
+};
+exports.setMethodMetadata = setMethodMetadata;
+const getMethodMetadata = (key, target, propertyKey) => Reflect.getMetadata(key, target.constructor, propertyKey);
+exports.getMethodMetadata = getMethodMetadata;

package/cjm/registration/IRegistration.js

@@ -6,7 +6,7 @@ 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.setScopePredicate(predicate);
+const scope = (predicate) => (r) => r.when(predicate);
 exports.scope = scope;
 const METADATA_KEY = 'registration';
 const getTransformers = (Target) => (0, metadata_1.getMetadata)(Target, METADATA_KEY) ?? [];

package/cjm/registration/Registration.js

@@ -50,7 +50,7 @@ class Registration {
         }
         container.register(this.key, this.createProvider(), this.aliases);
     }
-    setScopePredicate(isValidWhen) {
+    when(isValidWhen) {
         this.matchScope = isValidWhen;
         return this;
     }

package/esm/container/AutoMockedContainer.js

@@ -29,7 +29,7 @@ export class AutoMockedContainer {
     hasTag() {
         return false;
     }
-    addRegistration(registration) {
+    add(registration) {
         return this;
     }
     getKeyByAlias(alias) {

package/esm/container/Container.js

@@ -13,7 +13,7 @@ export class Container {
         this.parent = options.parent ?? new EmptyContainer();
         this.tags = new Set(options.tags ?? []);
     }
-    addRegistration(registration) {
+    add(registration) {
         this.registrations.push(registration);
         registration.applyTo(this);
         return this;
@@ -22,7 +22,7 @@ export class Container {
         this.validateContainer();
         this.providers.set(key, provider);
         if (aliases && aliases.length > 0) {
-            this.aliases.set(key, aliases);
+            this.aliases.set(key, new Set(aliases));
         }
         return this;
     }
@@ -67,10 +67,8 @@ export class Container {
     hasTag(tag) {
         return this.tags.has(tag);
     }
-    use(...modules) {
-        for (const module of modules) {
-            module.applyTo(this);
-        }
+    use(module) {
+        module.applyTo(this);
         return this;
     }
     hasDependency(key) {
@@ -105,9 +103,8 @@ export class Container {
      * @private
      */
     getRegistrations() {
-        return this.registrations.length
-            ? this.parent.getRegistrations().concat(this.registrations)
-            : this.parent.getRegistrations();
+        const registrations = this.parent.getRegistrations();
+        return this.registrations.length > 0 ? registrations.concat(this.registrations) : registrations;
     }
     /**
      * @private

package/esm/container/EmptyContainer.js

@@ -35,7 +35,7 @@ export class EmptyContainer {
     use(module) {
         throw new MethodNotImplementedError();
     }
-    addRegistration(registration) {
+    add(registration) {
         return this;
     }
     getKeyByAlias(alias) {

package/esm/hook.js

@@ -1,8 +1,13 @@
-export const hook = (key) => (target, propertyKey) => {
-    const hooks = Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : [];
-    Reflect.defineMetadata(key, [...hooks, propertyKey], target.constructor); // eslint-disable-line @typescript-eslint/ban-types
+export const hook = (key, fn = () => []) => (target, propertyKey) => {
+    const hooks = Reflect.hasMetadata(key, target.constructor)
+        ? Reflect.getMetadata(key, target.constructor)
+        : new Map();
+    hooks.set(propertyKey, fn);
+    Reflect.defineMetadata(key, hooks, target.constructor); // eslint-disable-line @typescript-eslint/ban-types
 };
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function getHooks(target, key) {
-    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : [];
+    return Reflect.hasMetadata(key, target.constructor) ? Reflect.getMetadata(key, target.constructor) : new Map();
+}
+export function hasHooks(target, key) {
+    return Reflect.hasMetadata(key, target.constructor);
 }

package/esm/index.js

@@ -15,6 +15,6 @@ export { key, alias, scope, register } from './registration/IRegistration';
 export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { getHooks, hook } from './hook';
+export { getHooks, hook, hasHooks } from './hook';
 export { by } from './by';
-export { setMetadata, getMetadata, setParameterMetadata } from './metadata';
+export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/esm/metadata.js

@@ -12,3 +12,7 @@ export const setParameterMetadata = (key, value) => (target, propertyKey, parame
 export const getParameterMetadata = (key, target) => {
     return Reflect.getOwnMetadata(key, target) ?? [];
 };
+export const setMethodMetadata = (key, value) => (target, propertyKey) => {
+    Reflect.defineMetadata(key, value, target.constructor, propertyKey);
+};
+export const getMethodMetadata = (key, target, propertyKey) => Reflect.getMetadata(key, target.constructor, propertyKey);

package/esm/registration/IRegistration.js

@@ -1,7 +1,7 @@
 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.setScopePredicate(predicate);
+export const scope = (predicate) => (r) => r.when(predicate);
 const METADATA_KEY = 'registration';
 export const getTransformers = (Target) => getMetadata(Target, METADATA_KEY) ?? [];
 export const register = (...mappers) => setMetadata(METADATA_KEY, mappers);

package/esm/registration/Registration.js

@@ -47,7 +47,7 @@ export class Registration {
         }
         container.register(this.key, this.createProvider(), this.aliases);
     }
-    setScopePredicate(isValidWhen) {
+    when(isValidWhen) {
         this.matchScope = isValidWhen;
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "31.1.2",
+  "version": "31.1.4",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -59,5 +59,5 @@
     "ts-node": "^10.9.1",
     "typescript": "5.4.3"
   },
-  "gitHead": "eb63fe25a61354a09e4c88326ed40907005c9757"
+  "gitHead": "78877437c1aa25256dd20042e106d787db5f0701"
 }

package/typings/container/AutoMockedContainer.d.ts

@@ -13,6 +13,6 @@ export declare abstract class AutoMockedContainer implements IContainer {
     use(): this;
     getRegistrations(): never[];
     hasTag(): boolean;
-    addRegistration(registration: IRegistration): this;
+    add(registration: IRegistration): this;
     getKeyByAlias(alias: AliasPredicate): DependencyKey;
 }

package/typings/container/Container.d.ts

@@ -16,14 +16,14 @@ export declare class Container implements IContainer {
         parent?: IContainer;
         tags?: Tag[];
     });
-    addRegistration(registration: IRegistration): this;
+    add(registration: IRegistration): this;
     register(key: DependencyKey, provider: IProvider, aliases?: Alias[]): this;
     resolve<T>(token: InjectionToken<T>, { args, child }?: ResolveOptions): T;
     createScope(...tags: Tag[]): Container;
     dispose(): void;
     getInstances(): unknown[];
     hasTag(tag: Tag): boolean;
-    use(...modules: IContainerModule[]): this;
+    use(module: IContainerModule): this;
     hasDependency(key: DependencyKey): boolean;
     getKeysByAlias(predicate: AliasPredicate): DependencyKey[];
     getKeyByAlias(predicate: AliasPredicate): DependencyKey;

package/typings/container/EmptyContainer.d.ts

@@ -14,6 +14,6 @@ export declare class EmptyContainer implements IContainer {
     getInstances(): unknown[];
     removeScope(): void;
     use(module: IContainerModule): this;
-    addRegistration(registration: IRegistration): this;
+    add(registration: IRegistration): this;
     getKeyByAlias(alias: AliasPredicate): DependencyKey;
 }

package/typings/container/IContainer.d.ts

@@ -20,16 +20,16 @@ export interface Tagged {
     hasTag(tag: Tag): boolean;
 }
 export type Alias = string;
-export type AliasPredicate = (aliases: Alias[]) => boolean;
+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;
-    addRegistration(registration: IRegistration): this;
+    add(registration: IRegistration): this;
     removeScope(child: IContainer): void;
     getInstances(): unknown[];
     dispose(): void;
-    use(...modules: IContainerModule[]): this;
+    use(module: IContainerModule): this;
     getRegistrations(): IRegistration[];
     hasDependency(key: DependencyKey): boolean;
     getKeysByAlias(alias: AliasPredicate): DependencyKey[];

package/typings/hook.d.ts

@@ -1,2 +1,4 @@
-export declare const hook: (key: string | symbol) => MethodDecorator;
-export declare function getHooks(target: Object, key: string | symbol): string[];
+import { ArgsFn } from './provider/ArgsProvider';
+export declare const hook: (key: string | symbol, fn?: ArgsFn) => MethodDecorator;
+export declare function getHooks(target: object, key: string | symbol): Map<string, ArgsFn>;
+export declare function hasHooks(target: object, key: string | symbol): boolean;

package/typings/index.d.ts

@@ -17,6 +17,6 @@ export { key, alias, IRegistration, scope, register } from './registration/IRegi
 export { MetadataInjector, inject } from './injector/MetadataInjector';
 export { SimpleInjector } from './injector/SimpleInjector';
 export { ProxyInjector } from './injector/ProxyInjector';
-export { getHooks, hook } from './hook';
+export { getHooks, hook, hasHooks } from './hook';
 export { by, InstancePredicate } from './by';
-export { setMetadata, getMetadata, setParameterMetadata } from './metadata';
+export { setMetadata, getMetadata, setParameterMetadata, setMethodMetadata, getMethodMetadata, getParameterMetadata, } from './metadata';

package/typings/metadata.d.ts

@@ -3,3 +3,5 @@ export declare const setMetadata: <T>(key: string | symbol, value: T) => ClassDe
 export declare function getMetadata<T>(target: object, key: string | symbol): T | undefined;
 export declare const setParameterMetadata: (key: string | symbol, value: unknown) => ParameterDecorator;
 export declare const getParameterMetadata: (key: string | symbol, target: constructor<unknown>) => unknown[];
+export declare const setMethodMetadata: (key: string, value: unknown) => MethodDecorator;
+export declare const getMethodMetadata: (key: string, target: object, propertyKey: string) => unknown;

package/typings/registration/IRegistration.d.ts

@@ -3,7 +3,7 @@ import { constructor, MapFn } from '../utils';
 export type ScopePredicate = (c: Tagged) => boolean;
 export interface IRegistration extends IContainerModule {
     addAliases(...aliases: Alias[]): this;
-    setScopePredicate(isValidWhen: ScopePredicate): this;
+    when(isValidWhen: ScopePredicate): this;
     to(key: DependencyKey): this;
 }
 export declare const key: (key: DependencyKey) => MapFn<IRegistration>;

package/typings/registration/Registration.d.ts

@@ -15,5 +15,5 @@ export declare class Registration<T = unknown> implements IRegistration {
     addAliases(...aliases: Alias[]): this;
     pipe(...mappers: MapFn<IProvider<T>>[]): this;
     applyTo(container: IContainer): void;
-    setScopePredicate(isValidWhen: ScopePredicate): this;
+    when(isValidWhen: ScopePredicate): this;
 }