# HG changeset patch
# User cin
# Date 2020-07-20 16:11:08
# Node ID 882b53b2ba5b335e4d82e7fd4ced4eeccf35b005
# Parent  850cc60b6e2aaee96170ff36722812b8820abf08

working on fluent configuration

diff --git a/src/main/ts/di/fluent/RegistrationBuilder.ts b/src/main/ts/di/fluent/RegistrationBuilder.ts
new file mode 100644
--- /dev/null
+++ b/src/main/ts/di/fluent/RegistrationBuilder.ts
@@ -0,0 +1,37 @@
+import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor } from "./interfaces";
+import { ActivationType } from "../interfaces";
+
+export class RegistrationBuilder<T, S extends object> {
+    private _activationType: ActivationType = "call";
+
+    private _overrides: { [m in keyof S]?: (...args: any) => void } | undefined;
+
+
+    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;
+    override<K extends keyof S>(name: K, builder: S[K] | ((t: ServiceRecordBuilder<S[K], S>) => void), raw: boolean = false) {
+        if (!this._overrides)
+            this._overrides = {};
+        if (raw) {
+            
+        } else if (builder instanceof Function) {
+            
+        } else {
+
+        }
+        return this;
+    }
+
+    activate(activation: ActivationType) {
+        this._activationType = activation;
+        return this;
+    }
+    inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P) {
+        return this;
+    }
+
+    visit(visitor: RegistrationVisitor<S>) {
+        
+    }
+}
\ No newline at end of file
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
@@ -2,7 +2,7 @@ import { primitive } from "../../safe";
 import { ActivationType } from "../interfaces";
 import { AnnotaionBuilder } from "../Annotations";
 import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
-import { PromiseOrValue } from "../../interfaces";
+import { Container } from "../Container";
 
 export interface DependencyOptions<T> {
     optional?: boolean;
@@ -28,19 +28,37 @@ export type ServiceModule<T, S extends o
     [m in M]: AnnotaionBuilder<T, S>;
 };
 
-export interface ServiceBuilder<T, S extends object> {
+export interface ServiceRecordBuilder<T, S extends object> {
     type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
         target: C, ...params: P): ConstructorBuilder<C, S>;
     factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
         target: F, ...params: P): FactoryBuilder<F, S>;
-    wired<M extends keyof any>(module: PromiseOrValue<ServiceModule<T, S, M>>, m: M): RegistrationBuilder<T, S>;
-    wired(module: PromiseOrValue<ServiceModule<T, S>>): RegistrationBuilder<T, S>;
+    wired<M extends keyof any>(module: ServiceModule<T, S, M>, m: M): RegistrationBuilder<T, S>;
+    wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;
+}
+
+export interface RegistrationVisitor<S extends object> {
+    visitDependency(): void;
+
+    visitObject(): void;
+
+    visitTypeRegistration(): void;
+
+    visitFactoryRegistration(): void;
+
+    visitBuilder<T>(builder: (t: ServiceRecordBuilder<T, S>) => void): void;
+
 }
 
 export interface RegistrationBuilder<T, S extends object> {
-    override<K extends keyof S>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): this;
+    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> {
@@ -52,11 +70,15 @@ export interface FactoryBuilder<F extend
 }
 
 export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
-    register<K extends Y>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
+    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>>;
+
+    apply(container: Container<S>): Promise<void>;
 }
 
 interface ServicesDeclaration<S extends object> {
-    build<T>(this: void): ServiceBuilder<T, S>;
+    build<T>(this: void): ServiceRecordBuilder<T, S>;
     annotate<T>(this: void): AnnotaionBuilder<T, S>;
 
     dependency<K extends keyof S>(this: void, name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
diff --git a/src/test/ts/mock/config.ts b/src/test/ts/mock/config.ts
--- a/src/test/ts/mock/config.ts
+++ b/src/test/ts/mock/config.ts
@@ -1,28 +1,17 @@
 import { configure, dependency, build } from "./services";
-import { Foo } from "./Foo";
-import { Bar } from "./Bar";
-import { Box } from "./Box";
 
 export const config = configure()
-    .register("bar", s => s
-        .wired(import("./Bar"), "service")
-        .inject("setName", "heell")
-    )
-    .register("box", s => s.wired(import("./Box")))
+    .register("bar", async s => s.wired(await import("./Bar"), "service"))
+    .register("box", s => import("./Box").then(m => s.wired(m)))
     .register("host", "example.com")
     // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
-    .register("bar2", s => s.type(Bar,
+    .register("bar2", async s => s.type((await import("./Bar")).Bar,
         {
-            foo: build().type(Foo)
+            foo: build().type((await import("./Foo")).Foo)
                 .activate("context"),
-            nested: { lazy: dependency("foo", {lazy: true}) },
+            nested: { lazy: dependency("foo", { lazy: true }) },
             host: dependency("host")
         },
         "")
         .inject("setName", dependency("host"))
-    )
-    .register("box", s => s
-        .type(Box, dependency("bar"))
-        .activate("context")
     );
-