# HG changeset patch
# User cin
# Date 2020-09-08 11:31:55
# Node ID 17c7de5d346c0a5be1fc9dfcea918c25a2b46b89
# Parent  03e32ec7c20bff5e5d5643bd23827167f906dda5

tests

diff --git a/.project b/.project
--- a/.project
+++ b/.project
@@ -14,4 +14,15 @@
 	<natures>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1599549685358</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>
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
@@ -185,10 +185,11 @@ export class Configuration<S extends obj
         );
     }
 
-    async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
+    async applyConfiguration(data: RegistrationMap<S>, opts: { contextRequire?: any; baseModule?: string }, ct = Cancellation.none) {
         argumentNotNull(data, "data");
+        const _opts = opts || {};
 
-        await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
+        await this._applyConfiguration(data, await makeResolver(_opts.baseModule, _opts.contextRequire), ct);
     }
 
     async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
diff --git a/src/main/ts/di/Container.ts b/src/main/ts/di/Container.ts
--- a/src/main/ts/di/Container.ts
+++ b/src/main/ts/di/Container.ts
@@ -110,24 +110,34 @@ export class Container<S extends object 
 
     /**
      * @param{String|Object} config
-     *  The configuration of the contaier. Can be either a string or an object,
+     *  The configuration of the container. Can be either a string or an object,
      *  if the configuration is an object it's treated as a collection of
-     *  services which will be registed in the contaier.
+     *  services which will be registered in the container.
      *
      * @param{Function} opts.contextRequire
      *  The function which will be used to load a configuration or types for services.
      *
      */
-    async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
-        const c = new Configuration<S>(this);
+    async configure(config: string | RegistrationMap<S>, opts?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
+        const _opts = Object.create(opts || null);
 
         if (typeof (config) === "string") {
-            return c.loadConfiguration(config, opts && opts.contextRequire, ct);
+            _opts.baseModule = config;
+
+            const module = await import(config);
+            if (module && module.default && typeof (module.default.apply) === "function")
+                return module.default.apply(this);
+            else
+                return this._applyLegacyConfig(module, _opts, ct);
         } else {
-            return c.applyConfiguration(config, opts && opts.contextRequire, ct);
+            return this._applyLegacyConfig(config, _opts, ct);
         }
     }
 
+    async _applyLegacyConfig(config: RegistrationMap<S>, opts: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
+        return new Configuration<S>(this).applyConfiguration(config, opts);
+    }
+
     async fluent<K extends keyof S>(config: FluentRegistrations<K, S>, ct = Cancellation.none): Promise<this> {
         await new FluentConfiguration<S>().register(config).apply(this, ct);
         return this;
diff --git a/src/main/ts/di/fluent/FluentConfiguration.ts b/src/main/ts/di/fluent/FluentConfiguration.ts
--- a/src/main/ts/di/fluent/FluentConfiguration.ts
+++ b/src/main/ts/di/fluent/FluentConfiguration.ts
@@ -21,11 +21,13 @@ export class FluentConfiguration<S exten
         return this;
     }
 
-    apply(target: Container<S>, ct = Cancellation.none) {
+    apply<SC extends object>(target: Container<SC>, ct = Cancellation.none) {
 
         let pending = 1;
 
-        return new Promise((resolve, reject) => {
+        const _t2 = target as unknown as Container<SC & S>;
+
+        return new Promise<Container<SC & S>>((resolve, reject) => {
             function guard(v: void | Promise<void>) {
                 if (isPromise(v))
                     v.catch(reject);
@@ -33,13 +35,13 @@ export class FluentConfiguration<S exten
 
             function complete() {
                 if (!--pending)
-                    resolve();
+                    resolve(_t2);
             }
             each(this._builders, (v, k) => {
                 pending++;
-                const d = new DescriptorBuilder<S, any>(target,
+                const d = new DescriptorBuilder<SC & S, any>(_t2,
                     result => {
-                        target.register(k, result);
+                        _t2.register(k, result);
                         complete();
                     },
                     reject
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,26 +1,14 @@
 import { Services } from "./services";
 import { fluent } from "../di/traits";
+import { Box } from "./Box";
 
 export default fluent<Services>().register({
     host: it => it.value("example.com"),
 
-    bar2: it => Promise.all([import("./Foo"), import("./Bar")])
-        .then(([{ Foo }, { Bar }]) => it
-            .lifetime("container")
-            .override({
-                host: it2 => it2.value("simple.org"),
-                foo: it2 => it2.value(new Foo())
-            })
-            .factory(resolve => {
-                const bar = new Bar({
-                    foo: new Foo(),
-                    nested: {
-                        lazy: resolve("foo", { lazy: true })
-                    },
-                    host: resolve("host")
-                }, "some text");
-                bar.setName(resolve("host"));
-                return bar;
-            })
-        )
+    foo: it => import("./Foo").then(({ Foo }) => it
+        .factory(() => new Foo())
+    ),
+
+    box: it => it
+        .factory($dependency => new Box($dependency("foo")))
 });
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
@@ -8,11 +8,7 @@ import { Box } from "./Box";
 export interface Services {
     foo: Foo;
 
-    bar: Bar;
-
-    bar2: Bar;
-
-    box: Box<Bar>;
+    box: Box<Foo>;
 
     host: string;
 
diff --git a/src/test/ts/tests/FluentContainerTests.ts b/src/test/ts/tests/FluentContainerTests.ts
--- a/src/test/ts/tests/FluentContainerTests.ts
+++ b/src/test/ts/tests/FluentContainerTests.ts
@@ -5,6 +5,7 @@ import { Container } from "../di/Contain
 import { Foo } from "../mock/Foo";
 import { Box } from "../mock/Box";
 import { delay } from "../safe";
+import { Services } from "../mock/services";
 
 test("Simple fluent config", async t => {
     const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
@@ -14,8 +15,8 @@ test("Simple fluent config", async t => 
             foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
         });
 
-    const container = new Container<{ host: string; bar: Bar; foo: Foo; }>();
-    await config.apply(container);
+    const c1 = new Container<{}>();
+    const container = await config.apply(c1);
 
     t.equal(container.resolve("host"), "example.com", "The value should be resolved");
     t.assert(container.resolve("bar"), "The service should de activated");
@@ -52,3 +53,11 @@ test("Bad fluent config", async t => {
         t.equal(e.message, "bad override", "the error should pass");
     }
 });
+
+test("Load fluent config", async t => {
+    const container = new Container<Services>();
+
+    await container.configure("../mock/config", { contextRequire: require });
+
+    t.assert(container.resolve("host"), "Should resolve simple value");
+});
diff --git a/src/testCjs/ts/tests/plan.ts b/src/testCjs/ts/tests/plan.ts
--- a/src/testCjs/ts/tests/plan.ts
+++ b/src/testCjs/ts/tests/plan.ts
@@ -5,3 +5,4 @@ import "./ObservableTests";
 import "./ContainerTests";
 import "./SafeTests";
 import "./TextTests";
+import "./FluentContainerTests";