# HG changeset patch
# User cin
# Date 2020-07-13 08:19:54
# Node ID b58fedd83580d676d633eee730f296081e3bd064
# Parent  264497557e7950f1ef543a0ac7c4a7802242e9f0

working on container configuration dsl

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,27 +1,17 @@
 import { primitive } from "../safe";
-import { TypeRegistration } from "./Configuration";
+import { TypeRegistration, DependencyRegistration, LazyDependencyRegistration, Registration, StrictTypeRegistration } from "./Configuration";
 
 export interface InjectOptions {
     lazy?: boolean;
 }
 
-export interface Dependency<K extends keyof any> {
-    $dependency: K;
-
-    lazy?: boolean;
-
-}
-
-export interface Lazy<K extends keyof any> extends Dependency<K> {
-    lazy: true;
-}
-
 type Compatible<T1, T2> = T2 extends T1 ? any : never;
 
 type ExtractService<K, S> = K extends keyof S ? S[K] : K;
 
 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 :
@@ -62,8 +52,10 @@ export interface LazyDependencyOptions<T
 interface Declaration<S extends object> {
     define<T>(): Builder<T, S>;
 
-    dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): Lazy<K>;
-    dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): Dependency<K>;
+    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<P extends any[], C extends new (...args: ExtractDependency<P, S>) => any>(target: C, ...params: P): StrictTypeRegistration<C, S>;
 
     configure(): Config<S>;
 }
@@ -76,9 +68,12 @@ type PromiseOrValue<T> = PromiseLike<T> 
 
 
 export interface Config<S extends object, Y extends keyof S = keyof S> {
-    register<K extends Y>(name: K, m: { $from: Promise<ServiceModule<S[K], S>> } | S[K]): Config<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, m: { $from: Promise<ServiceModule<S[K], S>> }): Config<S, Exclude<Y, K>>;
     register<K extends Y, M extends string>(name: K, m: { $from: Promise<ServiceModule<S[K], S, M>>, service: M }): Config<S, Exclude<Y, K>>;
-    register<K extends Y, C extends new (...args: any) => S[K]>(name: K, d: TypeRegistration<C, S>): Config<S, Exclude<Y, K>>;
+
+    register<K extends Y>(name: K, m: Registration<S[K], S>): Config<S, Exclude<Y, K>>;
+    registerType<K extends Y, P extends any[]>(
+        name: K, $type: new (...args: ExtractDependency<P, S>) => S[K], ...params: P): Config<S, Exclude<Y, K>>;
 }
 
 export declare function declare<S extends object>(): Declaration<S>;
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
@@ -44,12 +44,17 @@ export interface ServiceRegistration<T, 
     cleanup?: ((instance: T) => void) | string;
 }
 
-export interface TypeRegistration<C extends new () => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
     $type: string | C;
-    params?: ConstructorParameters<C>;
+    params?: Registration<ConstructorParameters<C>, S>;
 }
 
-export interface FactoryRegistration<F extends () => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
+export interface StrictTypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
+    $type: C;
+    params?: Registration<ConstructorParameters<C>, S>;
+}
+
+export interface FactoryRegistration<F extends (...args: any[]) => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
     $factory: string | F;
 }
 
@@ -69,12 +74,14 @@ 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 |
         { [k in keyof T]: Registration<T[k], S> } |
-        TypeRegistration<new () => T, S> |
-        FactoryRegistration<() => T, S> |
+        TypeRegistration<new (...args: any[]) => T, S> |
+        FactoryRegistration<(...args: any[]) => T, S> |
         ValueRegistration<any> |
         DependencyRegistration<S, keyof S>
     );
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
@@ -8,20 +8,20 @@ export const service = define<Bar>();
     nested: {
         lazy: dependency("foo", { lazy: true })
     },
-    host: "value"
-})
+    host: dependency("host")
+}, "")
 export class Bar {
     barName = "bar";
 
     _v: Foo | undefined;
 
-    constructor(_opts?: {
+    constructor(_opts: {
         foo?: Foo;
         nested?: {
             lazy: () => Foo
         },
         host: string
-    }) {
+    }, s: string) {
 
         if (_opts && _opts.foo)
             this._v = _opts.foo;
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,15 +1,23 @@
-import { configure } from "./services";
+import { configure, dependency, Services, $type } from "./services";
 import { Foo } from "./Foo";
 import { Bar } from "./Bar";
+import { Box } from "./Box";
+
 
 export const config = configure()
     .register("bar", { $from: import("./Bar"), service: "service" })
-    .register("box", { $from: import("./Box") })
+    // .register("box", { $from: import("./Box") })
     .register("host", "example.com")
-    .register("foo", {
-        $type: Foo
-    })
-    .register("bar2", {
-        $type: Bar,
-        params: []
-    });
+    // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
+    .register("bar2", $type(Bar,
+        {
+            foo: $type(Foo)
+                .override("host", "foo.example.com")
+                .inject("setName", dependency("host"))
+                .activate("context"),
+            host: ""
+        },
+        "")
+    )
+    .registerType("box", Box, dependency("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
@@ -22,4 +22,4 @@ export interface Services {
 /**
  * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
  */
-export const { define, dependency, configure } = declare<Services>();
+export const { define, dependency, configure, $type } = declare<Services>();