@difizen/libro-common 0.3.3 → 1.0.0

package/src/ioc/container.spec.ts

@@ -0,0 +1,291 @@
+import assert from 'assert';
+
+import { register, GlobalContainer, Container } from './container';
+import { Syringe } from './core';
+import { singleton, transient, injectable } from './decorator';
+import { Module } from './module';
+
+describe('container', () => {
+  describe('default', () => {
+    it('#injectable register', () => {
+      @injectable()
+      class Injectable {}
+      register(Injectable);
+      const foo = GlobalContainer.get(Injectable);
+      assert(foo instanceof Injectable);
+    });
+    it('#injectable child container', () => {
+      const child = GlobalContainer.createChild();
+      assert(child.parent === GlobalContainer);
+    });
+    it('#singleton register & event', () => {
+      const container = GlobalContainer.createChild();
+      let registered = false;
+      container.onRegistered(() => {
+        registered = true;
+      });
+      @singleton()
+      class Singleton {}
+      container.register(Singleton);
+      const foo1 = container.get(Singleton);
+      const foo2 = container.get(Singleton);
+      assert(foo1 === foo2);
+      assert(registered);
+    });
+    it('#transient register', () => {
+      @transient()
+      class Transient {}
+      register(Transient, {});
+      const foo1 = GlobalContainer.get(Transient);
+      const foo2 = GlobalContainer.get(Transient);
+      assert(foo1 !== foo2);
+    });
+    it('#option register', () => {
+      @injectable()
+      class Injectable {}
+      register({ token: Injectable, useClass: Injectable });
+      const foo = GlobalContainer.get(Injectable);
+      assert(foo instanceof Injectable);
+    });
+    it('#isBound', () => {
+      @injectable()
+      class Injectable {}
+      register({ token: Injectable, useClass: Injectable });
+      assert(GlobalContainer.isBound(Injectable));
+    });
+    it('#rebind', () => {
+      @injectable()
+      class InjectableFoo {}
+      register(InjectableFoo);
+      assert(GlobalContainer.isBound(InjectableFoo));
+      const childContainer = GlobalContainer.createChild();
+      @injectable()
+      class InjectableFoo1 extends InjectableFoo {}
+      childContainer.register({ token: InjectableFoo, useClass: InjectableFoo1 });
+      const instance = childContainer.get(InjectableFoo);
+      assert(instance instanceof InjectableFoo1);
+    });
+    it('#token', () => {
+      const TokenSymbol = Symbol('TokenSymbol');
+      @singleton({ token: TokenSymbol })
+      class Token {}
+      register(Token);
+      const foo1 = GlobalContainer.get(Token);
+      const foo2 = GlobalContainer.get(TokenSymbol);
+      assert(foo1 !== foo2);
+    });
+    it('#named token', () => {
+      const TokenSymbol = Symbol('TokenSymbol');
+      const named = 'named';
+      @singleton({ token: [{ token: TokenSymbol, named }] })
+      class Token {}
+      register(Token);
+      const foo1 = GlobalContainer.getNamed(TokenSymbol, named);
+      const foo2 = GlobalContainer.get(Token);
+      assert(foo1 !== foo2);
+    });
+    it('#named tokens', () => {
+      const TokenSymbol = Symbol('TokenSymbol');
+      const named = 'named';
+      @singleton({ token: { token: TokenSymbol, named } })
+      class Token {}
+      register(Token);
+      const foo1 = GlobalContainer.getNamed(TokenSymbol, named);
+      const fooArray = GlobalContainer.getAllNamed(TokenSymbol, named);
+      assert(fooArray.includes(foo1));
+    });
+    it('#array token', () => {
+      const FooSymbol = Symbol('FooSymbol');
+      const BarSymbol = Symbol('BarSymbol');
+      @singleton({ token: [FooSymbol, BarSymbol] })
+      class ArrayToken {}
+      register(ArrayToken);
+      const foo1 = GlobalContainer.get(ArrayToken);
+      const foo2 = GlobalContainer.get(FooSymbol);
+      const foo3 = GlobalContainer.get(BarSymbol);
+      assert(foo1 !== foo2);
+      assert(foo1 !== foo3);
+      assert(foo3 !== foo2);
+    });
+    it('#undefined value', () => {
+      const TokenSymbol = Symbol('UndefinedToken');
+      register({ token: TokenSymbol, useValue: undefined });
+      const foo1 = GlobalContainer.get(TokenSymbol);
+      assert(typeof foo1 === 'undefined');
+    });
+    it('#get all', () => {
+      const token = Syringe.defineToken('token');
+      @singleton()
+      class Foo {}
+      @singleton()
+      class Bar {}
+      register(token, { useClass: [Foo, Bar] });
+      const list = GlobalContainer.getAll(token);
+      assert(list instanceof Array);
+      assert(list.length === 2);
+    });
+    it('#get from parent', () => {
+      const token = Syringe.defineToken('token');
+      @singleton()
+      class Foo {}
+      const childContainer = GlobalContainer.createChild();
+      @singleton()
+      class Bar {}
+      register(token, { useClass: Foo });
+      childContainer.register(token, { useClass: Bar });
+      const list = GlobalContainer.getAll(token);
+      assert(list instanceof Array);
+      assert(list.length === 1);
+    });
+    it('#mono token', () => {
+      @singleton()
+      class Foo {}
+      @singleton()
+      class Bar {}
+      register(Bar, { useClass: [Foo] });
+      const foo1 = GlobalContainer.get(Bar);
+      assert(foo1 instanceof Foo);
+    });
+    it('#contrib', () => {
+      const FooSymbol = Symbol('FooSymbol');
+      @singleton({ contrib: FooSymbol })
+      class Contrib {}
+      register(Contrib);
+      const foo1 = GlobalContainer.get(Contrib);
+      const foo2 = GlobalContainer.get(FooSymbol);
+      assert(foo1 === foo2);
+    });
+    it('#contrib with transient', () => {
+      const FooSymbol = Symbol('FooSymbol');
+      @transient({ contrib: FooSymbol })
+      class ContribTransient {}
+      register(ContribTransient);
+      const foo1 = GlobalContainer.get(ContribTransient);
+      const foo2 = GlobalContainer.get(FooSymbol);
+      assert(foo1 === foo2);
+    });
+    it('#array contrib', () => {
+      const FooSymbol = Symbol('FooSymbol');
+      const BarSymbol = Symbol('BarSymbol');
+      @singleton({ contrib: [FooSymbol, BarSymbol] })
+      class ArrayContrib {}
+      register(ArrayContrib);
+      const foo1 = GlobalContainer.get(ArrayContrib);
+      const foo2 = GlobalContainer.get(FooSymbol);
+      assert(foo1 === foo2);
+    });
+    it('#contrib to mono/multi token', () => {
+      const FooSymbol = Symbol('FooSymbol');
+      const BarSymbol = Syringe.defineToken('BarSymbol');
+      register({ token: FooSymbol, useValue: FooSymbol });
+      register({ token: BarSymbol, useValue: undefined });
+      @singleton({ contrib: [FooSymbol, BarSymbol] })
+      class FooContribToMonoMulti {}
+      register(FooContribToMonoMulti);
+      const obj = GlobalContainer.get(FooContribToMonoMulti);
+      const objFoo = GlobalContainer.get(FooSymbol);
+      const barList = GlobalContainer.getAll(BarSymbol);
+      assert(obj === objFoo);
+      assert(barList.includes(objFoo));
+      assert(barList.includes(undefined));
+      assert(barList.length === 2);
+    });
+    it('#remove', () => {
+      @singleton()
+      class Foo {}
+      try {
+        register(Foo);
+        GlobalContainer.remove(Foo);
+        GlobalContainer.get(Foo);
+        assert(false);
+      } catch (ex) {
+        assert(true);
+      }
+    });
+    it('#remove contrib', () => {
+      const FooSymbol = Syringe.defineToken('FooSymbol');
+      @singleton({ contrib: FooSymbol })
+      class FooContribution {}
+      @singleton({ contrib: FooSymbol })
+      class BarContribution {}
+      register(FooContribution);
+      register(BarContribution);
+      const contribs = GlobalContainer.getAll(FooSymbol);
+      assert(contribs.length === 2);
+      assert(contribs[0] instanceof FooContribution);
+      GlobalContainer.remove(FooSymbol);
+      assert(!GlobalContainer.isBound(FooSymbol));
+      register(FooContribution);
+      const emptyContribs = GlobalContainer.getAll(FooSymbol);
+      assert(emptyContribs.length === 1);
+    });
+
+    it('#load module and event', () => {
+      const container = GlobalContainer.createChild();
+      let loaded = false;
+      container.onModuleChanged(() => {
+        loaded = true;
+      });
+      @singleton()
+      class Foo {}
+      const baseModule = Module().register(Foo);
+      container.load(baseModule);
+      assert(loaded);
+      assert(container.isBound(Foo));
+    });
+  });
+  describe('basic', () => {
+    it('#new container', () => {
+      @injectable()
+      class NewContainer {}
+      const container = new Container();
+      container.register(NewContainer);
+      const foo = container.get(NewContainer);
+      assert(foo instanceof NewContainer);
+    });
+    it('#global config', () => {
+      Container.config({ lifecycle: Syringe.Lifecycle.singleton });
+      @injectable()
+      class GlobalConfig {}
+      register(GlobalConfig);
+      const foo1 = GlobalContainer.get(GlobalConfig);
+      const foo2 = GlobalContainer.get(GlobalConfig);
+      assert(foo1 === foo2);
+    });
+    it('#global config downgrade', () => {
+      Container.config({});
+      @injectable()
+      class GlobalConfigDown {}
+      register(GlobalConfigDown);
+      const foo1 = GlobalContainer.get(GlobalConfigDown);
+      const foo2 = GlobalContainer.get(GlobalConfigDown);
+      assert(foo1 !== foo2);
+    });
+    it('#invalid register', () => {
+      const InvalidSymbol = Symbol('InvalidSymbol');
+      register(InvalidSymbol);
+      let flag = true;
+      try {
+        GlobalContainer.get(InvalidSymbol);
+      } catch (ex) {
+        flag = false;
+      }
+      assert(!flag);
+    });
+    it('#invalid register empty', () => {
+      const InvalidSymbol = Symbol('InvalidSymbol');
+      register(InvalidSymbol);
+      let flag = true;
+      try {
+        GlobalContainer.get(InvalidSymbol);
+      } catch (ex) {
+        flag = false;
+      }
+      assert(!flag);
+    });
+    it('#container context', () => {
+      const context = GlobalContainer.get(Syringe.ContextToken);
+      assert(context.container === GlobalContainer);
+    });
+  });
+});

