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");
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             let nextId = 1;
             /** This class is created once per `Container.resolve` method call and used to
              * cache dependencies and to track created instances. The activation context
              * tracks services with `context` activation type.
              */
             export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
                 _services: ContainerServiceMap<S>;
                 _visited: MapOf<any>;
                 _name: string;
                 _service: Descriptor<S, any>;
-                _container: Container<S>;
+                _container: ServiceContainer<S>;
                 _parent: ActivationContext<S> | undefined;
                 /** Creates a new activation context with the specified parameters.
                  * @param container the container which starts the activation process
                  * @param services the initial service registrations
                  * @param name the name of the service being activated, this parameter is
                  *  used for the debug purpose.
                  * @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 = {};
                     this._cache = {};
                     this._services = services;
                     this._container = container;
                 }
                 /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
                 /** Returns the container for which 'resolve' method was called */
                 getContainer() {
                     return this._container;
                 }
                 /** Resolves the specified dependency in the current context
                  * @param name The name of the dependency being resolved
                  */
                 resolve<K extends ContainerKeys<S>>(name: K): TypeOfService<S, K>;
                 /** Resolves the specified dependency with the specified default value if
                  * the dependency is missing.
                  *
                  * @param name The name of the dependency being resolved
                  * @param def A default value to return in case of the specified dependency
                  *   is missing.
                  */
                 resolve<K extends ContainerKeys<S>, T>(name: K, def: T): TypeOfService<S, K> | T;
                 /** Resolves the specified dependency and returns undefined in case if the
                  * dependency is missing.
                  *
                  * @param name The name of the dependency being resolved
                  */
                 resolve<K extends ContainerKeys<S>>(name: K, def: undefined): TypeOfService<S, K> | undefined;
                 resolve<K extends ContainerKeys<S>, T>(name: K, def?: T): TypeOfService<S, K> | T | undefined {
                     const d = this._services[name];
                     if (d !== undefined) {
                         return this.activate(d, name.toString());
                     } else {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service ${name} not found`);
                     }
                 }
                 /**
                  * registers services local to the the activation context
                  *
                  * @name{string} the name of the service
                  * @service{string} the service descriptor to register
                  */
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
                     this._services[name] = service as any;
                 }
                 createLifetime(): ILifetime {
                     const id = nextId++;
                     const me = this;
                     return {
                         initialize() {
                         },
                         has() {
                             return id in me._cache;
                         },
                         get() {
                             return me._cache[id];
                         },
                         store(item: any) {
                             me._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     if (trace.isLogEnabled())
                         trace.log(`enter ${name} ${d}`);
                     const ctx = this.enter(d, name);
                     const v = d.activate(ctx);
                     if (trace.isLogEnabled())
                         trace.log(`leave ${name}`);
                     return v;
                 }
                 visit(id: string) {
                     const count = this._visited[id] || 0;
                     this._visited[id] = count + 1;
                     return count;
                 }
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 private enter(service: Descriptor<S, any>, name: string): this {
                     const clone = Object.create(this);
                     clone._name = name;
                     clone._services = Object.create(this._services);
                     clone._parent = this;
                     clone._service = service;
                     return clone;
                 }
                 /** Creates a clone for the current context, used to protect it from modifications */
                 clone(): this {
                     const clone = Object.create(this);
                     clone._services = Object.create(this._services);
                     return clone;
                 }
             }

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

             import {
                 PartialServiceMap,
                 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";
             import { TraceSource } from "../log/TraceSource";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
             import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
             import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             import { LifetimeManager } from "./LifetimeManager";
             export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
                 services?: RegistrationMap<S>;
             }
             /**
              * Базовый интерфейс конфигурации сервисов
              */
             export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 params?: any;
                 /** Специальный идентификатор используется при активации singleton, если
                  * не указан для TypeRegistration вычисляется как oid($type)
                  */
                 typeId?: string;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<C extends new (...args: any[]) => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
                 params?: Registration<ConstructorParameters<C>, 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;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: TypeOfService<S, K>;
             }
             export interface LazyDependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends DependencyRegistration<S, K> {
                 lazy: true;
             }
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
                     TypeRegistration<new (...args: any[]) => T, S> |
                     FactoryRegistration<(...args: any[]) => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );
             export type RegistrationMap<S extends object> = {
                 [k in keyof S]?: Registration<S[k], S>;
             };
             const _activationTypes: { [k in ActivationType]: number; } = {
                 singleton: 1,
                 container: 2,
                 hierarchy: 3,
                 context: 4,
                 call: 5
             };
             export function isTypeRegistration(x: any): x is TypeRegistration<new () => any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<() => any, any> {
                 return (!isPrimitive(x)) && ("$factory" in x);
             }
             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export function isActivationType(x: string): x is ActivationType {
                 return typeof x === "string" && x in _activationTypes;
             }
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
             async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
             async function mapAll(data: any, map?: (v: any, k: any) => any): Promise<any> {
                 if (data instanceof Array) {
                     return Promise.all(map ? data.map(map) : data);
                 } else {
                     const keys = Object.keys(data);
                     const o: any = {};
                     await Promise.all(keys.map(async k => {
                         const v = map ? map(data[k], k) : data[k];
                         o[k] = isPromise(v) ? await v : v;
                     }));
                     return o;
                 }
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
             export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
-                readonly _container: Container<S>;
+                readonly _container: ServiceContainer<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
-                constructor(container: Container<S>) {
+                constructor(container: ServiceContainer<S>) {
                     argumentNotNull(container, "container");
                     this._container = container;
                     this._path = [];
                 }
                 async loadConfiguration(moduleName: string, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotEmptyString(moduleName, "moduleName");
                     trace.log(
                         "loadConfiguration moduleName={0}, contextRequire={1}",
                         moduleName,
                         contextRequire ? typeof (contextRequire) : "<nil>"
                     );
                     this._configName = moduleName;
                     const r = await makeResolver(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 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(_opts.baseModule, _opts.contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     e.configName = this._configName || "<inline>";
                     e.path = this._makePath();
                     return e;
                 }
                 _makePath() {
                     return this._path
                         .reduce(
                             (prev, cur) => typeof cur === "number" ?
                                 `${prev}[${cur}]` :
                                 `${prev}.${cur}`
                         )
                         .toString();
                 }
                 async _resolveType(moduleName: string, localName: string) {
                     trace.log("resolveType moduleName={0}, localName={1}", moduleName, localName);
                     try {
                         const m = await this._loadModule(moduleName);
                         if (localName) {
                             return get(localName, m);
                         } else {
                             if (m instanceof Function)
                                 return m;
                             if ("default" in m)
                                 return m.default;
                             return m;
                         }
                     } catch (e) {
                         trace.error("Failed to resolve type moduleName={0}, localName={1}", moduleName, localName);
                         throw e;
                     }
                 }
                 _loadModule(moduleName: string) {
                     trace.debug("loadModule {0}", moduleName);
                     if (!this._require)
                         throw new Error("Module loader isn't specified");
                     return this._require(moduleName);
                 }
                 async _visitRegistrations(data: RegistrationMap<S>, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
                 _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
                 _visit(data: any, name: string): Promise<any> {
                     if (isPrimitive(data))
                         return Promise.resolve(new ValueDescriptor(data));
                     if (isDescriptor(data))
                         return Promise.resolve(data);
                     if (isDependencyRegistration<S>(data)) {
                         return this._visitDependencyRegistration(data, name);
                     } else if (isValueRegistration(data)) {
                         return this._visitValueRegistration(data, name);
                     } else if (isTypeRegistration(data)) {
                         return this._visitTypeRegistration(data, name);
                     } else if (isFactoryRegistration(data)) {
                         return this._visitFactoryRegistration(data, name);
                     } else if (data instanceof Array) {
                         return this._visitArray(data, name);
                     }
                     return this._visitObject(data, name);
                 }
                 async _visitObject(data: any, name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     // TODO: handle inline descriptors properly
                     // const ex = {
                     //     activate(ctx) {
                     //         const value = ctx.activate(this.prop, "prop");
                     //         // some code
                     //     },
                     //     // will be turned to ReferenceDescriptor
                     //     prop: { $dependency: "depName" }
                     // };
                     this._leave();
                     return v;
                 }
                 async _visitArray(data: any[], name: string) {
                     if (data.constructor &&
                         data.constructor.prototype !== Array.prototype)
                         return new ValueDescriptor(data);
                     this._enter(name);
                     const v = await mapAll(data, delegate(this, "_visit"));
                     this._leave();
                     return v;
                 }
                 _makeServiceParams(data: ServiceRegistration<any, S>) {
                     const opts: any = {
                     };
                     if (data.services)
                         opts.services = this._visitRegistrations(data.services, "services");
                     if (data.inject) {
                         this._enter("inject");
                         opts.inject = mapAll(
                             data.inject instanceof Array ?
                                 data.inject :
                                 [data.inject],
                             delegate(this, "_visitObject")
                         );
                         this._leave();
                     }
                     if ("params" in data)
                         opts.params = data.params instanceof Array ?
                             this._visitArray(data.params, "params") :
                             this._visit(data.params, "params");
                     if (data.activation) {
                         opts.activation = this._getLifetimeManager(data.activation, data.typeId);
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
                     const options = {
                         name: data.$dependency,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
                     };
                     const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     argumentNotNull(data.$type, "data.$type");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     if (data.$type instanceof Function) {
                         opts.type = data.$type;
                     } else {
                         const [moduleName, typeName] = data.$type.split(":", 2);
                         opts.type = this._resolveType(moduleName, typeName).then(t => {
                             if (!(t instanceof Function))
                                 throw Error("$type (" + data.$type + ") is not a constructable");
                             return t;
                         });
                     }
                     const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration<() => any, S>, name: string) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 _getLifetimeManager(activation: ActivationType, typeId: string | undefined): ILifetime {
                     switch (activation) {
                         case "container":
                             return LifetimeManager.containerLifetime(this._container);
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":
                             return LifetimeManager.contextLifetime();
                         case "singleton":
                             if (typeId === undefined)
                                 throw Error("The singleton activation requires a typeId");
                             return LifetimeManager.singletonLifetime(typeId);
                         default:
                             return LifetimeManager.empty();
                     }
                 }
             }

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";
             import { ContainerConfiguration, FluentRegistrations } from "./fluent/interfaces";
             import { FluentConfiguration } from "./fluent/FluentConfiguration";
             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;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
                     this._lifetimeManager = new LifetimeManager();
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 getLifetimeManager() {
                     return this._lifetimeManager;
                 }
                 resolve<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>): TypeOfService<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService<K extends ContainerKeys<S>>(name: K, def?: TypeOfService<S, K>) {
                     return this.resolve(name, def);
                 }
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         each(data, (v, k) => this.register(k, v));
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
+                /** @deprecated use getLifetimeManager() */
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 destroy() {
                     return this.dispose();
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
                  *  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 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?: { contextRequire: any; baseModule?: string }, ct = Cancellation.none) {
                     const _opts = Object.create(opts || null);
                     if (typeof (config) === "string") {
                         _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 this._applyLegacyConfig(config, _opts, ct);
                     }
                 }
-                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;
                     let _prop: P | "default";
                     if (isString(propOrCt)) {
                         _prop = propOrCt;
                         _ct = ct || Cancellation.none;
                     } else {
                         _ct = propOrCt || Cancellation.none;
                         _prop = "default";
                     }
                     return mod[_prop].apply(this, _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;
                 }
                 createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
             }

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 {
                     item();
                 } catch {
                     // silence!
                 }
             }
             const emptyLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                 },
                 get() {
                     throw new Error("The specified item isn't registered with this lifetime manager");
                 },
                 store() {
                     // does nothing
                 }
             });
             const unknownLifetime: ILifetime = Object.freeze({
                 has() {
                     return false;
                 },
                 initialize() {
                     throw new Error("Can't call initialize on the unknown lifetime object");
                 },
                 get() {
                     throw new Error("The lifetime object isn't initialized");
                 },
                 store() {
                     throw new Error("Can't store a value in the unknown lifetime object");
                 }
             });
             let nextId = 0;
-            const singletons: { [k in keyof any]: any; } = {};
+            const singletons: any = {};
             export class LifetimeManager implements IDestroyable {
                 private _cleanup: (() => void)[] = [];
                 private _cache: MapOf<any> = {};
                 private _destroyed = false;
                 private _pending: MapOf<boolean> = {};
                 create(): ILifetime {
                     const self = this;
                     const id = ++nextId;
                     return {
                         has() {
                             return (id in self._cache);
                         },
                         get() {
                             const t = self._cache[id];
                             if (t === undefined)
                                 throw new Error(`The item with with the key ${id} isn't found`);
                             return t;
                         },
                         initialize() {
                             if (self._pending[id])
                                 throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
                             self._pending[id] = true;
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             argumentNotNull(id, "id");
                             argumentNotNull(item, "item");
                             if (this.has())
                                 throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
                             delete self._pending[id];
                             self._cache[id] = item;
                             if (self._destroyed)
                                 throw new Error("Lifetime manager is destroyed");
                             if (cleanup) {
                                 self._cleanup.push(() => cleanup(item));
                             } else if (isDestroyable(item)) {
                                 self._cleanup.push(() => item.destroy());
                             }
                         }
                     };
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         this._cleanup.forEach(safeCall);
                         this._cleanup.length = 0;
                     }
                 }
                 static empty(): ILifetime {
                     return emptyLifetime;
                 }
                 static hierarchyLifetime(): ILifetime {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference activation detected");
                             _lifetime = context.getContainer().getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any, cleanup?: (item: any) => void) {
                             return _lifetime.store(item, cleanup);
                         }
                     };
                 }
                 static contextLifetime(): ILifetime {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = context.createLifetime();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
                         }
                     };
                 }
                 static singletonLifetime(typeId: string): ILifetime {
                     argumentNotEmptyString(typeId, "typeId");
                     let pending = false;
                     return {
                         has() {
                             return typeId in singletons;
                         },
                         get() {
                             if (!this.has())
                                 throw new Error(`The instance ${typeId} doesn't exists`);
                             return singletons[typeId];
                         },
                         initialize() {
                             if (pending)
                                 throw new Error("Cyclic reference detected");
                             pending = true;
                         },
                         store(item: any) {
                             singletons[typeId] = item;
                             pending = false;
                         }
                     };
                 }
