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> {
+            type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
-                new (...params: A): T;
-                prototype: T;
-            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() {
+                consume<P extends any[]>(...args: P) {
-                    return <C extends Constructor<T>>(constructor: C) => {
+                    return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
-                        return constructor;
+                        // 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

@@ -1,18 +1,33
1	import { Foo } from "./Foo";	1	import { Foo } from "./Foo";
		2	import { config } from "./config";
2		3
3	export class Bar {	4	const service = config.build("bar");
4	name = "bar";
5		5
6	foo: Foo \| undefined;	6	@service.consume({
		7	f: config.dependency("foo"),
		8	nested: {
		9	lazy: config.lazy("foo")
		10	}
		11	})
		12	export class Bar {
		13	barName = "bar";
7		14
8	constructor(_opts?: { foo?: Foo; }) {	15	_v: Foo \| undefined;
9	if (_opts && _opts.foo)	16
10	this.foo = _opts.foo;	17	constructor(_opts: {
		18	f: Foo;
		19	nested: {
		20	lazy: () => Foo
		21	}
		22	}) {
		23
		24	if (_opts && _opts.f)
		25	this._v = _opts.f;
11	}	26	}
12		27
13	getFoo() {	28	getFoo() {
14	if (this.~~foo~~ === undefined)	29	if (this._v === undefined)
15	throw new Error("The foo isn't set");	30	throw new Error("The foo isn't set");
16	return this.~~foo~~;	31	return this._v;
17	}	32	}
18	}	33	}

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