implab/implabjs-di Commit - r5:83fa5814462d

Working on container builder

cin -

r5:83fa5814462d default

parent child

Context file:

r5:83fa5814462d

Collapse all files

src/main/ts/ContainerBuilder.ts created 644 +46 0

@@ -0,0 +1,46
	1	import { Container } from "./Container";
	2	import { DescriptorBuilder } from "./DescriptorBuilder";
	3	import { Configurable, ConfigurableKeys, ContainerServices, Descriptor, IContainerBuilder, IDescriptorBuilder, RegistrationMap, ServiceContainer } from "./interfaces";
	4	import { LifetimeManager } from "./LifetimeManager";
	5
	6	export class ContainerBuilder<S extends Configurable<S>> implements IContainerBuilder<S>{
	7
	8	private _pending = 1;
	9
	10	private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
	11
	12	private readonly _lifetimeManager = new LifetimeManager();
	13
	14	constructor(parentServices?: object) {
	15	this._services = Object.create(parentServices ? parentServices : null) as object;
	16	}
	17
	18	createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object> {
	19	return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
	20	}
	21
	22	build(): ServiceContainer<S> {
	23	this._assertBuilding();
	24	if(!this._complete())
	25	throw new Error("The configuration didn't complete.");
	26	return new Container(this._services, this._lifetimeManager);
	27	}
	28
	29	private readonly _register = <K extends ConfigurableKeys<S>>(name: K) => (descriptor: Descriptor<S, NonNullable<S[K]>>) => {
	30	this._complete();
	31	this._services[name] = descriptor;
	32	};
	33
	34	private readonly _fail = (ex: unknown) => {
	35
	36	};
	37
	38	private _assertBuilding() {
	39	throw new Error("The descriptor builder is finalized");
	40	}
	41
	42	private _complete() {
	43	return !(--this._pending);
	44	}
	45
	46	} No newline at end of file

.eslintrc.json +1 0

                         { "ignoreExpressions": true, "max": 1 }
                     ],
                     "@typescript-eslint/prefer-readonly": ["error"],
+                    "semi": "off",
                     "@typescript-eslint/semi": ["error"]
                 }

src/main/ts/ActivationContext.ts +4 -3

             import { Descriptor, ILifetime, RegistrationMap, LifetimeContainer, ConfigurableKeys } from "./interfaces";
