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()
+            export declare function build<T>(): TypeBuilder<T, Services>;
-                .register("bar", { $from: import("./Bar"), service: "service" })
+            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)
+                        foo: build().type(Foo)
-                            .override("host", "foo.example.com")
-                            .inject("setName", dependency("host"))
                             .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