-                static containerLifetime(container: Container<any>) {
+                static containerLifetime(container: ServiceContainer<any>) {
                     let _lifetime = unknownLifetime;
                     return {
                         initialize(context: ActivationContext<any>) {
                             if (_lifetime !== unknownLifetime)
                                 throw new Error("Cyclic reference detected");
                             _lifetime = container.getLifetimeManager().create();
                         },
                         get() {
                             return _lifetime.get();
                         },
                         has() {
                             return _lifetime.has();
                         },
                         store(item: any) {
                             _lifetime.store(item);
                         }
                     };
                 }
             }

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 _lifetime = LifetimeManager.empty();
                 private _overrides?: PartialServiceMap<S>;
                 private _cleanup?: (item: T) => void;
                 private _factory?: (resolve: Resolver<S>) => T;
                 private _pending = 1;
                 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;
                 }
                 build<T2>(): DescriptorBuilder<S, T2> {
                     this._defer();
                     return new DescriptorBuilder<S, T2>(this._container, () => this._complete(), err => this._fail(err));
                 }
                 override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
                 override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
                 override<K extends keyof S>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, S[K]> }, builder?: RegistrationBuilder<S, S[K]>): this {
                     const overrides: PartialServiceMap<S> = this._overrides ?
                         this._overrides :
                         (this._overrides = {});
                     const guard = (v: void | Promise<void>) => {
                         if (isPromise(v))
                             v.catch(err => this._fail(err));
                     };
                     if (isPrimitive(nameOrServices)) {
                         if (builder) {
                             this._defer();
                             const d = new DescriptorBuilder<S, S[K]>(
                                 this._container,
                                 result => {
                                     overrides[nameOrServices] = result;
                                     this._complete();
                                 },
                                 err => this._fail(err)
                             );
                             try {
                                 guard(builder(d));
                             } catch (err) {
                                 this._fail(err);
                             }
                         }
                     } else {
                         each(nameOrServices, (v, k) => this.override(k, v));
                     }
                     return this;
                 }
                 lifetime(lifetime: "singleton", typeId: string): this;
                 lifetime(lifetime: ILifetime | Exclude<ActivationType, "singleton">): this;
                 lifetime(lifetime: ILifetime | ActivationType, typeId?: string): this {
                     if (isString(lifetime)) {
                         this._lifetime = this._resolveLifetime(lifetime, typeId);
                     } else {
                         this._lifetime = lifetime;
                     }
                     return this;
                 }
                 cleanup(cb: (item: T) => void): this {
                     this._cleanup = cb;
                     return this;
                 }
                 factory(f: (resolve: Resolver<S>) => T): void {
                     this._factory = f;
                     this._complete();
                 }
                 value(v: T): void {
                     this._cb({
                         activate() {
                             return v;
                         }
                     });
                 }
                 _resolveLifetime(activation: ActivationType, typeId?: string | object) {
                     switch (activation) {
                         case "container":
                             return LifetimeManager.containerLifetime(this._container);
                         case "hierarchy":
                             return LifetimeManager.hierarchyLifetime();
                         case "context":
                             return LifetimeManager.contextLifetime();
                         case "singleton":
                             if (!typeId)
                                 throw Error("The singleton activation requires a typeId");
                             const _oid = isString(typeId) ? typeId : oid(typeId);
                             return LifetimeManager.singletonLifetime(_oid);
                         default:
                             return LifetimeManager.empty();
                     }
                 }
                 _defer() {
                     this._pending++;
                 }
                 _complete() {
                     if (--this._pending === 0) {
                         if (!this._factory)
                             throw new Error("The factory must be specified");
                         this._cb(new DescriptorImpl<S, T>({
                             lifetime: this._lifetime,
                             factory: this._factory,
                             overrides: this._overrides,
                             cleanup: this._cleanup
                         }));
                     }
                 }
                 _fail(err: any) {
                     if (!this._failed) {
                         this._failed = true;
                         this._eb.call(undefined, err);
                     }
                 }
             }

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> {
                 _builders: { [k in keyof S]?: RegistrationBuilder<S, S[k]> } = {};
                 provided<K extends Y>(): FluentConfiguration<S, Exclude<Y, K>> {
                     return this;
                 }
                 register<K extends Y>(name: K, builder: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(config: FluentRegistrations<K, S>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(nameOrConfig: K | FluentRegistrations<K, S>, builder?: RegistrationBuilder<S, S[K]>): FluentConfiguration<S, Exclude<Y, K>> {
                     if (isPrimitive(nameOrConfig)) {
                         argumentNotNull(builder, "builder");
                         this._builders[nameOrConfig] = builder;
                     } else {
                         each(nameOrConfig, (v, k) => this.register(k, v));
                     }
                     return this;
                 }
                 configure(config: FluentRegistrations<Y, S>): ContainerConfiguration<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);
                         }
                         function complete() {
                             if (!--pending)
                                 resolve(_t2);
                         }
                         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();
                                 },
                                 reject
                             );
                             try {
                                 guard(v(d, ct));
                             } catch (e) {
                                 reject(e);
                             }
                         });
                         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;
                 default?: any;
             }
             export interface LazyDependencyOptions extends DependencyOptions {
                 lazy: true;
             }
             export type ExtractService<K, S> = K extends keyof S ? S[K] : never;
             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>;
             export type WalkDependencies<D, S> = D extends primitive ? D :
                 { [K in keyof D]: ExtractDependency<D[K], S> };
             export type InferReferenceType<S extends object, K extends ContainerKeys<S>, O> = O extends { default: infer X } ? (TypeOfService<S, K> | X) :
                 O extends { optional: true } ? (TypeOfService<S, K> | undefined) :
                 TypeOfService<S, K>;
             export interface Resolver<S extends object> {
                 <K extends ContainerKeys<S>, O extends LazyDependencyOptions>(this: void, name: K, opts: O): () => InferReferenceType<S, K, O>;
                 <K extends ContainerKeys<S>, O extends DependencyOptions>(this: void, name: K, opts?: O): InferReferenceType<S, K, O>;
             }
             export interface DescriptorBuilder<S extends object, T> {
                 factory(f: (resolve: Resolver<S>) => T): void;
                 build<T2>(): DescriptorBuilder<S, T2>;
                 override<K extends keyof S>(name: K, builder: RegistrationBuilder<S, S[K]>): this;
                 override<K extends keyof S>(services: { [name in K]: RegistrationBuilder<S, S[K]> }): this;
                 lifetime(lifetime: "singleton", typeId: any): this;
                 lifetime(lifetime: ILifetime | Exclude<ActivationType, "singleton">): this;
                 cleanup(cb: (item: T) => void): this;
                 value(v: T): void;
             }
             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>;
             export type FluentRegistrations<K extends keyof S, S extends object> = { [k in K]: RegistrationBuilder<S, S[k]> };

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;
             }
             export type ServiceMap<S extends object> = {
                 [k in keyof S]: Descriptor<S, S[k]>;
             };
             export type ContainerKeys<S extends object> = keyof S | keyof ContainerProvided<S>;
             export type TypeOfService<S extends object, K> =
                 K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
                 K extends keyof S ? S[K] : never;
             export type ContainerServiceMap<S extends object> = {
                 [K in ContainerKeys<S>]: Descriptor<S, TypeOfService<S, K>>;
             };
             export type PartialServiceMap<S extends object> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             export interface ServiceLocator<S extends object> {
                 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>;
             }
             export type ContainerRegistered<S extends object> = /*{
                 [K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
             };*/
                 Exclude<S, ContainerProvided<S>>;
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): any;
                 initialize(context: ActivationContext<any>): void;
                 store(item: any, cleanup?: (item: any) => void): void;
             }

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

             import { Foo } from "./Foo";
             import { Box } from "./Box";
             import { Bar } from "./Bar";
             /**
              * Сервисы доступные внутри контейнера
              */
             export interface Services {
                 foo: Foo;
                 box: Box<Foo>;
                 host: string;
             }
             export interface ChildServices extends Services {
                 foo2?: Foo;
                 bar: Bar;
             }