+            import { LifetimeManager } from "./LifetimeManager";
             import { argumentNotNull } from "./traits";
             export interface ActivationContextInfo {
                 private readonly _service: Descriptor<S, unknown>;
-                private readonly _containerLifetimeManager: LifetimeContainer;
+                private readonly _containerLifetimeManager: LifetimeManager;
                 private readonly _parent: ActivationContext<S> | undefined;
                  * @param service the service to activate, this parameter is used for the
                  *  debug purpose.
                  */
-                constructor(containerLifetimeManager: LifetimeContainer, services: Partial<RegistrationMap<S>>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+                constructor(containerLifetimeManager: LifetimeManager, services: Partial<RegistrationMap<S>>, name: string, service: Descriptor<S, unknown>, cache = {}) {
                     this._name = name;
                     this._service = service;
                     this._cache = cache;
                 }
                 createContainerLifetime<T>() {
-                    return this._containerLifetimeManager.createLifetime<T>();
+                    return this._containerLifetimeManager.create<T>();
                 }
                 /** Resolves the specified dependency in the current context

src/main/ts/Container.ts +14 -39

             import { ActivationContext } from "./ActivationContext";
             import { ActivationError } from "./ActivationError";
-            import { RegistrationMap, ContainerKeys, ServiceContainer, ContainerServices, ConfigurableServices, ConfigurableKeys, ServiceLocator, Descriptor} from "./interfaces";
+            import { ContainerBuilder } from "./ContainerBuilder";
+            import { RegistrationMap, ServiceContainer, ContainerServices, ServiceLocator, IContainerBuilder, Configurable, ContainerKeys} from "./interfaces";
             import { LifetimeManager } from "./LifetimeManager";
-            import { each, isKey } from "./traits";
-            export class Container<S extends object > implements ServiceContainer<S> {
+            export class Container<S extends Configurable<S>> implements ServiceContainer<S> {
                 private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
                 private readonly _lifetimeManager: LifetimeManager;
-                private readonly _cleanup: (() => void)[];
                 private _disposed: boolean;
-                constructor(parent?: Container<S>) {
+                constructor(services: Partial<RegistrationMap<ContainerServices<S>>>, lifetimeManager: LifetimeManager) {
-                    this._services = Object.create(parent ? parent._services : null) as typeof this._services;
+                    this._services = services;
-                    this._cleanup = [];
+                    this._services.container = { activate: () => this as ContainerServices<S>["container"]};
-                    this._services.container = { activate: () => this  as ServiceLocator<ContainerServices<S>>};
+                    this._services.childContainer = { activate: () => this.createChildContainer() as ContainerServices<S>["childContainer"] };
-                    this._services.childContainer = { activate: () => this.createChildContainer() };
                     this._disposed = false;
-                    this._lifetimeManager = new LifetimeManager();
+                    this._lifetimeManager = lifetimeManager;
                 }
-                register<K extends ConfigurableKeys<S>>(name: K, service: Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>): void;
+                createChildContainer(): IContainerBuilder<S> {
-                register<K extends ConfigurableKeys<S>>(services: {[k in K]: Descriptor<ContainerServices<S>, ConfigurableServices<S>[k]>}): void;
+                    return new ContainerBuilder(this._services);
-                register<K extends ConfigurableKeys<S>>(nameOrCollection: K | {[k in K]: Descriptor<ContainerServices<S>, ConfigurableServices<S>[k]>}, service?: RegistrationMap<ContainerServices<S>>[K]) {
-                    if (!isKey(nameOrCollection)) {
-                        each(nameOrCollection, (v, k) => this.register(k, v));
-                    } else {
-                        if (!service)
-                            throw new Error("The service parameter must be a descriptor");
-                        this._services[nameOrCollection] = service;
                 }
-                createChildContainer(): ServiceContainer<S> {
+                resolve<K extends keyof ContainerServices<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
-                    return new Container(this);
+                resolve<K extends keyof ContainerServices<S>, T>(name: K, def: T): NonNullable<ContainerServices<S>[K]> | T;
+                resolve<K extends keyof ContainerServices<S>, T>(name: K, def?: T) {
-                resolve<K extends ContainerKeys<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
-                resolve<K extends ContainerKeys<S>>(name: K, def: ContainerServices<S>[K]): ContainerServices<S>[K];
-                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerServices<S>[K]): ContainerServices<S>[K] | undefined {
                     // TODO: add logging
                     // trace.debug("resolve {0}", name);
                     const d = this._services[name];
                             throw new Error(`Service '${String(name)}' isn't found`);
                     } else {
-                        const context = new ActivationContext(this, this._services, String(name), d);
+                        const context = new ActivationContext(this._lifetimeManager, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                     }
                 }
-                createLifetime<T>() {
-                    return this._lifetimeManager.create<T>();
                 destroy() {
-                    return this.dispose();
-                dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
-                    for (const f of this._cleanup)
-                        f();
                     this._lifetimeManager.destroy();
                 }
             }

src/main/ts/DescriptorBuilder.ts +6 -13

              * @template {T} Тип сервиса
              */
             export class DescriptorBuilder<S extends object, T, R extends object = object> implements IDescriptorBuilder<S, T, R> {
-                private readonly _lifetimeContainer: LifetimeContainer;
+                private readonly _lifetimeManager: LifetimeManager;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: unknown) => void;
                  * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
                  * lifetime.
                  *
-                 * @param container The lifetime container is the container where the service is to be registered.
+                 * @param lifetimeManager The lifetime container is the container where the service is to be registered.
                  * @param cb The callback to receive the built service descriptor
                  * @param eb The callback to receive the error due
                  */
-                constructor(container: LifetimeContainer, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
+                constructor(lifetimeManager: LifetimeManager, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
-                    this._lifetimeContainer = container;
+                    this._lifetimeManager = lifetimeManager;
                     this._cb = cb;
                     this._eb = eb;
                     this._overrides = {};
                         if (builder) {
                             this._defer();
                             const d = new DescriptorBuilder<S, NonNullable<S[K]>>(
-                                this._lifetimeContainer,
+                                this._lifetimeManager,
                                 result => {
                                     this._overrides[nameOrServices] = result;
                                     this._complete();
                     return this;
                 }
-                /*factory(f: (resolve: Resolver<S>) => T): void {
-                    this._assertBuilding();
-                    this._factory = f;
-                    this._finalize();
-                    this._complete();
-                }*/
                 value(v: T): void {
                     this._assertBuilding();
                     this._cb({
                 _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> {
                     switch (activation) {
                         case "container":
-                            return LifetimeManager.containerLifetime(this._lifetimeContainer);
+                            return this._lifetimeManager.create();
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":

src/main/ts/DescriptorImpl.ts +3 -3

-            import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref } from "./interfaces";
+            import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref, IActivationContext } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { each, isKey, key } from "./traits";
                         this._deps = dependencies;
                 }
-                activate(context: ActivationContext<S>): T {
+                activate(context: IActivationContext<S>): T {
                     if (this._lifetime.has())
                         return this._lifetime.get();
                         }
                     };
-                    const makeRefs = (deps?: DepsMap<key, keyof S>) => deps ?
+                    const makeRefs = (deps: typeof this._deps) => deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];

src/main/ts/FluentConfiguration.ts +4 -26

@@ -1,5 +1,5
1	import { DescriptorBuilder } from "./DescriptorBuilder";	1	import { DescriptorBuilder } from "./DescriptorBuilder";
2	import { ConfigurableKeys, ContainerServices, ~~ConfigurableServices~~, RegistrationBuildersMap, ExtractRequired } from "./interfaces";	2	import { ConfigurableKeys, ContainerServices, RegistrationBuildersMap, ExtractRequired, IContainerBuilder } from "./interfaces";
3	import { ServiceContainer } from "./interfaces";	3	import { ServiceContainer } from "./interfaces";
4	import { argumentNotNull, each, isKey } from "./traits";	4	import { argumentNotNull, each, isKey } from "./traits";
5		5
@@ -61,33 +61,11 export class FluentConfiguration<S exten
61	return this;	61	return this;
62	}	62	}
63		63
64		64	configure<T extends IContainerBuilder<S>>(builder: T) {
65	apply<T extends ServiceContainer<S>>(target: T) {
66
67	let pending = 1;
68
69	const reject = (ex: unknown) => { throw ex; };
70
71	const complete = () => !--pending;
72
73	each(this._builders, (v, k) => {	65	each(this._builders, (v, k) => {
74	pending++;	66	v(builder.createServiceBuilder(k));
75	const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(
76	target,
77	result => {
78	target.register(k, result);
79	complete();
80	},
81	reject
82	);
83
84
85	v(d);
86	});	67	});
87	if (!complete())	68	builder.build() as T & ServiceContainer<S>;
88	throw new Error("The configuration didn't complete.");
89
90	return target as T & ServiceContainer<S>;
91	}	69	}
92		70
93	}	71	}

src/main/ts/LifetimeManager.ts +2 -2

-            import { IDestroyable, ILifetime } from "./interfaces";
+            import { IActivationContext, IDestroyable, ILifetime } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { argumentNotNull, isDestroyable } from "./traits";
                 static hierarchyLifetime<T>() {
                     let _lifetime: ILifetime<T> = unknownLifetime;
                     return {
-                        initialize(context: ActivationContext<object>) {
+                        initialize(context: IActivationContext<object>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");

src/main/ts/interfaces.ts +26 -17

             import { ActivationContext } from "./ActivationContext";
             import { key } from "./traits";
-            export type primitive = number | string | null | undefined | symbol;
             export interface IDestroyable {
                 destroy(): void;
             }
             export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T>) => void;
             export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
-                [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[k]>>
+                [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<S[k]>>
             };
             export interface Descriptor<S extends object, T> {
-                activate(context: ActivationContext<S>): T;
+                activate(context: IActivationContext<S>): T;
             }
-            export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>;
+            export interface IActivationContext<S extends object> extends ServiceLocator<S> {
+                createLifetime<T>(): ILifetime<T>;
+                createContainerLifetime<T>(): ILifetime<T>;
+            }
+            export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, S[K]>;
             export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
                 [k in K]-?: Descriptor<S, S[k]>;
             };
-            export interface ProvidedServices<S extends object> {
+            export interface ContainerProvided<S extends Configurable<S>> {
                 container: ServiceLocator<ContainerServices<S>>;
-                childContainer: ServiceContainer<S>;
+                childContainer: IContainerBuilder<S>;
             }
-            export type ProvidedKeys = keyof ProvidedServices<object>;
+            export type Configurable<S> = { [k in keyof S & (keyof ContainerProvided<never>)]: never; };
-            export type ContainerKeys<S extends object> = keyof ContainerServices<S>;
-            export type Mix<S, X> = { [k in keyof (S & X)]: k extends keyof X ? X[k] : S[k & keyof S] };
+            export type ProvidedKeys = keyof ContainerProvided<never>;
-            export type ContainerServices<S extends object> = Mix<S, ProvidedServices<S>>;
+            export type ContainerServices<S extends Configurable<S>> = S & ContainerProvided<S>;
             export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
             export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
+            export type ContainerKeys<S extends Configurable<S>> = keyof S | keyof ContainerProvided<never>;
             export interface ServiceLocator<S extends object> {
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
                 createLifetime<T>(): ILifetime<T>;
             }
-            export interface ServiceContainer<S extends object> extends ServiceLocator<ContainerServices<S>>, LifetimeContainer, IDestroyable {
+            export interface ServiceContainer<S extends Configurable<S>> extends
+                ServiceLocator<ContainerServices<S>>,
+                IDestroyable {
-                register<K extends ConfigurableKeys<S>>(name: K, service: ConfigurableDescriptor<S, K>): void;
+                createChildContainer(): IContainerBuilder<S>;
-                register<K extends ConfigurableKeys<S>>(services: { [k in K]: ConfigurableDescriptor<S, K> }): void;
-                createChildContainer(): ServiceContainer<S>;
+            export interface IContainerBuilder<S extends Configurable<S>> {
+                createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>>;
+                build(): ServiceContainer<S>;
             }
                 get(): T;
-                initialize(context: ActivationContext<object>): void;
+                initialize(context: IActivationContext<object>): void;
                 store(item: T, cleanup?: (item: T) => void): void;
             }

src/test/ts/t/container.ts +8 -3

             /* eslint max-classes-per-file: ["error", 20] */
             import { describe, it } from "mocha";
             import { Container } from "../Container";
+            import { ContainerServices } from "../interfaces";
             import { fluent } from "../traits";
             class Foo {
                 })
                 .done({});
-            declare const container: Container<Record<string, never>>;
+            declare const container: Container<object>;
-            const c2 = config.apply(container);
+            const c2 = config.configure(container);
-            c2.resolve("foo");
  No newline at end of file
+            c2.resolve("foo");
+            declare const m :ContainerServices<{foo: Foo}>["container"];
+            m.resolve("container").resolve("container");
  No newline at end of file

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