# HG changeset patch
# User cin
# Date 2020-07-28 14:03:57
# Node ID 0866c62592851e4c8fc9670ca81a285076298c60
# Parent  674555892e141b526fbfa82b0203352bf3c394ff

working on fluent configuration

diff --git a/src/main/ts/di/ActivationContext.ts b/src/main/ts/di/ActivationContext.ts
--- a/src/main/ts/di/ActivationContext.ts
+++ b/src/main/ts/di/ActivationContext.ts
@@ -120,4 +120,11 @@ export class ActivationContext<S extends
         clone._service = service;
         return clone;
     }
+
+    /** Creates a clone for the current context, used to protect it from modifications */
+    clone(): this {
+        const clone = Object.create(this);
+        clone._services = Object.create(this._services);
+        return clone;
+    }
 }
diff --git a/src/main/ts/di/Annotations.ts b/src/main/ts/di/Annotations.ts
--- a/src/main/ts/di/Annotations.ts
+++ b/src/main/ts/di/Annotations.ts
@@ -1,5 +1,6 @@
 import { TypeRegistration } from "./Configuration";
 import { ExtractDependency } from "./fluent/interfaces";
+import { RegistrationBuilder } from "./fluent/RegistrationBuilder";
 
 export class AnnotaionBuilder<T, S extends object> {
     wire<P extends any[]>(...args: P) {
@@ -22,4 +23,8 @@ export class AnnotaionBuilder<T, S exten
         throw new Error();
     }
 
+    getRegistrationBuilder(): RegistrationBuilder<T, S> {
+        throw new Error();
+    }
+
 }
diff --git a/src/main/ts/di/Configuration.ts b/src/main/ts/di/Configuration.ts
--- a/src/main/ts/di/Configuration.ts
+++ b/src/main/ts/di/Configuration.ts
@@ -19,6 +19,7 @@ import { makeResolver } from "./Resolver
 import { ICancellation } from "../interfaces";
 import { isDescriptor } from "./traits";
 import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
+import { LifetimeManager } from "./LifetimeManager";
 
 export interface RegistrationScope<S extends object> {
 
@@ -74,8 +75,6 @@ export interface LazyDependencyRegistrat
     lazy: true;
 }
 
-type OfType<K extends keyof S, S, T> = Extract<{ [k in K]: T}, S>;
-
 export type Registration<T, S extends object> = T extends primitive ? T :
     (
         T |
@@ -325,7 +324,6 @@ export class Configuration<S extends obj
 
     _makeServiceParams(data: ServiceRegistration<any, S>) {
         const opts: any = {
-            owner: this._container
         };
         if (data.services)
             opts.services = this._visitRegistrations(data.services, "services");
@@ -347,7 +345,7 @@ export class Configuration<S extends obj
                 this._visit(data.params, "params");
 
         if (data.activation) {
-            opts.activation = data.activation;
+            opts.activation = this._getLifetimeManager(data.activation);
         }
 
         if (data.cleanup)
@@ -412,4 +410,19 @@ export class Configuration<S extends obj
         this._leave();
         return d;
     }
+
+    _getLifetimeManager(activation: ActivationType) {
+        switch (activation) {
+            case "container":
+                return this._container.getLifetimeManager();
+            case "hierarchy":
+                return LifetimeManager.hierarchyLifetime;
+            case "context":
+                return LifetimeManager.contextLifetime;
+            case "singleton":
+                return LifetimeManager.singletonLifetime;
+            default:
+                return LifetimeManager.empty;
+        }
+    }
 }
