# HG changeset patch
# User cin
# Date 2020-07-17 18:27:47
# Node ID 850cc60b6e2aaee96170ff36722812b8820abf08
# Parent  142c5f6dc2b5779d377d3686b409c07126fc8b7c

fluent configuration interfaces

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,24 +1,8 @@
-import { primitive } from "../safe";
-import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";
-
-export interface InjectOptions {
-    lazy?: boolean;
-}
-
-type Compatible<T1, T2> = T2 extends T1 ? any : never;
-
-type ExtractService<K, S> = K extends keyof S ? S[K] : K;
+import { TypeRegistration } from "./Configuration";
+import { ExtractDependency } from "./fluent/interfaces";
 
-type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
-    D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
-    D extends { $type: new (...args: any[]) => infer I } ? I :
-    WalkDependencies<D, S>;
-
-type WalkDependencies<D, S> = D extends primitive ? D :
-    { [K in keyof D]: ExtractDependency<D[K], S> };
-
-export class Builder<T, S extends object> {
-    declare<P extends any[]>(...args: P) {
+export class AnnotaionBuilder<T, S extends object> {
+    wire<P extends any[]>(...args: P) {
         return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
 
         };
@@ -28,7 +12,7 @@ export class Builder<T, S extends object
         return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
             target: X,
             memberName: M,
-            descriptor: TypedPropertyDescriptor<Compatible<(...args: ExtractDependency<P, S>) => any, T[M]>>
+            descriptor: TypedPropertyDescriptor< T[M] extends ((...args: ExtractDependency<P, S>) => any) ? any : never >
         ) => {
 
         };
@@ -39,24 +23,3 @@ export class Builder<T, S extends object
     }
 
 }
-
-export interface DependencyOptions<T> {
-    optional?: boolean;
-    default?: T;
-}
-
-export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
-    lazy: true;
-}
-
-interface Declaration<S extends object> {
-    define<T>(): Builder<T, S>;
-
-    dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;
-    dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
-
-    $type<T, P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(target: C, ...params: P): StrictTypeRegistration<C, S>;
-}
-
-
-export declare function declare<S extends object>(): Declaration<S>;
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
@@ -1,47 +1,68 @@
 import { primitive } from "../../safe";
 import { ActivationType } from "../interfaces";
-import { Builder } from "../Annotations";
+import { AnnotaionBuilder } from "../Annotations";
+import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
+import { PromiseOrValue } from "../../interfaces";
 
-type ExtractService<K, S> = K extends keyof S ? S[K] : K;
+export interface DependencyOptions<T> {
+    optional?: boolean;
+    default?: T;
+}
 
-type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
+export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
+    lazy: true;
+}
+
+export type ExtractService<K, S> = K extends keyof S ? S[K] : K;
+
+export type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
     D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
     D extends { $type: new (...args: any[]) => infer I } ? I :
     D extends { $factory: (...args: any[]) => infer R } ? R :
     WalkDependencies<D, S>;
 
-type WalkDependencies<D, S> = D extends primitive ? D :
+export type WalkDependencies<D, S> = D extends primitive ? D :
     { [K in keyof D]: ExtractDependency<D[K], S> };
 
-type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
-    [m in M]: Builder<T, S>;
+export type ServiceModule<T, S extends object, M extends keyof any = "service"> = {
+    [m in M]: AnnotaionBuilder<T, S>;
 };
 
-type PromiseOrValue<T> = T | PromiseLike<T>;
-
-export interface TypeBuilder<T, S extends object> {
+export interface ServiceBuilder<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>;
-    wire<M extends keyof any>(module: PromiseOrValue<ServiceModule<T, S, M>>, m: M): ServiceBuilder<T, S>;
-    wire(module: PromiseOrValue<ServiceModule<T, S>>): ServiceBuilder<T, 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>;
 }
 
-export interface ServiceBuilder<T, S extends object> {
-    override<K extends keyof S>(name: K, builder: S[K] | ((t: TypeBuilder<S[K], S>) => any)): this;
+export interface RegistrationBuilder<T, S extends object> {
+    override<K extends keyof S>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): 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;
 }
 
