# HG changeset patch
# User cin
# Date 2022-05-27 09:54:18
# Node ID 83fa5814462d5ed3c76a4f227d0cb8c8b7249f51
# Parent  d9e74143f779f1b80b332286f85bb522d2020c5d

Working on container builder

diff --git a/.eslintrc.json b/.eslintrc.json
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -26,6 +26,7 @@
             { "ignoreExpressions": true, "max": 1 }
         ],
         "@typescript-eslint/prefer-readonly": ["error"],
+        "semi": "off",
         "@typescript-eslint/semi": ["error"]
 
     }
diff --git a/src/main/ts/ActivationContext.ts b/src/main/ts/ActivationContext.ts
--- a/src/main/ts/ActivationContext.ts
+++ b/src/main/ts/ActivationContext.ts
@@ -1,4 +1,5 @@
 import { Descriptor, ILifetime, RegistrationMap, LifetimeContainer, ConfigurableKeys } from "./interfaces";
+import { LifetimeManager } from "./LifetimeManager";
 import { argumentNotNull } from "./traits";
 
 export interface ActivationContextInfo {
@@ -23,7 +24,7 @@ export class ActivationContext<S extends
 
     private readonly _service: Descriptor<S, unknown>;
 
-    private readonly _containerLifetimeManager: LifetimeContainer;
+    private readonly _containerLifetimeManager: LifetimeManager;
 
     private readonly _parent: ActivationContext<S> | undefined;
 
@@ -35,7 +36,7 @@ export class ActivationContext<S extends
      * @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;
@@ -49,7 +50,7 @@ export class ActivationContext<S extends
     }
 
     createContainerLifetime<T>() {
-        return this._containerLifetimeManager.createLifetime<T>();
+        return this._containerLifetimeManager.create<T>();
     }
 
     /** Resolves the specified dependency in the current context
diff --git a/src/main/ts/Container.ts b/src/main/ts/Container.ts
--- a/src/main/ts/Container.ts
+++ b/src/main/ts/Container.ts
@@ -1,47 +1,31 @@
 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>) {
-        this._services = Object.create(parent ? parent._services : null) as typeof this._services;
-        this._cleanup = [];
-        this._services.container = { activate: () => this  as ServiceLocator<ContainerServices<S>>};
-        this._services.childContainer = { activate: () => this.createChildContainer() };
+    constructor(services: Partial<RegistrationMap<ContainerServices<S>>>, lifetimeManager: LifetimeManager) {
+        this._services = services;
+        this._services.container = { activate: () => this as ContainerServices<S>["container"]};
+        this._services.childContainer = { activate: () => this.createChildContainer() as ContainerServices<S>["childContainer"] };
         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;
-    register<K extends ConfigurableKeys<S>>(services: {[k in K]: Descriptor<ContainerServices<S>, ConfigurableServices<S>[k]>}): void;
-    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(): IContainerBuilder<S> {
+        return new ContainerBuilder(this._services);
     }
 
-    createChildContainer(): ServiceContainer<S> {
-        return new Container(this);
-    }
-
-    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 {
+    resolve<K extends keyof ContainerServices<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
+    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) {
         // TODO: add logging
         // trace.debug("resolve {0}", name);
         const d = this._services[name];
@@ -52,7 +36,7 @@ export class Container<S extends object 
                 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) {
@@ -61,19 +45,10 @@ export class Container<S extends object 
         }
     }
 
-    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();
     }
 }
diff --git a/src/main/ts/ContainerBuilder.ts b/src/main/ts/ContainerBuilder.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/ContainerBuilder.ts
@@ -0,0 +1,46 @@
+import { Container } from "./Container";
+import { DescriptorBuilder } from "./DescriptorBuilder";
+import { Configurable, ConfigurableKeys, ContainerServices, Descriptor, IContainerBuilder, IDescriptorBuilder, RegistrationMap, ServiceContainer } from "./interfaces";
+import { LifetimeManager } from "./LifetimeManager";
+
+export class ContainerBuilder<S extends Configurable<S>> implements IContainerBuilder<S>{
+
+    private _pending = 1;
+
+    private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
+
+    private readonly _lifetimeManager = new LifetimeManager();
+
+    constructor(parentServices?: object) {
+        this._services = Object.create(parentServices ? parentServices : null) as object;
+    }
+
+    createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object> {
+        return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
+    }
+
+    build(): ServiceContainer<S> {
+        this._assertBuilding();
+        if(!this._complete())
+            throw new Error("The configuration didn't complete.");
+        return new Container(this._services, this._lifetimeManager);
+    }
+
+    private readonly _register = <K extends ConfigurableKeys<S>>(name: K) => (descriptor: Descriptor<S, NonNullable<S[K]>>) => {
+        this._complete();
+        this._services[name] = descriptor;
+    };
+
+    private readonly _fail = (ex: unknown) => {
+
+    };
+
+    private _assertBuilding() {
+        throw new Error("The descriptor builder is finalized");
+    }
+
+    private _complete() {
+        return !(--this._pending);
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/ts/DescriptorBuilder.ts b/src/main/ts/DescriptorBuilder.ts
--- a/src/main/ts/DescriptorBuilder.ts
+++ b/src/main/ts/DescriptorBuilder.ts
@@ -9,7 +9,7 @@ import { each, isKey, isPromise, isStrin
  * @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;
@@ -34,12 +34,12 @@ export class DescriptorBuilder<S extends
      * 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) {
-        this._lifetimeContainer = container;
+    constructor(lifetimeManager: LifetimeManager, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
+        this._lifetimeManager = lifetimeManager;
         this._cb = cb;
         this._eb = eb;
         this._overrides = {};
@@ -92,7 +92,7 @@ export class DescriptorBuilder<S extends
             if (builder) {
                 this._defer();
                 const d = new DescriptorBuilder<S, NonNullable<S[K]>>(
-                    this._lifetimeContainer,
+                    this._lifetimeManager,
                     result => {
                         this._overrides[nameOrServices] = result;
                         this._complete();
@@ -130,13 +130,6 @@ export class DescriptorBuilder<S extends
         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({
@@ -150,7 +143,7 @@ export class DescriptorBuilder<S extends
     _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":
diff --git a/src/main/ts/DescriptorImpl.ts b/src/main/ts/DescriptorImpl.ts
--- a/src/main/ts/DescriptorImpl.ts
+++ b/src/main/ts/DescriptorImpl.ts
@@ -1,4 +1,4 @@
-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";
 
@@ -40,7 +40,7 @@ export class DescriptorImpl<S extends ob
             this._deps = dependencies;
     }
 
-    activate(context: ActivationContext<S>): T {
+    activate(context: IActivationContext<S>): T {
 
         if (this._lifetime.has())
             return this._lifetime.get();
@@ -58,7 +58,7 @@ export class DescriptorImpl<S extends ob
             }
         };
 
-        const makeRefs = (deps?: DepsMap<key, keyof S>) => deps ?
+        const makeRefs = (deps: typeof this._deps) => deps ?
             Object.keys(deps)
                 .map(k => {
                     const ref = deps[k];
diff --git a/src/main/ts/FluentConfiguration.ts b/src/main/ts/FluentConfiguration.ts
--- a/src/main/ts/FluentConfiguration.ts
+++ b/src/main/ts/FluentConfiguration.ts
@@ -1,5 +1,5 @@
 import { DescriptorBuilder } from "./DescriptorBuilder";
-import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, ExtractRequired } from "./interfaces";
+import { ConfigurableKeys, ContainerServices, RegistrationBuildersMap, ExtractRequired, IContainerBuilder } from "./interfaces";
 import { ServiceContainer } from "./interfaces";
 import { argumentNotNull, each, isKey } from "./traits";
 
@@ -61,33 +61,11 @@ export class FluentConfiguration<S exten
         return this;
     }
 
-
-    apply<T extends ServiceContainer<S>>(target: T) {
-
-        let pending = 1;
-
-        const reject = (ex: unknown) => { throw ex; };
-
-        const complete = () => !--pending;
-
+    configure<T extends IContainerBuilder<S>>(builder: T) {
         each(this._builders, (v, k) => {
-            pending++;
-            const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(
-                target,
-                result => {
-                    target.register(k, result);
-                    complete();
-                },
-                reject
-            );
-
-
-            v(d);
+            v(builder.createServiceBuilder(k));
         });
-        if (!complete())
-            throw new Error("The configuration didn't complete.");
-
-        return target as T & ServiceContainer<S>;
+        builder.build() as T & ServiceContainer<S>;
     }
 
 }
diff --git a/src/main/ts/LifetimeManager.ts b/src/main/ts/LifetimeManager.ts
--- a/src/main/ts/LifetimeManager.ts
+++ b/src/main/ts/LifetimeManager.ts
@@ -1,4 +1,4 @@
-import { IDestroyable, ILifetime } from "./interfaces";
+import { IActivationContext, IDestroyable, ILifetime } from "./interfaces";
 import { ActivationContext } from "./ActivationContext";
 import { argumentNotNull, isDestroyable } from "./traits";
 
@@ -115,7 +115,7 @@ export class LifetimeManager implements 
     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");
 
diff --git a/src/main/ts/interfaces.ts b/src/main/ts/interfaces.ts
--- a/src/main/ts/interfaces.ts
+++ b/src/main/ts/interfaces.ts
@@ -1,8 +1,6 @@
 import { ActivationContext } from "./ActivationContext";
 import { key } from "./traits";
 
-export type primitive = number | string | null | undefined | symbol;
-
 export interface IDestroyable {
     destroy(): void;
 }
@@ -32,10 +30,10 @@ export interface Resolver<S extends obje
 
 export type DepsMap<K extends key, SK extends key> = { [k in K]: SK | Ref<SK, boolean, unknown> };
 
-export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L} | { name: K, lazy?: L, default: D };
+export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L } | { name: K, lazy?: L, default: D };
 
 export type Resolved<S, K extends keyof S, L, D> =
-    L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> |  (unknown extends D ? never : D);
+    L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> | (unknown extends D ? never : D);
 
 export interface IDescriptorBuilder<S extends object, T, R extends object = object> {
 
@@ -49,7 +47,7 @@ export interface IDescriptorBuilder<S ex
         IDescriptorBuilder<S, T, R & {
             [k in keyof X]:
             X[k] extends keyof S ? NonNullable<S[X[k]]> :
-            X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S,K & keyof S,L,D>:
+            X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
             never
         }>
 
@@ -67,37 +65,43 @@ export interface IDescriptorBuilder<S ex
 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 ContainerKeys<S extends object> = keyof ContainerServices<S>;
+export type Configurable<S> = { [k in keyof S & (keyof ContainerProvided<never>)]: never; };
 
-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;
@@ -107,12 +111,17 @@ export interface LifetimeContainer {
     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;
-    register<K extends ConfigurableKeys<S>>(services: { [k in K]: ConfigurableDescriptor<S, K> }): void;
+    createChildContainer(): IContainerBuilder<S>;
+}
 
-    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>;
 }
 
 
@@ -128,7 +137,7 @@ export interface ILifetime<T> {
 
     get(): T;
 
-    initialize(context: ActivationContext<object>): void;
+    initialize(context: IActivationContext<object>): void;
 
     store(item: T, cleanup?: (item: T) => void): void;
 }
diff --git a/src/test/ts/t/container.ts b/src/test/ts/t/container.ts
--- a/src/test/ts/t/container.ts
+++ b/src/test/ts/t/container.ts
@@ -1,6 +1,7 @@
 /* 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 {
@@ -59,7 +60,11 @@ const config = fluent()
     })
     .done({});
 
-declare const container: Container<Record<string, never>>;
-const c2 = config.apply(container);
+declare const container: Container<object>;
+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