+            export interface FooServices {
+                foo: Foo;
+            }

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

             import { test } from "./TestTraits";
             import { fluent } from "../di/traits";
             import { Bar } from "../mock/Bar";
             import { Container } from "../di/Container";
             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 }>()
                     .register({
                         host: it => it.value("example.com"),
                         bar: it => it.factory(resolve => new Bar({ host: resolve("host") }, "s-bar")),
                         foo: it => import("../mock/Foo").then(m => it.lifetime("container").factory(() => new m.Foo()))
                     });
                 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");
                 t.equal(container.resolve("foo"), container.resolve("foo"), "The service should be activated once");
             });
             test("Nested async configuration", async t => {
                 const container = await new Container<{
                     foo: Foo;
                     box: Box<Foo>
                 }>().fluent({
                     foo: it => delay(0).then(() => it.factory(() => new Foo())),
                     box: it => it.lifetime("context").factory($dependency => new Box($dependency("foo")))
                 });
                 t.assert(container.resolve("box").getValue(), "The dependency should be set");
                 t.equals(container.resolve("box").getValue(), container.resolve("box").getValue(), "The service should be activated once")
             });
             test("Bad fluent config", async t => {
                 try {
                     await new Container<{
                         foo: Foo;
                         box: Box<Foo>
                     }>().fluent({
                         foo: it => delay(0).then(() => it.factory(() => new Foo())),
                         box: it => it.lifetime("context")
                             .override("foo", () => { throw new Error("bad override"); })
                             .factory($dependency => new Box($dependency("foo")))
                     });
                     t.fail("Should throw");
                 } catch (e) {
                     t.pass("The configuration should fail");
                     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");
             });
             test("Container applyConfig", async t => {
                 const container = await new Container<{}>().applyConfig(import("../mock/config"));
                 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