package/src/ioc/container.ts

@@ -0,0 +1,171 @@
+import type { interfaces } from 'inversify';
+import { Container as InversifyContainer } from 'inversify';
+
+import type { Disposable } from '../common/index.js';
+import { DisposableCollection, Emitter } from '../common/index.js';
+
+import { ContainerAPI } from './container-api.js';
+import { Syringe } from './core.js';
+import { Utils } from './core.js';
+import {
+  GlobalContainer as InversifyGlobalContainer,
+  namedToIdentifier,
+  tokenToIdentifier,
+} from './inversify-api/index.js';
+import type { InversifyContext } from './inversify-api/inversify-protocol.js';
+import { isSyringeModule } from './module/index.js';
+import { Register } from './register.js';
+
+export const ContainerMeta = Symbol('ContainerMeta');
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Container implements Syringe.Container, InversifyContext, Disposable {
+  disposed?: boolean | undefined;
+  protected toDisposeOnParentChange = new DisposableCollection();
+  protected onModuleChangedEmitter = new Emitter<void>();
+  get onModuleChanged() {
+    return this.onModuleChangedEmitter.event;
+  }
+  protected onRegisteredEmitter = new Emitter<void>();
+  get onRegistered() {
+    return this.onRegisteredEmitter.event;
+  }
+  protected _parent?: Container | undefined;
+  get parent(): Container | undefined {
+    return this._parent;
+  }
+  set parent(p: Container | undefined) {
+    this._parent = p;
+    if (this.toDisposeOnParentChange) {
+      this.toDisposeOnParentChange.dispose();
+      this.toDisposeOnParentChange = new DisposableCollection();
+    }
+    if (p) {
+      this.toDisposeOnParentChange.push(
+        p.onModuleChanged(() => {
+          this.onModuleChangedEmitter.fire();
+        }),
+      );
+      this.toDisposeOnParentChange.push(
+        p.onRegistered(() => {
+          this.onRegisteredEmitter.fire();
+        }),
+      );
+    }
+  }
+  static config(option: Syringe.InjectOption<void>): void {
+    Register.globalConfig = option;
+  }
+
+  protected loadedModules: number[] = [];
+  container: interfaces.Container;
+  constructor(inversifyContainer?: interfaces.Container) {
+    if (inversifyContainer) {
+      this.container = inversifyContainer;
+    } else {
+      this.container = new InversifyContainer();
+    }
+    ContainerAPI.setCache(this.container, this);
+    this.register({
+      token: Syringe.ContextToken,
+      useDynamic: (ctx) => {
+        return ctx;
+      },
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+  }
+  dispose() {
+    this.toDisposeOnParentChange.dispose();
+    this.onModuleChangedEmitter.dispose();
+    this.onRegisteredEmitter.dispose();
+    this.disposed = true;
+  }
+  load(module: Syringe.Module, force?: boolean, deep = true): void {
+    if (force || !this.loadedModules.includes(module.id)) {
+      if (isSyringeModule(module)) {
+        if (deep) {
+          const { dependencies } = module.toLoader();
+          if (dependencies) {
+            for (const dep of dependencies) {
+              this.load(dep);
+            }
+          }
+        }
+        this.container.load(module.inversifyModule);
+        this.onModuleChangedEmitter.fire();
+      } else {
+        console.warn(
+          `Unsupported module${module.name ? ` ${module.name}` : ''}.`,
+          module,
+        );
+      }
+      this.loadedModules.push(module.id);
+    }
+  }
+  unload(module: Syringe.Module): void {
+    if (isSyringeModule(module)) {
+      this.container.unload(module.inversifyModule);
+      this.onModuleChangedEmitter.fire();
+      this.loadedModules = this.loadedModules.filter((id) => id !== module.id);
+    }
+  }
+  remove<T>(token: Syringe.Token<T>): void {
+    return this.container.unbind(tokenToIdentifier(token));
+  }
+  get<T>(token: Syringe.Token<T>): T {
+    return this.container.get(tokenToIdentifier(token));
+  }
+  getNamed<T>(token: Syringe.Token<T>, named: Syringe.Named): T {
+    return this.container.getNamed(tokenToIdentifier(token), namedToIdentifier(named));
+  }
+  getAll<T>(token: Syringe.Token<T>): T[] {
+    return this.container.getAll(tokenToIdentifier(token));
+  }
+  getAllNamed<T>(token: Syringe.Token<T>, named: Syringe.Named): T[] {
+    return this.container.getAllNamed(
+      tokenToIdentifier(token),
+      namedToIdentifier(named),
+    );
+  }
+
+  isBound<T>(token: Syringe.Token<T>): boolean {
+    return this.container.isBound(tokenToIdentifier(token));
+  }
+
+  isBoundNamed<T>(token: Syringe.Token<T>, named: Syringe.Named): boolean {
+    return this.container.isBoundNamed(
+      tokenToIdentifier(token),
+      namedToIdentifier(named),
+    );
+  }
+
+  createChild(): Syringe.Container {
+    const childContainer = this.container.createChild();
+    const child = new Container(childContainer);
+    child.parent = this;
+    return child;
+  }
+  register<T = any>(tokenOrOption: Syringe.Token<T> | Syringe.InjectOption<T>): void;
+  register<T = any>(token: Syringe.Token<T>, options: Syringe.InjectOption<T>): void;
+  register<T = any>(
+    token: Syringe.Token<T> | Syringe.InjectOption<T>,
+    options: Syringe.InjectOption<T> = {},
+  ): void {
+    if (Utils.isInjectOption(token)) {
+      Register.resolveOption(this, token);
+    } else {
+      Register.resolveTarget(this, token, options);
+    }
+    this.onRegisteredEmitter.fire();
+  }
+}
+
+export const GlobalContainer = new Container(InversifyGlobalContainer);
+
+export const register: Syringe.Register =
+  GlobalContainer.register.bind(GlobalContainer);
+
+ContainerAPI.toContainer = (ctn) => {
+  const container = new Container(ctn);
+  return container;
+};

package/src/ioc/contribution/contribution-protocol.ts

@@ -0,0 +1,27 @@
+import type { Event } from '../../common/index.js';
+import { Syringe } from '../core.js';
+
+export type Option = {
+  /**
+   * collected from the parent containers
+   */
+  recursive?: boolean;
+  /**
+   * use cache
+   */
+  cache?: boolean;
+};
+export type Provider<T extends Record<string, any>> = {
+  getContributions: (option?: Option) => T[];
+  onChanged: Event<void>;
+};
+export const Provider = Syringe.defineToken('SyringeContributionProvider', {
+  global: true,
+});
+
+class ContributionOptionConfigImpl {
+  recursive = false;
+  cache = true;
+}
+
+export const ContributionOptionConfig = new ContributionOptionConfigImpl();

package/src/ioc/contribution/contribution-provider.ts

@@ -0,0 +1,73 @@
+import type { Disposable } from '../../common/index.js';
+import { Emitter } from '../../common/index.js';
+import { DisposableCollection } from '../../common/index.js';
+import type { Syringe } from '../core.js';
+
+import {
+  ContributionOptionConfig,
+  type Option,
+  type Provider,
+} from './contribution-protocol.js';
+
+export class DefaultContributionProvider<T extends Record<string, any>>
+  implements Provider<T>, Disposable
+{
+  protected onChangedEmitter = new Emitter<void>();
+  get onChanged() {
+    return this.onChangedEmitter.event;
+  }
+  protected option: Option = {
+    recursive: ContributionOptionConfig.recursive,
+    cache: ContributionOptionConfig.cache,
+  };
+  protected services: T[] | undefined;
+  protected readonly serviceIdentifier: Syringe.Token<T>;
+  protected readonly container: Syringe.Container;
+  protected toDispose = new DisposableCollection();
+  constructor(
+    serviceIdentifier: Syringe.Token<T>,
+    container: Syringe.Container,
+    option?: Option,
+  ) {
+    this.container = container;
+    this.serviceIdentifier = serviceIdentifier;
+    if (option) {
+      this.option = { ...this.option, ...option };
+    }
+    this.toDispose.push(this.onChangedEmitter);
+    this.toDispose.push(this.container.onModuleChanged(this.onCtxChanged));
+    this.toDispose.push(this.container.onRegistered(this.onCtxChanged));
+  }
+
+  disposed?: boolean | undefined;
+  dispose() {
+    this.toDispose.dispose();
+    this.disposed = true;
+  }
+
+  protected onCtxChanged = () => {
+    this.services = undefined;
+    this.onChangedEmitter.fire();
+  };
+
+  protected setServices(recursive: boolean): T[] {
+    const currentServices: T[] = [];
+    let currentContainer: Syringe.Container | undefined = this.container;
+    while (currentContainer) {
+      if (currentContainer.isBound(this.serviceIdentifier)) {
+        const list = currentContainer.getAll(this.serviceIdentifier);
+        currentServices.push(...list);
+      }
+      currentContainer = recursive ? currentContainer.parent : undefined;
+    }
+    return currentServices;
+  }
+
+  getContributions(option: Option = {}): T[] {
+    const { cache, recursive } = { ...this.option, ...option };
+    if (!cache || this.services === undefined) {
+      this.services = this.setServices(!!recursive);
+    }
+    return this.services;
+  }
+}

package/src/ioc/contribution/contribution-register.ts

@@ -0,0 +1,32 @@
+import { Syringe } from '../core';
+
+import * as Contribution from './contribution-protocol';
+import type { Provider, Option } from './contribution-protocol';
+import { DefaultContributionProvider } from './contribution-provider';
+
+export function contributionInjectOption(
+  token: Syringe.DefinedToken,
+  option?: Option,
+): Syringe.InjectOption<Provider<Syringe.DefinedToken>> {
+  return {
+    token: { token: Contribution.Provider, named: token },
+    useDynamic: (ctx) => {
+      return new DefaultContributionProvider(token, ctx.container, option);
+    },
+    lifecycle: Syringe.Lifecycle.singleton,
+  };
+}
+
+export function contributionRegister(
+  registerMethod: Syringe.Register,
+  identifier: Syringe.DefinedToken,
+  option?: Option,
+): void {
+  registerMethod({
+    token: { token: Contribution.Provider, named: identifier },
+    useDynamic: (ctx) => {
+      return new DefaultContributionProvider(identifier, ctx.container, option);
+    },
+    lifecycle: Syringe.Lifecycle.singleton,
+  });
+}

package/src/ioc/contribution/decorator.ts

@@ -0,0 +1,16 @@
+import type { Syringe } from '../core';
+import { inject, named } from '../decorator';
+
+import { Provider } from './contribution-protocol';
+
+export const contrib =
+  (token: Syringe.Named) =>
+  (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    target: any,
+    targetKey: any,
+    index?: number | undefined,
+  ) => {
+    named(token)(target, targetKey, index);
+    inject(Provider)(target, targetKey, index);
+  };