ts-ioc-container 23.3.8 → 23.3.9

package/README.md

@@ -191,94 +191,127 @@ Injectors are used to describe how dependencies should be injected to constructo
 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 `ReflectionInjector`.
 
 ```typescript
-import { Container, IContainer, IInjector, Provider, by, inject, resolve } from "ts-ioc-container";
+import 'reflect-metadata';
+import { by, Container, inject, Provider, ReflectionInjector } from 'ts-ioc-container';
 
-class Logger implements ILogger {
-  info(message: string) {
-    console.log(message);
-  }
+class Logger {
+  name = 'Logger';
 }
 
 class App {
-  constructor(@inject((container, ...args) => container.resolve('ILogger', ...args)) private logger: ILogger) {
-  }
+  constructor(@inject(by('ILogger')) private logger: Logger) {}
 
   // OR
-  // constructor(@inject(by('ILogger')) private logger: ILogger) {
+  // constructor(@inject((container, ...args) => container.resolve('ILogger', ...args)) private logger: ILogger) {
   // }
 
-  run() {
-    this.logger.info('Hello world');
+  getLoggerName(): string {
+    return this.logger.name;
   }
 }
 
-const container = new Container(new ReflectionInjector())
-  .register('ILogger', Provider.fromClass(Logger));
+describe('Reflection Injector', function () {
+  it('should inject dependencies by @inject decorator', function () {
+    const container = new Container(new ReflectionInjector()).register('ILogger', Provider.fromClass(Logger));
+
+    const app = container.resolve(App);
+
+    expect(app.getLoggerName()).toBe('Logger');
+  });
+});
 
-const app = container.resolve(App);
-app.run();
 ```
 
 ### Simple injector
 This type of injector just passes container to constructor with others arguments.
 
 ```typescript
-import { SimpleInjector, IContainer } from "ts-ioc-container";
+import 'reflect-metadata';
+import { Container, IContainer, Provider, SimpleInjector } from '../lib';
 
-class Logger implements ILogger {
-  info(message: string) {
-    console.log(message);
-  }
-}
+describe('SimpleInjector', function () {
+  it('should pass container as first parameter', function () {
+    class App {
+      constructor(public container: IContainer) {}
+    }
 
-class App {
-  private logger: ILogger;
+    const container = new Container(new SimpleInjector()).register('App', Provider.fromClass(App));
+    const app = container.resolve<App>('App');
 
-  constructor(private container: IContainer) {
-    this.logger = container.resolve('ILogger');
-  }
+    expect(app.container).toBeInstanceOf(Container);
+  });
 
-  run() {
-    this.logger.info('Hello world');
-  }
-}
+  it('should pass parameters alongside with container', function () {
+    class App {
+      constructor(container: IContainer, public greeting: string) {}
+    }
 
-const container = new Container(new SimpleInjector())
-  .register('ILogger', Provider.fromClass(Logger));
+    const container = new Container(new SimpleInjector()).register('App', Provider.fromClass(App));
+    const app = container.resolve<App>('App', 'Hello world');
+
+    expect(app.greeting).toBe('Hello world');
+  });
+});
 
-const app = container.resolve(App);
-app.run();
 ```
 
 ### Proxy injector
 This type of injector injects dependencies as dictionary `Record<string, unknown>`.
 
 ```typescript
-import { ProxyInjector, IContainer } from "ts-ioc-container";
+import 'reflect-metadata';
+import { Container, Provider, ProxyInjector, withArgs } from '../lib';
 
-class Logger implements ILogger {
-  info(message: string) {
-    console.log(message);
-  }
-}
+describe('ProxyInjector', function () {
+  it('should pass dependency to constructor as dictionary', function () {
+    class Logger {}
 
-class App {
-  private logger: ILogger;
+    class App {
+      logger: Logger;
 
-  constructor({ logger }: { logger: ILogger }) {
-    this.logger = logger;
-  }
+      constructor({ logger }: { logger: Logger }) {
+        this.logger = logger;
+      }
+    }
 
-  run() {
-    this.logger.info('Hello world');
-  }
-}
+    const container = new Container(new ProxyInjector()).register('logger', Provider.fromClass(Logger));
+
+    const app = container.resolve(App);
+    expect(app.logger).toBeInstanceOf(Logger);
+  });
+
+  it('should pass arguments as objects', function () {
+    class Logger {}
 
-const container = new Container(new ProxyInjector())
-  .register('logger', Provider.fromClass(Logger));
+    class App {
+      logger: Logger;
+      greeting: string;
+
+      constructor({
+        logger,
+        greetingTemplate,
+        name,
+      }: {
+        logger: Logger;
+        greetingTemplate: (name: string) => string;
+        name: string;
+      }) {
+        this.logger = logger;
+        this.greeting = greetingTemplate(name);
+      }
+    }
+
+    const greetingTemplate = (name: string) => `Hello ${name}`;
+
+    const container = new Container(new ProxyInjector())
+      .register('App', Provider.fromClass(App).pipe(withArgs({ greetingTemplate })))
+      .register('logger', Provider.fromClass(Logger));
+
+    const app = container.resolve<App>('App', { name: `world` });
+    expect(app.greeting).toBe('Hello world');
+  });
+});
 
-const app = container.resolve(App);
-app.run();
 ```
 
 ## Providers `IProvider<T>`
