implab/implabjs-core Commit - r111:33420a95f637

Working on IoC container configuration

cin -

r111:33420a95f637 ioc ts support

parent child

Context file:

r111:33420a95f637

Collapse all files

src/main/ts/di/Annotations.ts +6 -19

              import { Constructor } from "../interfaces";
              export interface InjectOptions {
                  lazy?: boolean;
              }
              type Setter<T = any> = (v: T) => void;
-             type Injector<T> = {
-                 [k in keyof T]: Setter;
-             };
              type Compatible<T1, T2> = T1 extends T2 ? any : never;
              type SetterType<T> = T extends (v: infer V) => void ? V : never;
-             type Tuple<T = any> = Parameters<(...args: T[]) => void>;
+             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
-             interface Newable<A extends Tuple, T> {
-                 new (...params: A): T;
-                 prototype: T;
+             }
+             type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
-             type MapTuple<T, A extends (keyof T)[]> = { [K in keyof A] : K extends number ? T[ A[K] ] : A[K] };
+             type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
              export class Builder<T, S> {
-                 provides() {
-                     return <C extends Constructor<T>>(constructor: C) => {
-                         return constructor;
+                 consume<P extends any[]>(...args: P) {
+                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
+                         // return constructor;
                      };
                  }
                  inject<K extends keyof S>(dependency: K) {
                      // K = "bar"
                      // M = "setValue"
                      // S[K] = Bar
                      // T[M] = (value: string) => void
                      // P[m] = (value: V) => void
                      return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
                      };
                  }
-                 dependencies<D extends (keyof S)[]>(...deps: D) {
-                     return <C extends Constructor<T>>(constructor: MapTuple<S, D> extends ConstructorParameters<C> ? C : never) => {
-                         return constructor;
-                     } ;
+                 }
              }

src/main/ts/interfaces.ts +1 -1

              export interface Constructor<T = {}> {
                  new(...args: any[]): T;
                  prototype: T;
              }
              export type Factory<T = {}> = (...args: any[]) => T;
              export type Predicate<T = any> = (x: T) => boolean;
              export interface MapOf<T> {
                  [key: string]: T;
              }
              export interface IDestroyable {
                  destroy(): void;
              }
              export interface IRemovable {
                  remove(): void;
              }
              export interface ICancellation {
                  throwIfRequested(): void;
                  isRequested(): boolean;
                  isSupported(): boolean;
                  register(cb: (e: any) => void): IDestroyable;
              }
              /**
               * Интерфейс поддерживающий асинхронную активацию
               */
              export interface IActivatable {
                  /**
                   * @returns Boolean indicates the current state
                   */
                  isActive(): boolean;
                  /**
                   * Starts the component activation
                   * @param ct cancellation token for this operation
                   */
                  activate(ct?: ICancellation): Promise<void>;
                  /**
                   * Starts the component deactivation
                   * @param ct cancellation token for this operation
                   */
                  deactivate(ct?: ICancellation): Promise<void>;
                  /**
                   * Sets the activation controller for this component
                   * @param controller The activation controller
                   *
                   * Activation controller checks whether this component
                   * can be activated and manages the active state of the
                   * component
                   */
-                 setActivationController(controller: IActivationController);
+                 setActivationController(controller: IActivationController): void;
                  /**
                   * Gets the current activation controller for this component
                   */
                  getActivationController(): IActivationController;
              }
              export interface IActivationController {
                  activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                  activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                  deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                  deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                  deactivate(ct?: ICancellation): Promise<void>;
                  activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                  getActive(): IActivatable;
              }
              export interface IAsyncComponent {
                  getCompletion(): Promise<void>;
              }
              export interface ICancellable {
                  cancel(reason?: any): void;
              }
              export interface IObservable<T> {
                  on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                  next(ct?: ICancellation): Promise<T>;
              }
              export interface IObserver<T> {
                  next(event: T): void;
                  error(e: any): void;
                  complete(): void;
              }
              export interface TextWriter {
                  write(obj: any): void;
                  write(format: string, ...args: any[]): void;
                  writeLine(obj?: any): void;
                  writeLine(format: string, ...args: any[]): void;
                  writeValue(value: any, spec?: string): void;
              }

src/test/ts/mock/Bar.ts +23 -8

              import { Foo } from "./Foo";