diff --git a/src/main/ts/di/LazyReferenceDescriptor.ts b/src/main/ts/di/LazyReferenceDescriptor.ts
--- a/src/main/ts/di/LazyReferenceDescriptor.ts
+++ b/src/main/ts/di/LazyReferenceDescriptor.ts
@@ -41,7 +41,7 @@ export class LazyReferenceDescriptor<S e
         return (cfg?: PartialServiceMap<S>) => {
             // защищаем контекст на случай исключения в процессе
             // активации
-            const ct = saved.clone();
+            const ct = cfg ? saved.clone() : saved;
             try {
                 if (cfg) {
                     each(cfg, (v, k) => ct.register(k, v));
diff --git a/src/main/ts/di/LifetimeManager.ts b/src/main/ts/di/LifetimeManager.ts
--- a/src/main/ts/di/LifetimeManager.ts
+++ b/src/main/ts/di/LifetimeManager.ts
@@ -35,9 +35,10 @@ export class LifetimeManager implements 
     private _cache: MapOf<any> = {};
     private _destroyed = false;
 
+    private _pending: MapOf<boolean> = {};
+
     initialize(id: string): ILifetime {
         const self = this;
-        let pending = false;
         return {
             has() {
                 return (id in self._cache);
@@ -51,9 +52,9 @@ export class LifetimeManager implements 
             },
 
             enter() {
-                if (pending)
+                if (self._pending[id])
                     throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
-                pending = true;
+                self._pending[id] = true;
             },
 
             store(item: any, cleanup?: (item: any) => void) {
@@ -62,7 +63,7 @@ export class LifetimeManager implements 
 
                 if (this.has())
                     throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-                pending = false;
+                delete self._pending[id];
 
                 self._cache[id] = item;
 
diff --git a/src/main/ts/di/ServiceDescriptor.ts b/src/main/ts/di/ServiceDescriptor.ts
--- a/src/main/ts/di/ServiceDescriptor.ts
+++ b/src/main/ts/di/ServiceDescriptor.ts
@@ -62,8 +62,6 @@ export type InjectionSpec<T> = {
 };
 
 export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
-    owner: Container<S>;
-
     lifetime?: ILifetimeManager;
 
     params?: P;
@@ -88,12 +86,7 @@ export class ServiceDescriptor<S extends
 
     _lifetime = LifetimeManager.empty;
 
-    _owner: Container<S>;
-
     constructor(opts: ServiceDescriptorParams<S, T, P>) {
-        argumentNotNull(opts && opts.owner, "opts.owner");
-
-        this._owner = opts.owner;
 
         if (opts.lifetime)
             this._lifetime = opts.lifetime;
diff --git a/src/main/ts/di/TypeServiceDescriptor.ts b/src/main/ts/di/TypeServiceDescriptor.ts
--- a/src/main/ts/di/TypeServiceDescriptor.ts
+++ b/src/main/ts/di/TypeServiceDescriptor.ts
@@ -1,13 +1,12 @@
 import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
-import { Constructor, Factory } from "../interfaces";
 import { argumentNotNull, isPrimitive } from "../safe";
 
 export interface TypeServiceDescriptorParams<S extends object, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
-    type: Constructor<T>;
+    type: new (...args: any[]) => T;
 }
 
 export class TypeServiceDescriptor<S extends object, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
-    _type: Constructor;
+    _type: new (...args: any[]) => T;
 
     constructor(opts: TypeServiceDescriptorParams<S, T, P>) {
         super(opts);
@@ -18,9 +17,10 @@ export class TypeServiceDescriptor<S ext
         if (this._params) {
             if (this._params.length) {
                 this._factory = (...args) => {
-                    const t = Object.create(ctor.prototype);
+                    /*const t = Object.create(ctor.prototype);
                     const inst = ctor.apply(t, args);
-                    return isPrimitive(inst) ? t : inst;
+                    return isPrimitive(inst) ? t : inst;*/
+                    return new ctor(...args);
                 };
             } else {
                 this._factory = arg => {
diff --git a/src/main/ts/di/fluent/ConfigBuilder.ts b/src/main/ts/di/fluent/ConfigBuilder.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/di/fluent/ConfigBuilder.ts
@@ -0,0 +1,17 @@
+import { Container } from "../Container";
+import { ExtractDependency, ServiceRecordBuilder } from "./interfaces";
+
+export class ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
+    register<K extends Y>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void | Promise<void>): ConfigBuilder<S, Exclude<Y, K>>;
+    register<K extends Y, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): ConfigBuilder<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, value: S[K], raw: true): ConfigBuilder<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, value: any, raw = false): ConfigBuilder<S, Exclude<Y, K>> {
+
+        return this;
+    }
+
+    apply(container: Container<S>): PromiseLike<void> {
+        
+        return Promise.resolve();
+    }
+}
diff --git a/src/main/ts/di/fluent/ConstructorBuiler.ts b/src/main/ts/di/fluent/ConstructorBuiler.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/di/fluent/ConstructorBuiler.ts
@@ -0,0 +1,17 @@
+import { RegistrationBuilder } from "./RegistrationBuilder";
+
+export class ConstructorBuilder<C extends new (...args: any[]) => any, S extends object>
+    extends RegistrationBuilder<InstanceType<C>, S> {
+
+    $type: C;
+
+    _params: any;
+
+    constructor(target: C, params: any) {
+        super();
+        this.$type = target;
+
+        this._params = params;
+    }
+
+}
diff --git a/src/main/ts/di/fluent/FactoryBuilder.ts b/src/main/ts/di/fluent/FactoryBuilder.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/di/fluent/FactoryBuilder.ts
@@ -0,0 +1,14 @@
+import { RegistrationBuilder } from "./RegistrationBuilder";
+
+export class FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<ReturnType<F>, S> {
+    $factory: F;
+
+    _params: any;
+
+    constructor(target: F, params: any) {
+        super();
+
+        this.$factory = target;
+        this._params = params;
+    }
+}
diff --git a/src/main/ts/di/fluent/RegistrationBuilder.ts b/src/main/ts/di/fluent/RegistrationBuilder.ts
--- a/src/main/ts/di/fluent/RegistrationBuilder.ts
+++ b/src/main/ts/di/fluent/RegistrationBuilder.ts
@@ -1,7 +1,7 @@
-import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor } from "./interfaces";
+import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor, ServiceRegistration } from "./interfaces";
 import { ActivationType } from "../interfaces";
 
-export class RegistrationBuilder<T, S extends object> {
+export class RegistrationBuilder<T, S extends object> implements ServiceRegistration {
     private _activationType: ActivationType = "call";
 
     private _overrides: { [m in keyof S]?: (...args: any) => void } | undefined;
@@ -31,7 +31,7 @@ export class RegistrationBuilder<T, S ex
         return this;
     }
 
-    visit(visitor: RegistrationVisitor<S>) {
+    visit(visitor: RegistrationVisitor) {
         
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/ts/di/fluent/ServiceRecordBuilder.ts b/src/main/ts/di/fluent/ServiceRecordBuilder.ts
new file mode 100644
diff --git a/src/main/ts/di/fluent/interfaces.ts b/src/main/ts/di/fluent/interfaces.ts
--- a/src/main/ts/di/fluent/interfaces.ts
+++ b/src/main/ts/di/fluent/interfaces.ts
@@ -37,7 +37,7 @@ export interface ServiceRecordBuilder<T,
     wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;
 }
 
-export interface RegistrationVisitor<S extends object> {
+export interface RegistrationVisitor {
     visitDependency(): void;
 
     visitObject(): void;
@@ -48,23 +48,8 @@ export interface RegistrationVisitor<S e
 
 }
 
-export interface RegistrationBuilder<T, S extends object> {
-    override<K extends keyof S>(name: K, builder: S[K], raw: true): this;
-    override<K extends keyof S>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void): this;
-    override<K extends keyof S, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): this;
-
-    activate(activation: ActivationType): this;
-    inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P): this;
-
-    visit(visitor: RegistrationVisitor<S>): void;
-}
-
-export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends RegistrationBuilder<InstanceType<C>, S> {
-    $type: C;
-}
-
-export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<ReturnType<F>, S> {
-    $factory: F;
+export interface ServiceRegistration {
+    visit(visitor: RegistrationVisitor): void;
 }
 
 export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
@@ -75,7 +60,7 @@ export interface ConfigBuilder<S extends
     apply(container: Container<S>): Promise<void>;
 }
 
-interface ServicesDeclaration<S extends object> {
+export interface ServicesDeclaration<S extends object> {
     build<T>(this: void): ServiceRecordBuilder<T, S>;
     annotate<T>(this: void): AnnotaionBuilder<T, S>;
 
@@ -84,5 +69,3 @@ interface ServicesDeclaration<S extends 
 
     configure(): ConfigBuilder<S>;
 }
-
-export declare function declare<S extends object>(): ServicesDeclaration<S>;
diff --git a/src/main/ts/di/interfaces.ts b/src/main/ts/di/interfaces.ts
--- a/src/main/ts/di/interfaces.ts
+++ b/src/main/ts/di/interfaces.ts
@@ -50,4 +50,4 @@ export interface ILifetime {
     enter(): void;
 
     store(item: any, cleanup?: (item: any) => void): void;
-}
\ No newline at end of file
+}
diff --git a/src/main/ts/di/traits.ts b/src/main/ts/di/traits.ts
--- a/src/main/ts/di/traits.ts
+++ b/src/main/ts/di/traits.ts
@@ -1,7 +1,50 @@
 import { isPrimitive } from "../safe";
 import { Descriptor } from "./interfaces";
+import { ServicesDeclaration, ServiceRecordBuilder, ServiceModule, RegistrationBuilder, ExtractDependency } from "./fluent/interfaces";
+import { AnnotaionBuilder } from "./Annotations";
+import { FactoryBuilder } from "./fluent/FactoryBuilder";
+import { ConstructorBuilder } from "./fluent/ConstructorBuiler";
 
 export function isDescriptor(x: any): x is Descriptor {
     return (!isPrimitive(x)) &&
         (x.activate instanceof Function);
-}
\ No newline at end of file
+}
+
+export function declare<S extends object>(): ServicesDeclaration<S> {
+    return {
+        annotate<T>() {
+            return new AnnotaionBuilder<T, S>();
+        },
+        build<T>(): ServiceRecordBuilder<T, S> {
+            return {
+                factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
+                    target: F,
+                    ...params: P
+                ): FactoryBuilder<F, S> {
+                    return new FactoryBuilder(target, params);
+                },
+
+                type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
+                    target: C, ...params: P
+                ): ConstructorBuilder<C, S> {
+                    return new ConstructorBuilder(target, params);
+                },
+
+                wired<M extends keyof any>(module: ServiceModule<T, S, M>, m?: M): RegistrationBuilder<T, S> {
+                    const service = m ?
+                        module[m] :
+                        (module as ServiceModule<T, S>).service;
+                    if (!service)
+                        throw new Error("The specified module doen's provides a service annotation");
+                    return service.getRegistrationBuilder();
+                }
+            };
+        },
+        configure() {
+            throw new Error();
+        },
+        dependency() {
+            throw new Error();
+        }
+    };
+}
diff --git a/src/main/ts/log/writers/ConsoleWriter.ts b/src/main/ts/log/writers/ConsoleWriter.ts
--- a/src/main/ts/log/writers/ConsoleWriter.ts
+++ b/src/main/ts/log/writers/ConsoleWriter.ts
@@ -1,1 +1,1 @@
-export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger";
\ No newline at end of file
+export { ConsoleLogger as ConsoleWriter } from "./ConsoleLogger";