-export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends ServiceBuilder<InstanceType<C>, S> {
+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 ServiceBuilder<ReturnType<F>, S> {
+export interface FactoryBuilder<F extends (...args: any[]) => any, S extends object> extends RegistrationBuilder<ReturnType<F>, S> {
     $factory: F;
 }
 
 export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
-    register<K extends Y>(name: K, builder: S[K] | ((t: TypeBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
 }
+
+interface ServicesDeclaration<S extends object> {
+    build<T>(this: void): ServiceBuilder<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>;
+    dependency<K extends keyof S>(this: void, name: K, opts?: DependencyOptions<S[K]>): DependencyRegistration<S, K>;
+
+    configure(): ConfigBuilder<S>;
+}
+
+export declare function declare<S extends object>(): ServicesDeclaration<S>;
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
@@ -3,6 +3,8 @@ export interface Constructor<T = {}> {
     prototype: T;
 }
 
+export type PromiseOrValue<T> = T | PromiseLike<T>;
+
 export type Factory<T = {}> = (...args: any[]) => T;
 
 export type Predicate<T = any> = (x: T) => boolean;
diff --git a/src/test/ts/mock/Bar.ts b/src/test/ts/mock/Bar.ts
--- a/src/test/ts/mock/Bar.ts
+++ b/src/test/ts/mock/Bar.ts
@@ -1,9 +1,9 @@
 import { Foo } from "./Foo";
-import { define, dependency } from "./services";
+import { annotate, dependency } from "./services";
 
-export const service = define<Bar>();
+export const service = annotate<Bar>();
 
-@service.declare({
+@service.wire({
     foo: dependency("foo"),
     nested: {
         lazy: dependency("foo", { lazy: true })
@@ -11,7 +11,7 @@ export const service = define<Bar>();
     host: dependency("host")
 }, "")
 export class Bar {
-    barName = "bar";
+    barName = "Twister";
 
     _v: Foo | undefined;
 
diff --git a/src/test/ts/mock/Box.ts b/src/test/ts/mock/Box.ts
--- a/src/test/ts/mock/Box.ts
+++ b/src/test/ts/mock/Box.ts
@@ -1,16 +1,16 @@
 import { Bar } from "./Bar";
-import { define, dependency } from "./services";
+import { annotate, dependency } from "./services";
 
 // export service descriptor
 // через service передается информация о типе зависимости
 // даже если это шаблон.
-export const service = define<Box<Bar>>();
+export const service = annotate<Box<Bar>>();
 
-@service.declare(dependency("bar"))
+@service.wire()
 export class Box<T> {
     private _value: T | undefined;
 
-    constructor(value: T) {
+    constructor(value?: T) {
         this._value = value;
     }
 
@@ -20,10 +20,6 @@ export class Box<T> {
         return value;
     }
 
-    setObj(value: any) {
-
-    }
-
     getValue() {
         if (this._value === undefined)
             throw new Error("Trying to get a value from the empty box");
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,18 +1,14 @@
-import { configure, dependency, Services, $type } from "./services";
+import { configure, dependency, build } from "./services";
 import { Foo } from "./Foo";
 import { Bar } from "./Bar";
 import { Box } from "./Box";
-import { ConfigBuilder, TypeBuilder } from "../di/fluent/interfaces";
 
-export declare function build<T>(): TypeBuilder<T, Services>;
-
-export declare const config: ConfigBuilder<Services>;
-config
+export const config = configure()
     .register("bar", s => s
-        .wire(import("./Bar"), "service")
+        .wired(import("./Bar"), "service")
         .inject("setName", "heell")
     )
-    .register("box", s => s.wire(import("./Box")))
+    .register("box", s => s.wired(import("./Box")))
     .register("host", "example.com")
     // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
     .register("bar2", s => s.type(Bar,
diff --git a/src/test/ts/mock/services.ts b/src/test/ts/mock/services.ts
--- a/src/test/ts/mock/services.ts
+++ b/src/test/ts/mock/services.ts
@@ -1,7 +1,7 @@
 import { Foo } from "./Foo";
 import { Bar } from "./Bar";
 import { Box } from "./Box";
-import { declare } from "../di/Annotations";
+import { declare } from "../di/fluent/interfaces";
 
 /**
  * Сервисы доступные внутри контейнера
@@ -22,4 +22,4 @@ export interface Services {
 /**
  * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
  */
-export const { define, dependency } = declare<Services>();
+export const { dependency, build, annotate, configure } = declare<Services>();