+             import { config } from "./config";
-             export class Bar {
-                 name = "bar";
+             const service = config.build("bar");
-                 foo: Foo | undefined;
+             @service.consume({
+                 f: config.dependency("foo"),
+                 nested: {
+                     lazy: config.lazy("foo")
+                 }
+             })
+             export class Bar {
+                 barName = "bar";
-                 constructor(_opts?: { foo?: Foo; }) {
-                     if (_opts && _opts.foo)
-                         this.foo = _opts.foo;
+                 _v: Foo | undefined;
+                 constructor(_opts: {
+                     f: Foo;
+                     nested: {
+                         lazy: () => Foo
+                     }
+                 }) {
+                     if (_opts && _opts.f)
+                         this._v = _opts.f;
                  }
                  getFoo() {
-                     if (this.foo === undefined)
+                     if (this._v === undefined)
                          throw new Error("The foo isn't set");
-                     return this.foo;
+                     return this._v;
                  }
              }

src/test/ts/mock/Box.ts +3 -4

              import { config } from "./config";
-             const service = config.service("barBox");
+             const service = config.build("barBox");
-             @service.provides()
+             @service.consume(config.dependency("bar"))
              export class Box<T> {
                  private _value: T | undefined;
                  constructor(value: T) {
                      this._value = value;
                  }
                  @service.inject("bar")
                  setValue(value: T) {
                      this._value = value;
                  }
-                 @service.inject("foo")
                  setObj(value: object) {
                  }
                  getValue() {
                      if (this._value === undefined)
                          throw new Error("Trying to get a value from the empty box");
                      return this._value;
                  }
-             }
  No newline at end of file
+             }

src/test/ts/mock/Foo.ts +1 -1

              export class Foo {
-                 name = "foo";
+                 fooName = "foo";
              }

src/test/ts/mock/config.ts +39 -1

              import { Foo } from "./Foo";
              import { Bar } from "./Bar";
              import { ActivationType } from "../di/interfaces";
              import { Builder } from "../di/Annotations";
              import { Box } from "./Box";
              interface RegistrationOptions {
                  activation?: ActivationType;
              }
+             interface Dependency<K extends keyof any> {
+                 $dependency: K;
+                 lazy?: boolean;
+             }
+             interface Lazy<K extends keyof any> extends Dependency<K> {
+                 lazy: true;
+             }
+             type PromiseOrValue<T> = T | PromiseLike<T>;
              interface ConfigBuilder<S> {
-                 service<K extends keyof S>(name: K): Builder<S[K], S>;
+                 build<K extends keyof S, T = S[K]>(name: K): Builder<T, S>;
+                 dependency<K extends keyof S>(name: K): Dependency<K>;
+                 lazy<K extends keyof S>(name: K): Lazy<K>;
+                 mapTo<K extends keyof S>(name: K, ctor: () => PromiseOrValue<new (...args: any[]) => S[K]>): ConfigBuilder<S>;
              }
              interface ContainerServices {
                  barBox: Box<Bar>;
                  foo: Foo;
                  bar: Bar;
                  password: string;
                  user: string;
                  timeout: number;
              }
+             declare function load<M, C extends keyof M>(m: PromiseLike<M>, name: C): () => PromiseLike<M[C]>;
+             const t = {
+                 barBox: load(import("./Box"), "Box"),
+                 foo: async () => (await import("./Bar")).Bar,
+                 bar: Bar,
+                 password: String,
+                 user: String,
+                 timeout: Number
+             };
              export declare const config: ConfigBuilder<ContainerServices>;
+             config
+                 .mapTo("bar", )
+                 .mapTo("barBox", ;

src/test/ts/tests/ContainerTests.ts +1 -1

              import { test } from "./TestTraits";
              import { Container } from "../di/Container";
              import { ReferenceDescriptor } from "../di/ReferenceDescriptor";
              import { AggregateDescriptor } from "../di/AggregateDescriptor";
              import { ValueDescriptor } from "../di/ValueDescriptor";
              import { Foo } from "../mock/Foo";
              import { Bar } from "../mock/Bar";
              import { isNull } from "../safe";
              test("Container register/resolve tests", async t => {
                  const container = new Container();
                  const connection1 = "db://localhost";
                  t.throws(
                      () => container.register("bla-bla", "bla-bla"),
                      "Do not allow to register anything other than descriptors"
                  );
                  t.doesNotThrow(
                      () => container.register("connection", new ValueDescriptor(connection1)),
                      "register ValueDescriptor"
                  );
                  t.equals(container.resolve("connection"), connection1, "resolve string value");
                  t.doesNotThrow(
                      () => container.register(
                          "dbParams",
                          new AggregateDescriptor({
                              timeout: 10,
                              connection: new ReferenceDescriptor({ name: "connection" })
                          })
                      ),
                      "register AggregateDescriptor"
                  );
                  const dbParams = container.resolve("dbParams");
                  t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
              });
              test("Container configure/resolve tests", async t => {
                  const container = new Container();
                  await container.configure({
                      foo: {
                          $type: Foo
                      },
                      box: {
                          $type: Bar,
                          params: {
                              $dependency: "foo"
                          }
                      },
                      bar: {
                          $type: Bar,
                          params: {
                              db: {
                                  provider: {
                                      $dependency: "db"
                                  }
                              }
                          }
                      }
                  });
                  t.pass("should configure from js object");
                  const f1 = container.resolve("foo");
                  t.assert(!isNull(f1), "foo should be not null");
                  t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
              });
              test("Load configuration from module", async t => {
                  const container = new Container();
                  await container.configure("../mock/config1", { contextRequire: require });
                  t.pass("The configuration should load");
                  const f1 = container.resolve("foo");
                  t.assert(!isNull(f1), "foo should be not null");
                  const b1 = container.resolve("bar") as Bar;
                  t.assert(!isNull(b1), "bar should not be null");
-                 t.assert(!isNull(b1.foo), "bar.foo should not be null");
+                 t.assert(!isNull(b1._v), "bar.foo should not be null");
              });

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages