implab/implabjs-core Commit - r144:f97a113c3209

Fixed container interfaces, separated ServiceContainer

cin -

r144:f97a113c3209 v1.4.0-rc4 default

parent child

Context file:

r144:f97a113c3209

Collapse all files

src/main/ts/di/ActivationContext.ts +3 -4

             import { TraceSource } from "../log/TraceSource";
             import { argumentNotEmptyString } from "../safe";
-            import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime } from "./interfaces";
+            import { Descriptor, ContainerServiceMap, ContainerKeys, TypeOfService, ILifetime, ServiceContainer } from "./interfaces";
-            import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
                 _service: Descriptor<S, any>;
-                _container: Container<S>;
+                _container: ServiceContainer<S>;
                 _parent: ActivationContext<S> | undefined;
                  * @param service the service to activate, this parameter is used for the
                  *  debug purpose.
                  */
-                constructor(container: Container<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
+                constructor(container: ServiceContainer<S>, services: ContainerServiceMap<S>, name: string, service: Descriptor<S, any>) {
                     this._name = name;
                     this._service = service;
                     this._visited = {};

src/main/ts/di/Configuration.ts +3 -4

                 ActivationType,
                 ContainerKeys,
                 TypeOfService,
-                ILifetime
+                ILifetime, ServiceContainer
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
-            import { Container } from "./Container";
             import { ReferenceDescriptor } from "./ReferenceDescriptor";
             import { TypeServiceDescriptor } from "./TypeServiceDescriptor";
             import { FactoryServiceDescriptor } from "./FactoryServiceDescriptor";
                 _hasInnerDescriptors = false;
-                readonly _container: Container<S>;
+                readonly _container: ServiceContainer<S>;
                 _path: Array<string>;
                 _require: ModuleResolver | undefined;
-                constructor(container: Container<S>) {
+                constructor(container: ServiceContainer<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];

src/main/ts/di/Container.ts +7 -6

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ServiceLocator, ContainerServiceMap, ContainerKeys, TypeOfService } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerServiceMap, ContainerKeys, TypeOfService, ServiceContainer } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration, RegistrationMap } from "./Configuration";
             import { Cancellation } from "../Cancellation";
-            import { IDestroyable, PromiseOrValue, ICancellation } from "../interfaces";
+            import { IDestroyable, ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LifetimeManager } from "./LifetimeManager";
             import { each, isString } from "../safe";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export class Container<S extends object = any> implements ServiceLocator<S>, IDestroyable {
+            export class Container<S extends object = any> implements ServiceContainer<S>, IDestroyable {
                 readonly _services: ContainerServiceMap<S>;
                 readonly _lifetimeManager: LifetimeManager;
                     return this;
                 }
+                /** @deprecated use getLifetimeManager() */
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     }
                 }
-                applyConfig<S2 extends object>(config: Promise<{ default: ContainerConfiguration<S2>; }>, ct?: ICancellation): Promise<Container<S & S2>>;
+                applyConfig<S2 extends object>(config: Promise<{ default: ContainerConfiguration<S2>; }>, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
-                applyConfig<S2 extends object, P extends string>(config: Promise<{ [p in P]: ContainerConfiguration<S2>; }>, prop: P, ct?: ICancellation): Promise<Container<S & S2>>;
+                applyConfig<S2 extends object, P extends string>(config: Promise<{ [p in P]: ContainerConfiguration<S2>; }>, prop: P, ct?: ICancellation): Promise<ServiceContainer<S & S2>>;
                 async applyConfig<S2 extends object, P extends string>(
                     config: Promise<{ [p in P | "default"]: ContainerConfiguration<S2>; }>,
                     propOrCt?: P | ICancellation,
                     ct?: ICancellation
-                ): Promise<Container<S & S2>> {
+                ): Promise<ServiceContainer<S & S2>> {
                     const mod = await config;
                     let _ct: ICancellation;

src/main/ts/di/LifetimeManager.ts +4 -5

             import { IDestroyable, MapOf } from "../interfaces";
-            import { argumentNotNull, isDestroyable, primitive, isNull, argumentNotEmptyString } from "../safe";
+            import { argumentNotNull, isDestroyable, argumentNotEmptyString } from "../safe";
-            import { ILifetime } from "./interfaces";
+            import { ILifetime, ServiceContainer } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
-            import { Container } from "./Container";
             function safeCall(item: () => void) {
                 try {
             let nextId = 0;
-            const singletons: { [k in keyof any]: any; } = {};
+            const singletons: any = {};
             export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
                     };
                 }
-                static containerLifetime(container: Container<any>) {
+                static containerLifetime(container: ServiceContainer<any>) {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {

src/main/ts/di/fluent/DescriptorBuilder.ts +3 -4

             import { Resolver, RegistrationBuilder } from "./interfaces";
-            import { Container } from "../Container";
+            import { Descriptor, ILifetime, ActivationType, PartialServiceMap, ServiceContainer } from "../interfaces";
-            import { Descriptor, ILifetime, ActivationType, PartialServiceMap } from "../interfaces";
             import { DescriptorImpl } from "./DescriptorImpl";
             import { LifetimeManager } from "../LifetimeManager";
             import { isString, each, isPrimitive, isPromise, oid } from "../../safe";
             export class DescriptorBuilder<S extends object, T> {
-                private readonly _container: Container<S>;
+                private readonly _container: ServiceContainer<S>;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: any) => void;
                 private _failed = false;
-                constructor(container: Container<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
+                constructor(container: ServiceContainer<S>, cb: (d: Descriptor<S, T>) => void, eb: (err: any) => void) {
                     this._container = container;
                     this._cb = cb;
                     this._eb = eb;

src/main/ts/di/fluent/FluentConfiguration.ts +5 -5

-            import { Container } from "../Container";
             import { argumentNotNull, each, isPrimitive, isPromise } from "../../safe";
             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { RegistrationBuilder, FluentRegistrations, ContainerConfiguration } from "./interfaces";
             import { Cancellation } from "../../Cancellation";
+            import { ServiceContainer } from "../interfaces";
             export class FluentConfiguration<S extends object, Y extends keyof S = keyof S> {
                     return this.register(config);
                 }
-                apply<SC extends object>(target: Container<SC>, ct = Cancellation.none) {
+                apply<S2 extends object>(target: ServiceContainer<S2>, ct = Cancellation.none) {
                     let pending = 1;
-                    const _t2 = target as unknown as Container<SC & S>;
+                    const _t2 = target as unknown as ServiceContainer<S2 & S>;
-                    return new Promise<Container<SC & S>>((resolve, reject) => {
+                    return new Promise<ServiceContainer<S2 & S>>((resolve, reject) => {
                         function guard(v: void | Promise<void>) {
                             if (isPromise(v))
                                 v.catch(reject);
                         }
                         each(this._builders, (v, k) => {
                             pending++;
-                            const d = new DescriptorBuilder<SC & S, any>(_t2,
+                            const d = new DescriptorBuilder<S2 & S, any>(_t2,
                                 result => {
                                     _t2.register(k, result);
                                     complete();

src/main/ts/di/fluent/interfaces.ts +2 -3

             import { primitive } from "../../safe";
-            import { TypeOfService, ContainerKeys, ActivationType, ILifetime } from "../interfaces";
+            import { TypeOfService, ContainerKeys, ActivationType, ILifetime, ServiceContainer } from "../interfaces";
             import { ICancellation } from "../../interfaces";
-            import { Container } from "../Container";
             export interface DependencyOptions {
                 optional?: boolean;
             }
             export interface ContainerConfiguration<S extends object> {
-                apply<S2 extends object>(target: Container<S2>, ct: ICancellation): Promise<Container<S2 & S>>;
+                apply<S2 extends object>(target: ServiceContainer<S2>, ct?: ICancellation): Promise<ServiceContainer<S2 & S>>;
             }
             export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>, ct?: ICancellation) => void | Promise<void>;

src/main/ts/di/interfaces.ts +9 0

             import { ActivationContext } from "./ActivationContext";
+            import { LifetimeManager } from "./LifetimeManager";
             export interface Descriptor<S extends object = any, T = any> {
                 activate(context: ActivationContext<S>): T;
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K>;
             }
+            export interface ServiceContainer<S extends object> extends ServiceLocator<S> {
+                getLifetimeManager(): LifetimeManager;
+                register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
+                register(services: PartialServiceMap<S>): this;
+                createChildContainer(): ServiceContainer<S>;
+            }
             export interface ContainerProvided<S extends object> {
                 container: ServiceLocator<S>;
             }

src/test/ts/mock/services.ts +4 0

@@ -20,3 +20,7 export interface ChildServices extends S
20		20
21	bar: Bar;	21	bar: Bar;
22	}	22	}
		23
		24	export interface FooServices {
		25	foo: Foo;
		26	}

src/test/ts/tests/FluentContainerTests.ts +12 -1

             import { Foo } from "../mock/Foo";
             import { Box } from "../mock/Box";
             import { delay } from "../safe";
-            import { Services } from "../mock/services";
+            import { FooServices, Services } from "../mock/services";
+            import { ContainerConfiguration } from "../di/fluent/interfaces";
             test("Simple fluent config", async t => {
                 const config = fluent<{ host: string; bar: Bar; foo: Foo }>()
                 t.assert(container.resolve("host"), "Should resolve simple value");
             });
+            test("Child container config", async t => {
+                const container = await new Container<{}>().applyConfig(import("../mock/config"));
+                const fooServices: ContainerConfiguration<FooServices> = (await import("../mock/config2")).default;
+                const child = await fooServices.apply(container.createChildContainer());
+                t.assert(child.resolve("foo"), "foo should be resolved");
+            });

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages