implab/implabjs-di Commit - r13:dc3d64c43573

WIP service descriptors

cin -

r13:dc3d64c43573 default

parent child

Context file:

r13:dc3d64c43573

Collapse all files

src/main/ts/ActivationContext.ts +3 -7

             import { ActivationError } from "./ActivationError";
             import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";
             import { argumentNotNull, prototype } from "./traits";
             export interface ActivationContextInfo {
                 name: string;
                 service: string;
             }
             let nextId = 1;
             /** This object 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.
              *
              * @template S The service map used in the activation context, services from
              *   this map are available to resolution.
              * @template U A set of keys from the service map which can be overridden in
              *   this activation context.
              */
             export class ActivationContext<S> implements IActivationContext<S> {
                 private readonly _cache: Record<string, unknown>;
                 private readonly _services: DescriptorMap<S>;
                 private readonly _name: string;
                 private readonly _service: Descriptor<S, unknown>;
-                private readonly _containerLifetimeManager: ILifetimeManager;
+                private readonly _lifetimeManagers: ILifetimeManager[];
                 private readonly _parent: ActivationContext<S> | undefined;
                 /** Creates a new activation context with the specified parameters.
                  * @param containerLifetimeManager 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(containerLifetimeManager: ILifetimeManager, services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+                constructor(lifetimeManagers: ILifetimeManager[], services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
                     this._name = name;
                     this._service = service;
                     this._cache = cache;
                     this._services = services;
-                    this._containerLifetimeManager = containerLifetimeManager;
+                    this._lifetimeManagers = lifetimeManagers;
                 }
                 /** the name of the current resolving dependency */
                 getName() {
                     return this._name;
                 }
-                createContainerLifetime<T>() {
-                    return this._containerLifetimeManager.create<T>();
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
                 resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<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 ${String(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: DescriptorMap<S>[K]) {
                     argumentNotNull(name, "name");
                     const d = this._services[name];
                     if (d !== undefined && !d.configurable)
                         throw new Error(`Service ${String(name)} can't be overridden`);
                     this._services[name] = service;
                 }
                 createLifetime<T>(): ILifetime<T> {
                     const id = nextId++;
                     return {
                         initialize() { },
                         has: () => id in this._cache,
                         get: () => {
                             const v = this._cache[id] as T;
                             if (v === undefined || v === null)
                                 throw new Error("The value isn't present in the activation context");
                             return v;
                         },
                         store: item => {
                             this._cache[id] = item;
                         }
                     };
                 }
                 activate<T>(d: Descriptor<S, T>, name: string) {
                     // TODO: add logging
                     // if (trace.isLogEnabled())
                     //    trace.log("enter {0} {1}", name, d);
                     const ctx = new ActivationContext(
                         this._containerLifetimeManager,
                         d.hasOverrides ? prototype(this._services) : this._services,
                         name,
                         d,
                         this._cache
                     );
                     const v = d.activate(ctx);
                     // if (trace.isLogEnabled())
                     //    trace.log(`leave ${name}`);
                     return v;
                 }
                 getStack(): ActivationContextInfo[] {
                     const stack = [{
                         name: this._name,
                         service: this._service.toString()
                     }];
                     return this._parent ?
                         stack.concat(this._parent.getStack()) :
                         stack;
                 }
                 fail(innerException: unknown): never {
                     throw new ActivationError(this._name, this.getStack(), innerException);
                 }
             }

src/main/ts/Container.ts +6 -16

             import { ActivationContext } from "./ActivationContext";
             import { ActivationError } from "./ActivationError";
             import { ContainerBuilder } from "./ContainerBuilder";
+            import { LifetimeManager } from "./LifetimeManager";
             import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
             export class Container<S> implements ServiceLocator<S>, IDestroyable {
                 private readonly _services: DescriptorMap<S>;
-                private readonly _lifetimeManager: ILifetimeManager;
+                private readonly _lifetimeManagers: ILifetimeManager[];
                 private _disposed: boolean;
                 private readonly _onDestroyed: () => void;
-                constructor(services: DescriptorMap<S>, lifetimeManager: ILifetimeManager, destroyed: () => void) {
+                constructor(services: DescriptorMap<S>, lifetimeManagers: ILifetimeManager[], destroyed: () => void) {
-                    this._services = {
+                    this._services = services;
-                        ...services,
-                        container: {
-                            configurable: false,
-                            activate: () => this
-                        },
-                        childContainer: {
-                            configurable: false,
-                            activate: () => this.createChildBuilder(),
-                    };
                     this._disposed = false;
-                    this._lifetimeManager = lifetimeManager;
+                    this._lifetimeManagers = lifetimeManagers.concat(new LifetimeManager());
                     this._onDestroyed = destroyed;
                 }
                 private _assertNotDestroyed() {
                     if (this._disposed)
                         throw new Error("The container is destroyed");
                 }
                 createChildBuilder(): IContainerBuilder<S, keyof S> {
                     this._assertNotDestroyed();
                     const lifetime = this._lifetimeManager.create<IDestroyable>();
                     return new ContainerBuilder(this._services, lifetime);
                 }
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
                 resolve<K extends keyof S, T>(name: K, def?: T) {
                     this._assertNotDestroyed();
                     const d = this._services[name];
                     if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error(`Service '${String(name)}' isn't found`);
                     } else {
-                        const context = new ActivationContext(this._lifetimeManager, this._services, String(name), d);
+                        const context = new ActivationContext(this._lifetimeManagers, this._services, String(name), d);
                         try {
                             return d.activate(context);
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 destroy() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     this._lifetimeManager.destroy();
                     (0,this._onDestroyed)();
                 }
             }

src/main/ts/ContainerBuilder.ts +9 -4

             import { Container } from "./Container";
             import { DescriptorBuilder } from "./DescriptorBuilder";
-            import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
+            import { containerSelfDescriptor } from "./DescriptorImpl";
+            import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable, ContainerServices, ContainerServicesConstraint } from "./interfaces";
             import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
             import { isDestroyable, prototype } from "./traits";
             /**
              * Container builder used to prepare service descriptors and create a IoC container
              */
-            export class ContainerBuilder<S, U extends keyof S> implements
+            export class ContainerBuilder<S extends ContainerServicesConstraint<S>, U extends keyof S> implements
                 IContainerBuilder<S, U> {
                 private _pending = 1;
-                private readonly _services: DescriptorMap<S>;
+                private readonly _services: DescriptorMap<ContainerServices<S>>;
                 private readonly _lifetimeManager = new LifetimeManager();
                 private readonly _lifetime: ILifetime<IDestroyable>;
                 constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
-                    this._services = prototype(parentServices);
+                    this._services = {
+                        ...parentServices,
+                        container: containerSelfDescriptor as any,
+                        childContainer: containerSelfDescriptor as any
+                    };
                     this._lifetimeManager = new LifetimeManager();
                     this._lifetime = lifetime ?? emptyLifetime();
                 }
                 createServiceBuilder<K extends U>(name: K):
                     IDescriptorBuilder<S, S[K], Record<never, never>, U> {
                     return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
                 }
                 build(): ServiceLocator<S> {
                     this._assertBuilding();
                     if (!this._complete())
                         throw new Error("The configuration didn't complete.");
                     const {remove, store} = this._lifetime(null);
                     const container = new Container(this._services, this._lifetimeManager, remove);
                     store(container);
                     return container;
                 }
                 private readonly _register = <K extends U>(name: K) =>
                     (descriptor: Descriptor<S, S[K]>) => {
                         this._complete();
                         this._services[name] = descriptor;
                     };
                 private readonly _fail = (ex: unknown) => {
                     throw ex;
                 };
                 private _assertBuilding() {
                     if (!this._pending)
                         throw new Error("The descriptor builder is finalized");
                 }
                 private _complete() {
                     return !(--this._pending);
                 }
             }

src/main/ts/DescriptorImpl.ts +7 0

             import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
             import { each, key } from "./traits";
             export interface DescriptorImplArgs<S, T> {
                 lifetime: ILifetime<T>;
                 factory: (refs: Record<key, unknown>) => NonNullable<T>;
                 cleanup?: (item: NonNullable<T>) => void;
                 overrides?: DescriptorMap<S>;
                 dependencies?: DepsMap<S>;
             }
+            export const containerSelfDescriptor = <S>() => Object.freeze({
+                level: 0,
+                activate(context: IActivationContext<S>) {
+                    return context.createChildContainer();
+                }
+            });
             export class DescriptorImpl<S, T> implements Descriptor<S, T> {
                 private readonly _overrides?: DescriptorMap<S>;
                 private readonly _lifetime: ILifetime<T>;
                 private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
                 private readonly _cleanup?: (item: NonNullable<T>) => void;
                 private readonly _deps?: DepsMap<S>;
                 readonly hasOverrides: boolean;
                 constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
                     this._lifetime = lifetime;
                     this._factory = factory;
                     if (cleanup)
                         this._cleanup = cleanup;
                     if (overrides)
                         this._overrides = overrides;
                     if (dependencies)
                         this._deps = dependencies;
                     this.hasOverrides = !!overrides;
                 }
                 activate(context: IActivationContext<S>): NonNullable<T> {
                     const { has, get, initialize, store } = this._lifetime(context);
                     if (has())
                         return get();
                     initialize();
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
                     const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K] | null; }) => {
                         if (lazy) {
                             return "default" in opts ?
                                 () => context.resolve(name, opts.default) :
                                 () => context.resolve(name);
                         } else {
                             return "default" in opts ?
                                 context.resolve(name, opts.default) :
                                 context.resolve(name);
                         }
                     };
                     const deps = this._deps;
                     const refs = deps ?
                         Object.keys(deps)
                             .map(k => {
                                 const ref = deps[k];
                                 return typeof ref !== "object" ?
                                     { [k]: resolve({ name: ref }) } :
                                     { [k]: resolve(ref) };
                             })
                             .reduce((a, p) => ({ ...a, ...p }), {}) :
                         {};
                     try {
                         // call the factory method
                         const instance = (0,this._factory)(refs);
                         // store the instance
                         store(instance, this._cleanup);
                         return instance;
                     } catch(err) {
                         context.fail(err);
                     }
                 }
                 toString() {
                     return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
                 }
             }

src/main/ts/LifetimeManager.ts +8 -4

             import { IDestroyable, ILifetimeContext, ILifetimeManager, ILifetimeSlot } from "./interfaces";
             import { argumentNotNull, isDestroyable } from "./traits";
             const safeCall = (item: () => void) => {
                 try {
                     item();
                 } catch {
                     // silence!
                 }
             };
             const noop = () => { };
             const fail = (message: string) => (): never => {
                 throw new Error(message);
             };
             const _emptySlot = Object.freeze({
                 has: () => false,
                 initialize: noop,
                 get: fail("The specified item isn't registered with a lifetime manager"),
                 store: noop,
                 remove: noop,
                 cleanup: noop,
             });
-            const _destroy = (item: IDestroyable) => item.destroy();
+            const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ;
             const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
-                cleanup ? () => cleanup(value) :
+                cleanup ? () => cleanup(value) : _destroy(value);
-                    isDestroyable(value) ? () => _destroy(value) :
-                        noop;
             const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
                 has: () => false,
                 initialize: () => put(pendingSlot(put, remove)),
                 get: fail("The slot doesn't hold a value"),
                 store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
                 remove: noop,
                 cleanup: noop,
             });
             const pendingSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
                 has: () => false,
                 get: fail("The value in this slot doesn't exist"),
                 initialize: fail("Cyclic reference detected"),
                 store: (value, cleanup) => put(valueSlot(value, cleanup, remove)),
                 remove,
                 cleanup: noop
             });
             const valueSlot = <T>(value: T, cleanup: ((item: T) => void) | undefined, remove: () => void) => ({
                 has: () => true,
                 get: () => value,
                 initialize: fail("The slot already has a value"),
                 store: fail("The slot already has a value"),
                 cleanup: _makeCleanup(value, cleanup),
                 remove: remove
             });
             export class LifetimeManager implements ILifetimeManager {
                 private _destroyed = false;
                 private readonly _slots: Record<string, ILifetimeSlot<unknown>> = {};
                 slot<T>(cookie: string | number): ILifetimeSlot<T> {
                     if (cookie in this._slots)
                         return this._slots[cookie] as ILifetimeSlot<T>;
                     return newSlot<T>(this._put(cookie), this._remove(cookie));
                 }
                 private readonly _put = (id: string | number) => <T>(slot: ILifetimeSlot<T>) => {
                     this._assertNotDestroyed();
                     this._slots[id] = slot as ILifetimeSlot<unknown>;
                 };
                 private readonly _remove = (id: string | number) => () => {
                     this._assertNotDestroyed();
                     delete this._slots[id];
                 };
                 private _assertNotDestroyed() {
                     if (this._destroyed)
                         throw new Error("The lifetime manager is destroyed");
                 }
                 destroy() {
                     if (!this._destroyed) {
                         this._destroyed = true;
                         Object.values(this._slots).forEach(({ cleanup }) => safeCall(cleanup));
                     }
                 }
             }
             export const emptyLifetime = <T>() => () => _emptySlot as ILifetimeSlot<T>;
             let nextId = 1;
+            export const containerLifetime = <T>() => {
+                const slotId = nextId ++;
+                return (context: ILifetimeContext) =>
+                    context.ownerSlot<T>(slotId);
+            };
             export const hierarchyLifetime = <T>() => {
                 const slotId = nextId++;
                 return (context: ILifetimeContext) =>
                     context.containerSlot<T>(slotId);
             };
             /**
              * Creates a lifetime instance bound to the current activation context. This
              * lifetime will store the service instance per activation context. Every
              * top level service resolution will create a new activation context. This
              * context is propagated to subsequent service resolution thus all services
              * with context lifetime will be shared among their consumers.
              *
              * @returns The instance of the lifetime.
              */
             export const contextLifetime = <T>() => {
                 const slotId = nextId++;
                 return (context: ILifetimeContext) =>
                     context.contextSlot<T>(slotId);
             };
             const singletons = new LifetimeManager();
             /**
              * Creates the lifetime for the service which will allow existence only one
              * instance with the specified {@linkcode typeId}. If there will be created
              * several lifetime instances with same `typeId` in the runtime, they will
              * share the same service instance.
              *
              * @param typeId The identified for the global instance, usually this is a
              *   fully qualified class name
              * @returns The lifetime instance
              */
             export const singletonLifetime = <T>(typeId: string) => {
                 argumentNotNull(typeId, "typeId");
                 return () => singletons.slot<T>(typeId);
             };
             /** Creates a lifetime bound to the specified container. Using this lifetime
              * will create a single service instance per the specified container.
              *
              * @param container The container which will manage the lifetime for the service
              */
             export const containerLifetime = <T>(manager: ILifetimeManager) => {
                 const slotId = nextId++;
                 return () => manager.slot<T>(slotId);
             };

src/main/ts/interfaces.ts +17 -5

+            import { ContainerBuilder } from "./ContainerBuilder";
             import { key } from "./traits";
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
             export interface Resolver<S> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                  * @template K Ключ сервиса из {@linkcode S}
                  * @template O Тип параметра {@linkcode opts} используется для выведения типа
                  *   возвращаемого значения.
                  * @param name Ключ сервиса, который будет разрешен.
                  * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
                  *   будет возвращен фабричный метод для получения зависимости. Если не указан,
                  *   то считается `false`.
                  * @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
                  *   сервис не зарегистрирован
                  * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
                  * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
                  */
                 <K extends keyof S, O extends { lazy: true; }>(name: K, opts?: O): () => NonNullable<S[K]> | InferDefault<O>;
                 <K extends keyof S, O extends { lazy?: false; }>(name: K, opts?: O): NonNullable<S[K]> | InferDefault<O>;
             }
             export type DepsMap<S> = {
                 [k in key]: Refs<S> | keyof S;
             };
             export type Refs<S> = {
                 [k in keyof S]: Ref<k, S[k]>;
             }[keyof S];
             export type Ref<K extends key, D> = {
                 /** The name of the service */
                 name: K;
                 /** Make a lazy reference, the resolved dependency will be a function */
                 lazy?: boolean;
                 /** The default value for the case where the service isn't defined.
                  * When specified the dependency becomes optional, the default value can be
                  * `null` or `undefined`
                  */
                 default?: D | null
             };
             export type Lazy<T, L extends boolean> = L extends true ? () => T : T;
             /** Возвращает тип свойства `default` в типе {@link T} */
             export type InferDefault<T> = T extends { default: infer D } ? D : never;
             export type InferLazy<R> = R extends { lazy: infer L } ?
                 L extends true ? true : false :
                 false;
             export type Resolve<S, R> =
                 R extends keyof S ? NonNullable<S[R]> :
                 R extends Ref<infer K, unknown> ?
                 K extends keyof S ?
                 Lazy<NonNullable<S[K]> | InferDefault<R>, InferLazy<R>> :
                 never :
                 never;
             /**
              * Интерфейс для конфигурирования сервиса в контейнере. Конфигурирование сервиса
              * состоит из настройки различных параметров вызовами методов {@linkcode wants},
              * {@linkcode lifetime}, {@linkcode override}, {@linkcode cleanup}. Завершение настройки
              * сервиса осуществляется вызовом одного из методов {@linkcode factory} либо
              * {@linkcode value}.
              *
              * @template S Карта сервисов контейнера, доступных при описании дескриптора
              * @template T Тип сервиса
              * @template R Карта зависимостей, которая передается параметром фабрике
              * @template U Имена пользовательских сервисов, доступных для переопределения
              */
             export interface IDescriptorBuilder<S, T, R, U extends keyof S> {
                 /** Указывает фабрика для создания экземпляра сервиса, фабрика передается
                  * в виде параметра. При вызове фабрике будет передан объект с зависимостями,
                  * которые были предварительно указаны вызовами метода `wants(...)`
                  *
                  * Вызов данного метода завершает конфигурирование сервиса.
                  *
                  * @param f Фабрика для создания экземпляра сервиса.
                  */
                 factory(f: (refs: R) => NonNullable<T>): void;
                 /**
                  * Используется для указания зависимостей, которые потребуются фабричному
                  * методу при создании нового экземпляра сервиса. Данный метод может быть
                  * вызван несколько раз подряд, при этом вызовы этого метода имеют
                  * кумулятивный эффект.
                  *
                  * @template X Тип объекта с зависимостями, которые требуется получить при
                  *   создании экземпляра фабрики при помощи фабричного метода.
                  * @param refs Объект с описанием зависимостей
                  * @returns Возвращает дескриптор сервиса, в котором указаны необходимые
                  *   зависимости
                  */
                 wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
                     IDescriptorBuilder<S, T, R & {
                         [k in keyof X]: Resolve<S, X[k]>;
                     }, U>
                 override<K extends U>(name: K, builder: BuildDescriptorFn<S, S[K], U>): this;
                 override<X extends ConfigurationMapConstraint<S, U, keyof X>>(services: X): this;
                 lifetime(lifetime: "singleton", typeId: string | number | object): this;
                 lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
                 /** Указывает функцию для освобождения экземпляра сервиса для случаев, когда
                  * время жизни привязано к контейнеру.
                  */
                 cleanup(cb: (item: T) => void): this;
                 /**
                  * Регистрирует в контейнере постоянное значение в качестве реализации сервиса.
                  *
                  * @param v Экземпляр реализации сервиса.
                  */
                 value(v: NonNullable<T>): void;
             }
             export type BuildDescriptorFn<S, T, U extends keyof S> = (d: IDescriptorBuilder<S, T, Record<never, never>, U>) => void;
             /**
              * Конфигурация контейнера, состоит из набора функций, которые выполняют конфигурацию.
              *
              * Все параметры конфигурации являются обязательными, если требуется ввести
              * необязательные параметры, то нужно ограничить параметр типа {@linkcode K}
              *
              * @template S Сервисы доступные в контейнере
              * @template K Сервисы участвующие в конфигурации
              */
             export type ConfigurationMap<S, K extends keyof S, U extends keyof S> = {
                 [k in K]-?: BuildDescriptorFn<S, S[k], U>
             };
             export type ConfigurationMapConstraint<S, U extends keyof S, X extends string | number | symbol> = {
                 [k in X]-?: k extends U ? BuildDescriptorFn<S, S[k], U> : never;
             };
             /**
              * The type constraint useful to restrict type parameters to prevent defining
              * the services with the {@link ContainerKeys} names.
              *
              * The constraint doesn't exclude using this keys but declares them as `never`
              * which effectively will lead using this keys to the error.
              */
             export type ContainerServicesConstraint<S> = {
                 [k in keyof S]: k extends ContainerKeys ? never : S[k];
             };
             export interface Descriptor<S, T> {
+                /** The level of the service in the containers chain.
+                */
+                readonly level: number;
                 /** This flags indicates that this registration can be replaced or overridden. */
                 readonly configurable?: boolean;
                 /** If specified signals the activation context that a new service scope
                  * should be created to isolate service overrides.
                  */
                 readonly hasOverrides?: boolean;
                 activate(context: IActivationContext<S>): NonNullable<T>;
             }
             /** The context used to initialize lifetime instance {@linkcode ILifetime} */
             export interface ILifetimeContext {
+                ownerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
                 contextSlot<T>(slotId: string | number): ILifetimeSlot<T>;
                 containerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
             }
             export interface IActivationContext<S> extends ILifetimeContext, ServiceLocator<S> {
                 register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
                 fail(error: unknown): never;
+                selfContainer(): ServiceLocator<S>;
+                createChildContainer(): IContainerBuilder<S, Exclude<keyof S, ContainerKeys>>;
             }
             /**
              * Descriptors map for the specified services {@linkcode S}. All entries are
              * optional regardless the required or optional services in the original map.
              *
              * @template S Сервисы контекста активации
              * @template U Карта сервисов которые создаются дескрипторами
              */
             export type DescriptorMap<S> = {
                 [k in keyof S]?: Descriptor<S, S[k]>;
             };
             type ContainerKeys = keyof ContainerProvided<object>;
-            export type ContainerProvided<S extends ContainerServicesConstraint<S>> = {
+            export type ContainerProvided<S, U extends keyof S = keyof S> = {
-                container: ServiceLocator<ContainerServices<S>>;
+                container: ServiceLocator<ContainerProvided<S>>;
-                childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
+                childContainer: IContainerBuilder<S, U>;
             };
             /**
              * Таблица сервисов, которые предоставляет контейнер.
              *
              * Сервисы, предоставляемые контейнером не могут быть null или undefined.
              */
-            export type ContainerServices<S extends ContainerServicesConstraint<S>> = {
+            export type ContainerServices<S> = {
-                [k in keyof S | ContainerKeys]:
+                [k in (keyof S) | ContainerKeys]:
                 k extends ContainerKeys ? ContainerProvided<S>[k] :
                 k extends keyof S ? S[k] : never
             };
             /**
              * Returns the service declared in the type map {@link S}.
              *
              *
              */
             export interface ServiceLocator<S> {
                 resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
                 resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
             }
             export interface IContainerBuilder<S, U extends keyof S> {
                 createServiceBuilder<K extends U>(name: K):
                     IDescriptorBuilder<S, S[K], Record<never, never>, U>;
                 build(): ServiceLocator<S>;
             }
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export type ILifetime<T> = (context: ILifetimeContext) => ILifetimeSlot<NonNullable<T>>;
             export interface ILifetimeSlot<T> {
                 readonly has: () => boolean;
                 readonly get: () => T;
                 readonly initialize: () => void;
                 readonly store: (item: T, cleanup?: (item: T) => void) => void;
                 readonly remove: () => void;
                 readonly cleanup: () => void;
             }
             export interface ILifetimeManager extends IDestroyable {
                 slot<T>(id: string | number): ILifetimeSlot<T>;
             }
             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };
             export type ExtractRequiredKeys<T, K extends keyof T = keyof T> = { [p in K]-?: undefined extends T[p] ? never : p }[K];

src/test/ts/t/container.ts +3 -3

             /* eslint max-classes-per-file: ["error", 20] */
             import { describe, it } from "mocha";
             import { Container } from "../Container";
             import { ContainerBuilder } from "../ContainerBuilder";
-            import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver } from "../interfaces";
+            import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver, ServiceLocator } from "../interfaces";
             import { fluent } from "../traits";
             class Foo {
                 foo = "foo";
             }
             class Bar {
                 bar = "bar";
                 constructor(foo?: () => Foo) { }
             }
             interface Services {
                 foo: Foo;
                 bar?: Bar;
                 baz: Foo;
                 box?: Foo;
                 //container: string;
             }
             interface ServicesB {
                 // will give errors
                 // baz: Bar;
                 baz: Foo;
                 zoo?: Foo;
             }
             declare const resolver: Resolver<Services>;
             const foo = resolver("foo", { lazy: true, default: null });
             const mmap = <X extends DepsMap<Services>>(m: X) => { };
             declare const refs: Refs<Services>;
             if (refs && refs.name === "foo") {
                 refs.default;
             }
-            declare const x: ContainerServices<Services>;
+            declare const x: ServiceLocator<ContainerServices<Services>>;
-            x.container.resolve("container");
+            x.resolve("container").resolve("container");
             mmap({
                 fooz: { name: "foo", lazy: false, default: undefined },
                 ooz: "bar"
             });
             interface SharedServices {
                 foo: Foo;
                 bar?: Bar;
                 baz: Bar;
             }
             const config = fluent<Services>()
                 .declare<ServicesB>()
                 .register({
                     zoo: it => it.value(new Foo()),
                     bar: it => it
                         .lifetime("context") // тип активации, время жизни
                         .wants({
                             self: "container",
                             childContainer: "childContainer",
                             bar: "bar",
                             foo$: { name: "foo", lazy: true } // отложенная активация, фабричный метод
                         })
                         .override({ // переопределение сервиса
                             box: it => it.factory(() => new Foo())
                         })
                         .factory(({ foo$, bar, self, childContainer }) => // фабрика получает объект с именованными зависимостями
                             new Bar(foo$) // создается экземпляр сервиса
                         ),
                     foo: it => it.factory(() => new Foo()),
                     baz: it => it.value(new Foo()),
                     //box: it => it.factory(() => new Foo())
                 })
                 .done();
             declare const container: IContainerBuilder<ContainerServices<Services>, keyof Services>;
             const v = container.build().resolve("foo");
             if (v) {
                 // noop
             }
             const c2 = config.configure(container);
             c2.resolve("foo");
             declare const m: ContainerServices<{ foo?: Foo }>["container"];
             m.resolve("container").resolve("container").resolve("foo");

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