implab/implabjs-core Commit - r125:a19ad0acfd39

working on fluent container configuration

cin -

r125:a19ad0acfd39 ioc ts support

parent child

Context file:

r125:a19ad0acfd39

Collapse all files

src/main/ts/di/fluent/interfaces.ts created 644 +38 0

			@@ -0,0 +1,38
		1	import { primitive } from "../../safe";
		2	import { ActivationType } from "../interfaces";
		3
		4	type ExtractService<K, S> = K extends keyof S ? S[K] : K;
		5
		6	type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
		7	D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
		8	D extends { $type: new (...args: any[]) => infer I } ? I :
		9	D extends { $factory: (...args: any[]) => infer R } ? R :
		10	WalkDependencies<D, S>;
		11
		12	type WalkDependencies<D, S> = D extends primitive ? D :
		13	{ [K in keyof D]: ExtractDependency<D[K], S> };
		14
		15	export interface TypeBuilder<T, S extends object> {
		16	type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
		17	target: C, ...params: P): ConstructorBuilder<C, S>;
		18	factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
		19	target: F, ...params: P): FactoryBuilder<F, S>;
		20	}
		21
		22	export interface ServiceBuilder<T, S extends object> {
		23	override<K extends keyof S>(name: K, builder: S[K] \| ((t: TypeBuilder<S[K], S>) => any)): this;
		24	activate(activation: ActivationType): this;
		25	inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P): this;
		26	}
		27
		28	export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends ServiceBuilder<InstanceType<C>, S> {
		29	$type: C;
		30	}
		31
		32	export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends ServiceBuilder<ReturnType<F>, S> {
		33	$factory: F;
		34	}
		35
		36	export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
		37	register<K extends Y>(name: K, builder: S[K] \| ((t: TypeBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
		38	}

src/main/ts/di/Annotations.ts +1 -1

              import { primitive } from "../safe";
              import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";
              export interface InjectOptions {
                  lazy?: boolean;
              }
              type Compatible<T1, T2> = T2 extends T1 ? any : never;
              type ExtractService<K, S> = K extends keyof S ? S[K] : K;
              type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
                  D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
                  D extends { $type: new (...args: any[]) => infer I } ? I :
                  WalkDependencies<D, S>;
              type WalkDependencies<D, S> = D extends primitive ? D :
                  { [K in keyof D]: ExtractDependency<D[K], S> };
              export class Builder<T, S extends object> {
                  declare<P extends any[]>(...args: P) {
                      return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
                      };
                  }
                  inject<P extends any[]>(...args: P) {
                      return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
                          target: X,
                          memberName: M,
                          descriptor: TypedPropertyDescriptor<Compatible<(...args: ExtractDependency<P, S>) => any, T[M]>>
                      ) => {
                      };
                  }
                  getDescriptor(): TypeRegistration<new () => T, S> {
                      throw new Error();
                  }
              }
              export interface DependencyOptions<T> {
                  optional?: boolean;
                  default?: T;
              }
              export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
                  lazy: true;
              }
              interface Declaration<S extends object> {
                  define<T>(): Builder<T, S>;
                  dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
                  dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
-                 $type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => any>(target: C, ...params: P): StrictTypeRegistration<C, S>;
+                 $type<T, P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(target: C, ...params: P): StrictTypeRegistration<C, S>;
                  configure(): Config<S>;
              }
              type ServiceModule<T, S extends object, M extends string = "service"> = {
                  [m in M]: Builder<T, S>;
              };
              type PromiseOrValue<T> = PromiseLike<T> | T;
              export interface Config<S extends object, Y extends keyof S = keyof S> {
                  register<K extends Y>(name: K, m: { $from: Promise<ServiceModule<S[K], S>> }): Config<S, Exclude<Y, K>>;
                  register<K extends Y, M extends string>(name: K, m: { $from: Promise<ServiceModule<S[K], S, M>>, service: M }): Config<S, Exclude<Y, K>>;
                  register<K extends Y>(name: K, m: Registration<S[K], S>): Config<S, Exclude<Y, K>>;
                  registerType<K extends Y, P extends any[]>(
                      name: K, $type: new (...args: ExtractDependency<P, S>) => S[K], ...params: P): Config<S, Exclude<Y, K>>;
              }
              export declare function declare<S extends object>(): Declaration<S>;

src/test/ts/mock/Bar.ts +4 0

              import { Foo } from "./Foo";
              import { define, dependency } from "./services";
              export const service = define<Bar>();
              @service.declare({
                  foo: dependency("foo"),
                  nested: {
                      lazy: dependency("foo", { lazy: true })
                  },
                  host: dependency("host")
              }, "")
              export class Bar {
                  barName = "bar";
                  _v: Foo | undefined;
                  constructor(_opts: {
                      foo?: Foo;
                      nested?: {
                          lazy: () => Foo
                      },
                      host: string
                  }, s: string) {
                      if (_opts && _opts.foo)
                          this._v = _opts.foo;
                  }
+                 setName(name: string) {
+                 }
                  getFoo() {
                      if (this._v === undefined)
                          throw new Error("The foo isn't set");
                      return this._v;
                  }
              }

src/test/ts/mock/config.ts +16 -9

              import { configure, dependency, Services, $type } from "./services";
              import { Foo } from "./Foo";
              import { Bar } from "./Bar";
              import { Box } from "./Box";
+             import { declare } from "../di/Annotations";
+             import { ConfigBuilder, TypeBuilder } from "../di/fluent/interfaces";
-             export const config = configure()
-                 .register("bar", { $from: import("./Bar"), service: "service" })
+             export declare function build<T>(): TypeBuilder<T, Services>;
+             export declare const config: ConfigBuilder<Services>;
+             config
+                 //.register("bar", { $from: import("./Bar"), service: "service" })
                  // .register("box", { $from: import("./Box") })
-                 .register("host", "example.com")
                  // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
-                 .register("bar2", $type(Bar,
+                 .register("bar2", s => s.type(Bar,
                      {
-                         foo: $type(Foo)
-                             .override("host", "foo.example.com")
-                             .inject("setName", dependency("host"))
+                         foo: build().type(Foo)
                              .activate("context"),
-                         host: ""
+                         nested: { lazy: dependency("foo", {lazy: true}) },
+                         host: dependency("host")
                      },
                      "")
+                     .inject("setName", dependency("host"))
                  )
-                 .registerType("box", Box, dependency("bar"));
+                 .register("box", s => s
+                     .type(Box, dependency("bar"))
+                     .activate("context")
+                 );

src/test/ts/tests/ContainerTests.ts +3 -2

              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";
              import { Box } from "ts/mock/Box";
              test("Container register/resolve tests", async t => {
                  const container = new Container<{
                      "bla-bla": string;
                      "connection": string;
                      "dbParams": {
                          timeout: number;
                          connection: string;
                      }
                  }>();
                  const connection1 = "db://localhost";
                  t.throws(
                      () => container.register("bla-bla", "bla-bla" as any),
                      "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<{
                      foo: Foo;
                      box: Bar;
                      bar: Bar;
+                     db: any;
                  }>();
                  await container.configure({
                      foo: {
                          $type: Foo
                      },
                      box: {
                          $type: Bar,
                          params: {
                              $dependency: "foo"
                          }
                      },
                      bar: {
                          $type: Bar,
-                         params: {
+                         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._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