@difizen/libro-common 0.3.3 → 1.0.0

package/src/ioc/inversify-api/index.spec.ts

@@ -0,0 +1,224 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import 'reflect-metadata';
+import assert from 'assert';
+
+import { injectable } from 'inversify';
+
+import { GlobalContainer } from '../container';
+import { Syringe } from '../core';
+import { Event } from '../../common/index.js';
+import { Register } from '../register';
+
+import { bindSingleton, bindTransient, bindLifecycle, isInversifyContext } from '.';
+
+const fakeContainer: Syringe.Container = {
+  register: () => {
+    //
+  },
+  remove: () => {
+    //
+  },
+  load: () => ({
+    dispose: () => {
+      //
+    },
+  }),
+  unload: () => {
+    //
+  },
+  get: () => ({}) as any,
+  getNamed: () => ({}) as any,
+  getAll: () => [],
+  getAllNamed: () => [],
+  isBound: () => false,
+  isBoundNamed: () => false,
+  createChild: () => fakeContainer,
+  onModuleChanged: Event.None,
+  onRegistered: Event.None,
+};
+const emptyOptions: Syringe.FormattedInjectOption<any> = {
+  token: [],
+  useDynamic: [],
+  lifecycle: Syringe.Lifecycle.singleton,
+  useClass: [],
+  contrib: [],
+  useFactory: [],
+};
+
+describe('inversify', () => {
+  it('#global container', () => {
+    assert(GlobalContainer);
+    assert(isInversifyContext(GlobalContainer));
+  });
+  it('#bind singleton', () => {
+    @injectable()
+    class Foo {}
+    bindSingleton<Foo>(GlobalContainer.container.bind(Foo).toSelf());
+    const foo1 = GlobalContainer.get(Foo);
+    const foo2 = GlobalContainer.get(Foo);
+    assert(foo1 === foo2);
+  });
+  it('#bind transient', () => {
+    @injectable()
+    class Foo {}
+    bindTransient<Foo>(GlobalContainer.container.bind(Foo).toSelf());
+    const foo1 = GlobalContainer.get(Foo);
+    const foo2 = GlobalContainer.get(Foo);
+    assert(foo1 !== foo2);
+  });
+  it('#bind lifecycle', () => {
+    @injectable()
+    class Foo {}
+    bindLifecycle<Foo>(GlobalContainer.container.bind(Foo).to(Foo), {
+      ...emptyOptions,
+      lifecycle: Syringe.Lifecycle.singleton,
+      useClass: [Foo],
+      token: [Foo],
+    });
+    const foo1 = GlobalContainer.get(Foo);
+    const foo2 = GlobalContainer.get(Foo);
+    assert(foo1 === foo2);
+  });
+  it('#bind factory', () => {
+    const FooFactory = Symbol('FooFactory');
+    @injectable()
+    class Foo {}
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [FooFactory],
+      useFactory: [() => () => new Foo()],
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const fooFactory = GlobalContainer.get<() => Foo>(FooFactory);
+    const foo = fooFactory();
+    assert(foo instanceof Foo);
+  });
+
+  it('#bind value', () => {
+    const Foo = Symbol('Foo');
+    const Bar = Symbol('Bar');
+    const foo = {};
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [Foo],
+      useValue: foo,
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [Bar],
+      useValue: false,
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const fooValue = GlobalContainer.get<any>(Foo);
+    const barValue = GlobalContainer.get<any>(Bar);
+    assert(fooValue === foo);
+    assert(barValue === false);
+  });
+
+  it('#bind named value', () => {
+    const Foo = Symbol('Foo');
+    const named = 'named';
+    const foo = {};
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [{ token: Foo, named }],
+      useValue: foo,
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const fooValue = GlobalContainer.getNamed<any>(Foo, named);
+    assert(fooValue === foo);
+  });
+
+  it('#bind named factory', () => {
+    const FooFactory = Symbol('FooFactory');
+    const named = 'named';
+    @injectable()
+    class Foo {}
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [{ token: FooFactory, named }],
+      useFactory: [() => () => new Foo()],
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const fooFactory = GlobalContainer.getNamed<() => Foo>(FooFactory, named);
+    const foo = fooFactory();
+    assert(foo instanceof Foo);
+  });
+  it('#bind dynamic', () => {
+    const FooDynamic = Symbol('FooDynamic');
+    @injectable()
+    class Foo {}
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [FooDynamic],
+      useDynamic: [() => new Foo()],
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const foo = GlobalContainer.get<Foo>(FooDynamic);
+    assert(foo instanceof Foo);
+  });
+  it('#bind named dynamic', () => {
+    const FooDynamic = Symbol('FooDynamic');
+    const named = 'named';
+    @injectable()
+    class Foo {}
+    Register.resolveOption(GlobalContainer, {
+      ...emptyOptions,
+      token: [{ token: FooDynamic, named }],
+      useDynamic: [() => new Foo()],
+      lifecycle: Syringe.Lifecycle.singleton,
+    });
+    const foo = GlobalContainer.getNamed<Foo>(FooDynamic, named);
+    assert(foo instanceof Foo);
+  });
+  it('#bind named', () => {
+    @injectable()
+    class Foo {}
+    Register.resolveOption<Foo>(GlobalContainer, {
+      ...emptyOptions,
+      token: [{ token: Foo, named: 'named' }],
+      lifecycle: Syringe.Lifecycle.singleton,
+      useClass: [Foo],
+    });
+    const foo1 = GlobalContainer.getNamed(Foo, 'named');
+    const foo2 = GlobalContainer.getNamed(Foo, 'named');
+    assert(foo1 && foo1 === foo2);
+  });
+  it('#bind', () => {
+    @injectable()
+    class Foo {}
+    Register.resolveOption<Foo>(GlobalContainer, {
+      ...emptyOptions,
+      lifecycle: Syringe.Lifecycle.singleton,
+      useClass: [Foo],
+      token: [Foo],
+    });
+    const foo1 = GlobalContainer.get(Foo);
+    const foo2 = GlobalContainer.get(Foo);
+    assert(foo1 === foo2);
+  });
+
+  it('#bind with error ', () => {
+    @injectable()
+    class Foo {}
+    try {
+      Register.resolveOption<Foo>(fakeContainer as any, {
+        ...emptyOptions,
+        lifecycle: Syringe.Lifecycle.singleton,
+        useClass: [Foo],
+        token: [Foo],
+      });
+      Register.resolveOption<Foo>(fakeContainer as any, {
+        ...emptyOptions,
+        lifecycle: Syringe.Lifecycle.singleton,
+        useClass: [Foo],
+        token: [Foo],
+      });
+      assert(true);
+    } catch {
+      assert(false);
+    }
+  });
+});

package/src/ioc/inversify-api/index.ts

@@ -0,0 +1,76 @@
+import type { interfaces } from 'inversify';
+import { Container } from 'inversify';
+
+import { Syringe, Utils } from '../core';
+
+import type { InversifyContext } from './inversify-protocol';
+
+export function bindSingleton<T>(
+  toBind: interfaces.BindingInSyntax<T>,
+): interfaces.BindingWhenOnSyntax<T> {
+  return toBind.inSingletonScope();
+}
+
+export function bindTransient<T>(
+  toBind: interfaces.BindingInSyntax<T>,
+): interfaces.BindingWhenOnSyntax<T> {
+  return toBind.inTransientScope();
+}
+export function bindLifecycle<T>(
+  toBind: interfaces.BindingInSyntax<T>,
+  option: Syringe.FormattedInjectOption<T>,
+): interfaces.BindingWhenOnSyntax<T> {
+  if (option.lifecycle === Syringe.Lifecycle.singleton) {
+    return bindSingleton(toBind);
+  }
+  return bindTransient(toBind);
+}
+
+export function bindNamed<T>(
+  toBind: interfaces.BindingWhenOnSyntax<T>,
+  named: Syringe.Named,
+): void {
+  toBind.whenTargetNamed(namedToIdentifier(named));
+}
+
+export function bindGeneralToken<T>(
+  token: interfaces.ServiceIdentifier<T>,
+  ictx: InversifyContext,
+): interfaces.BindingToSyntax<T> {
+  return ictx.container.bind(tokenToIdentifier(token));
+}
+export function bindMonoToken<T>(
+  token: interfaces.ServiceIdentifier<T>,
+  ictx: InversifyContext,
+): interfaces.BindingToSyntax<T> {
+  if (ictx.container.isBound(tokenToIdentifier(token))) {
+    try {
+      return ictx.container.rebind(tokenToIdentifier(token));
+    } catch (ex) {
+      // not bind in crrent container
+      return ictx.container.bind(tokenToIdentifier(token));
+    }
+  }
+  return ictx.container.bind(tokenToIdentifier(token));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function namedToIdentifier(named: Syringe.Named): string | symbol {
+  if (Utils.isDefinedToken(named)) {
+    return named.symbol;
+  }
+  return named;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function tokenToIdentifier<T = any>(
+  token: Syringe.Token<T>,
+): interfaces.ServiceIdentifier<T> {
+  if (Utils.isDefinedToken(token)) {
+    return token.symbol;
+  }
+  return token;
+}
+
+export const GlobalContainer = new Container();
+
+export * from './inversify-protocol';

package/src/ioc/inversify-api/inversify-protocol.ts

@@ -0,0 +1,31 @@
+import type { interfaces } from 'inversify';
+
+export type InversifyContext = {
+  container: InversifyRegister;
+};
+export function isInversifyContext(data: Record<any, any>): data is InversifyContext {
+  return (
+    data &&
+    typeof data === 'object' &&
+    'container' in data &&
+    isInversifyRegister(data['container'])
+  );
+}
+
+export type InversifyRegister = {
+  bind: interfaces.Bind;
+  unbind: interfaces.Unbind;
+  isBound: interfaces.IsBound;
+  rebind: interfaces.Rebind;
+};
+
+export function isInversifyRegister(data: Record<any, any>): data is InversifyRegister {
+  return (
+    data &&
+    typeof data === 'object' &&
+    'bind' in data &&
+    'unbind' in data &&
+    'rebind' in data &&
+    'isBound' in data
+  );
+}

package/src/ioc/module/index.spec.ts

@@ -0,0 +1,68 @@
+import assert from 'assert';
+
+import type { Contribution } from '..';
+import { injectable, Module, GlobalContainer, Syringe, singleton, contrib } from '..';
+
+describe('module', () => {
+  it('#load module', () => {
+    @injectable()
+    class Foo {}
+    class Bar {}
+    const module = Module().register(Foo, Bar);
+    GlobalContainer.load(module);
+    const foo = GlobalContainer.get(Foo);
+    assert(foo instanceof Foo);
+  });
+
+  it('#check module', () => {
+    @injectable()
+    class Foo {}
+    class Bar {}
+    const module = Module().register(Foo, Bar);
+
+    assert(Syringe.isModule(module));
+    assert(!Syringe.isModule({}));
+  });
+
+  it('#load module once', () => {
+    @injectable()
+    class Foo {}
+    const module = Module().register(Foo);
+    GlobalContainer.load(module);
+    GlobalContainer.load(module);
+    const foo = GlobalContainer.get(Foo);
+    assert(foo instanceof Foo);
+  });
+
+  it('#force load module twice', () => {
+    @injectable()
+    class Foo {}
+    const module = Module().register(Foo);
+    GlobalContainer.load(module);
+    GlobalContainer.load(module, true);
+    try {
+      GlobalContainer.get(Foo);
+    } catch (ex) {
+      assert(ex);
+    }
+  });
+
+  it('#register contribution in module', () => {
+    const FooContribution = Syringe.defineToken('FooContribution');
+    @singleton({ contrib: FooContribution })
+    class Foo {}
+    @singleton()
+    class Bar {
+      public provider: Contribution.Provider<any>;
+      constructor(@contrib(FooContribution) provider: Contribution.Provider<any>) {
+        this.provider = provider;
+      }
+    }
+    const module = Module().contribution(FooContribution).register(Foo, Bar);
+    GlobalContainer.load(module);
+    const bar = GlobalContainer.get(Bar);
+    const list = bar.provider.getContributions();
+    assert(list.length === 1);
+    assert(list.find((item) => item instanceof Foo));
+  });
+});

package/src/ioc/module/index.ts

@@ -0,0 +1,7 @@
+import { SyringeModule } from './syringe-module';
+
+export * from './syringe-module';
+
+export function Module(name?: string): SyringeModule {
+  return new SyringeModule(name);
+}

package/src/ioc/module/syringe-module.ts

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-invalid-this */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { interfaces } from 'inversify';
+import { ContainerModule } from 'inversify';
+
+import { contributionInjectOption } from '../contribution/contribution-register';
+import type { Syringe } from '../core';
+import { Utils } from '../core';
+import type { InversifyRegister } from '../inversify-api';
+import { Register } from '../register';
+
+type TokenOrOption<T> = Syringe.Token<T> | Syringe.InjectOption<T>;
+
+export class SyringeModule<T = Syringe.Module> implements Syringe.Module {
+  protected dependencies: T[] = [];
+  /**
+   * @readonly
+   * module unique id
+   */
+  readonly id: number;
+  protected moduleName?: string | undefined;
+  readonly inversifyModule: ContainerModule;
+
+  protected optionCollection?: (Syringe.Token<any> | Syringe.InjectOption<any>)[];
+
+  get name() {
+    return this.moduleName;
+  }
+  constructor(name?: string) {
+    this.moduleName = name;
+    this.inversifyModule = new ContainerModule(this.inversifyRegister);
+    this.id = this.inversifyModule.id;
+  }
+  protected inversifyRegister = (
+    bind: interfaces.Bind,
+    unbind: interfaces.Unbind,
+    isBound: interfaces.IsBound,
+    rebind: interfaces.Rebind,
+  ) => {
+    const inversifyRegister: InversifyRegister = {
+      bind,
+      unbind,
+      isBound,
+      rebind,
+    };
+    const register = <T = any>(
+      token: Syringe.Token<T> | Syringe.InjectOption<T>,
+      options: Syringe.InjectOption<T> = {},
+    ): void => {
+      if (Utils.isInjectOption(token)) {
+        Register.resolveOption({ container: inversifyRegister }, token);
+      } else {
+        Register.resolveTarget({ container: inversifyRegister }, token, options);
+      }
+    };
+    if (this.optionCollection) {
+      this.optionCollection.forEach((option) => register(option));
+    }
+  };
+
+  protected get options() {
+    if (!this.optionCollection) {
+      this.optionCollection = [];
+    }
+    return this.optionCollection;
+  }
+  register(...options: TokenOrOption<any>[]) {
+    options.forEach((option) => this.options.push(option));
+    return this;
+  }
+
+  contribution(...tokens: Syringe.DefinedToken[]) {
+    tokens.forEach((token) => this.options.push(contributionInjectOption(token)));
+    return this;
+  }
+
+  dependOn(...modules: T[]) {
+    this.dependencies.push(...modules);
+    return this;
+  }
+
+  toLoader(): SyringeModuleLoader<T> {
+    return {
+      dependencies: this.dependencies.length > 0 ? this.dependencies : undefined,
+    };
+  }
+}
+
+export interface SyringeModuleLoader<T = Syringe.Module> {
+  dependencies?: T[];
+}
+
+export function isSyringeModule(data: Syringe.Module): data is SyringeModule {
+  return data && 'inversifyModule' in data;
+}

package/src/ioc/register.spec.ts

@@ -0,0 +1,75 @@
+import assert from 'assert';
+
+import { injectable } from 'inversify';
+
+import { Syringe, Utils } from './core';
+
+describe('register helper', () => {
+  describe('option parser', () => {
+    it('#simple class', () => {
+      @injectable()
+      class Foo {}
+      const parsed = Utils.toRegistryOption({
+        token: Foo,
+        useClass: Foo,
+      });
+      assert(parsed.token.length === 1);
+      assert(parsed.token.includes(Foo));
+      assert(parsed.useClass.length === 1);
+      assert(parsed.useClass.includes(Foo));
+      assert(parsed.lifecycle === Syringe.DefaultOption.lifecycle);
+    });
+    it('#simple token', () => {
+      @injectable()
+      class Foo {}
+      const parsed = Utils.toRegistryOption({
+        token: Foo,
+        lifecycle: Syringe.Lifecycle.singleton,
+      });
+      assert(parsed.token.length === 1);
+      assert(parsed.token.includes(Foo));
+      assert(parsed.lifecycle === Syringe.Lifecycle.singleton);
+    });
+    it('#multiple', () => {
+      @injectable()
+      class Foo {}
+      @injectable()
+      class Bar {}
+      const parsed = Utils.toRegistryOption({
+        token: Foo,
+        useClass: [Foo, Bar],
+      });
+      assert(parsed.token.length === 1);
+      assert(parsed.token.includes(Foo));
+      assert(parsed.useClass.length === 2);
+      assert(parsed.useClass.includes(Foo));
+      assert(parsed.useClass.includes(Bar));
+    });
+    it('#undefined value', () => {
+      const TokenSymbol = Symbol('UndefinedToken');
+      const parsed = Utils.toRegistryOption({
+        token: TokenSymbol,
+        useValue: undefined,
+      });
+      assert(parsed.token.length === 1);
+      assert(parsed.token.includes(TokenSymbol));
+      assert(parsed.useValue === undefined);
+      assert('useValue' in parsed);
+      assert(parsed.lifecycle === Syringe.DefaultOption.lifecycle);
+    });
+  });
+
+  describe('error option', () => {
+    it('#Named token can not be service to other tokens', () => {
+      const named = 'named';
+      @injectable()
+      class Foo {}
+      const parsed = Utils.toRegistryOption({
+        token: { token: Foo, named },
+      });
+      assert(parsed.token.length === 1);
+      assert(parsed.token.find((item) => Utils.isNamedToken(item)));
+      assert(parsed.lifecycle === Syringe.DefaultOption.lifecycle);
+    });
+  });
+});