@@ -344,17 +377,39 @@ Sometimes you need to create only one instance of dependency per scope. For exam
 - NOTICE: if you create a scope 'A' of container 'root' then Logger of A !== Logger of root.
 
 ```typescript
-import { Provider, SingletonProvider, asSingleton } from "ts-ioc-container";
+import 'reflect-metadata';
+import { asSingleton, Container, forKey, provider, ReflectionInjector, Registration } from '../lib';
 
-container.register('ILogger', Provider.fromClass(Logger).pipe((provider) => new SingletonProvider(provider)));
-// OR
-container.register('ILogger', Provider.fromClass(Logger).pipe(asSingleton()));
+@forKey('logger')
+@provider(asSingleton())
+class Logger {}
 
-container.resolve('ILogger') === container.resolve('ILogger'); // true
+describe('Singleton', function () {
+  function createContainer() {
+    return new Container(new ReflectionInjector());
+  }
+
+  it('should resolve the same container per every request', function () {
+    const container = createContainer().add(Registration.fromClass(Logger));
+
+    expect(container.resolve('logger')).toBe(container.resolve('logger'));
+  });
+
+  it('should resolve different dependency per scope', function () {
+    const container = createContainer().add(Registration.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().add(Registration.fromClass(Logger));
+    const child = container.createScope();
+
+    expect(child.resolve('logger')).toBe(child.resolve('logger'));
+  });
+});
 
-const scope = container.createScope();
-scope.resolve('ILogger') === scope.resolve('ILogger'); // true
-container.resolve('ILogger') !== scope.resolve('ILogger'); // true. NOTICE: because every provider is cloned for every child scope from parent one
 ```
 
 ### Tagged provider
@@ -455,15 +510,25 @@ container.register('ILogger', Provider.fromClass(Logger));
 Sometimes you need to invoke methods after construct or dispose of class. This is what hooks are for.
 
 ```typescript
+import 'reflect-metadata';
 import {
+  asSingleton,
+  by,
+  constructor,
   Container,
-  IInjector,
-  ContainerHook,
-  Injector,
-  Registration,
+  forKey,
   getHooks,
   hook,
-} from "ts-ioc-container";
+  IContainer,
+  IInjector,
+  inject,
+  provider,
+  ReflectionInjector,
+  Registration,
+} from '../lib';
+
+const onConstruct = hook('onConstruct');
+const onDispose = hook('onDispose');
 
 class MyInjector implements IInjector {
   private injector = new ReflectionInjector();
@@ -478,29 +543,70 @@ class MyInjector implements IInjector {
   }
 }
 
-@forKey('ILogger')
+@forKey('logsRepo')
+@provider(asSingleton())
+class LogsRepo {
+  savedLogs: string[] = [];
+
+  saveLogs(messages: string[]) {
+    this.savedLogs.push(...messages);
+  }
+}
+
+@forKey('logger')
 class Logger {
-  @hook('onConstruct')
+  isReady = false;
+  private messages: string[] = [];
+
+  constructor(@inject(by('logsRepo')) private logsRepo: LogsRepo) {}
+
+  @onConstruct
   initialize() {
-    console.log('initialized');
+    this.isReady = true;
   }
 
-  @hook('onDispose')
-  dispose() {
-    console.log('disposed');
+  log(message: string): void {
+    this.messages.push(message);
   }
-}
 
-const container = new Container(new MyInjector())
-  .add(Registration.fromClass(Logger));
-const logger = container.resolve<ILogger>('ILogger'); // initialized
-
-for (const instance of container.getInstances()) {
-  for (const h of getHooks(instance, 'onDispose')) {
-    // @ts-ignore
-    instance[h](); // disposed
+  @onDispose
+  async save(): Promise<void> {
+    this.logsRepo.saveLogs(this.messages);
+    this.messages = [];
   }
 }
+
+describe('Hooks', function () {
+  function createContainer() {
+    return new Container(new MyInjector());
+  }
+
+  it('should invoke hooks on all instances', async function () {
+    const container = createContainer().add(Registration.fromClass(Logger)).add(Registration.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')) {
+        // @ts-ignore
+        await instance[h]();
+      }
+    }
+
+    expect(container.resolve<LogsRepo>('logsRepo').savedLogs).toContain('Hello');
+  });
+
+  it('should make logger be ready on resolve', function () {
+    const container = createContainer().add(Registration.fromClass(Logger)).add(Registration.fromClass(LogsRepo));
+
+    const logger = container.resolve<Logger>('logger');
+
+    expect(logger.isReady).toBe(true);
+  });
+});
+
 ```
 
 ## Mocking / Tests `AutoMockedContainer`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-ioc-container",
-  "version": "23.3.8",
+  "version": "23.3.9",
   "description": "Typescript IoC container",
   "publishConfig": {
     "access": "public",
@@ -56,5 +56,5 @@
     "ts-node": "^10.9.1",
     "typescript": "4.4.3"
   },
-  "gitHead": "77c7357527b743dc09d8aad2dfa0a15ff78d6697"
+  "gitHead": "f764eba0952e959a0415b24e27c40fa774023473"
 }