implab/implabjs-di Commit - r4:d9e74143f779

Removed ContextResolver, added DescriptoBuilder.wants(...), dependencies are declared statically

cin -

r4:d9e74143f779 default

parent child

Context file:

r4:d9e74143f779

Collapse all files

src/main/ts/ActivationError.ts +4 -4

             export interface ActivationItem {
                 name: string;
                 service: string;
             }
             export class ActivationError {
-                activationStack: ActivationItem[];
+                readonly activationStack: ActivationItem[];
-                service: string;
+                readonly service: string;
-                innerException: unknown;
+                readonly innerException: unknown;
-                message: string;
+                readonly message: string;
                 constructor(service: string, activationStack: ActivationItem[], innerException: unknown) {
                     this.message = "Failed to activate the service";
                     this.activationStack = activationStack;
                     this.service = service;
                     this.innerException = innerException;
                 }
                 toString() {
                     const parts = [this.message];
                     if (this.service)
                         parts.push(`when activating: ${String(this.service)}`);
                     if (this.innerException)
                         parts.push(`caused by: ${String(this.innerException)}`);
                     if (this.activationStack) {
                         parts.push("at");
                         parts.push.apply(null,
                             this.activationStack
                                 .map(({ name, service }) => `    ${name} ${service}`)
                         );
                     }
                     return parts.join("\n");
                 }
             }

src/main/ts/DescriptorBuilder.ts +33 -6

-            import { Resolver, RegistrationBuilder, LifetimeContainer, ConfigurableKeys } from "./interfaces";
+            import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces";
             import { Descriptor, ILifetime, ActivationType } from "./interfaces";
             import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
             import { LifetimeManager } from "./LifetimeManager";
-            import { each, isKey, isPromise, isString, oid } from "./traits";
+            import { each, isKey, isPromise, isString, key, oid } from "./traits";
             /**
              * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
              * @template {T} Тип сервиса
              */
-            export class DescriptorBuilder<S extends object, T> {
+            export class DescriptorBuilder<S extends object, T, R extends object = object> implements IDescriptorBuilder<S, T, R> {
                 private readonly _lifetimeContainer: LifetimeContainer;
                 private readonly _cb: (d: Descriptor<S, T>) => void;
                 private readonly _eb: (err: unknown) => void;
+                private readonly _refs: DepsMap<key, keyof S>;
                 private _lifetime = LifetimeManager.empty<T>();
                 private _overrides: RegistrationOverridesMap<S>;
                 private _cleanup?: (item: T) => void;
-                private _factory?: (resolve: Resolver<S>) => T;
+                private _factory?: (refs: R) => T;
                 private _pending = 1;
                 private _failed = false;
                 private _finalized = false;
                 /**
                  * Creates new DescriptorBuilder. Accepts a lifetime container for resolving "container"
                  * lifetime.
                  *
                  * @param container The lifetime container is the container where the service is to be registered.
                  * @param cb The callback to receive the built service descriptor
                  * @param eb The callback to receive the error due
                  */
                 constructor(container: LifetimeContainer, cb: (d: Descriptor<S, T>) => void, eb: (err: unknown) => void) {
                     this._lifetimeContainer = container;
                     this._cb = cb;
                     this._eb = eb;
                     this._overrides = {};
+                    this._refs = {};
                 }
+                wants<X extends { [k in Exclude<key, keyof R>]: keyof S | Ref<keyof S, boolean, unknown>; }>(refs: X):
+                    IDescriptorBuilder<S, T, R & {
+                        [k in keyof X]:
+                        X[k] extends keyof S ? NonNullable<S[X[k]]> :
+                        X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
+                        never;
+                    }> {
+                    each(refs, (v, k) => this._refs[k] = v);
+                    return this as IDescriptorBuilder<S, T, R & {
+                        [k in keyof X]:
+                        X[k] extends keyof S ? NonNullable<S[X[k]]> :
+                        X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
+                        never;
+                    }>;
+                }
+                factory(f: (refs: R) => T): void {
+                    this._assertBuilding();
+                    this._factory = f;
+                    this._finalize();
+                    this._complete();
+                }
                 private _assertBuilding() {
                     if (this._finalized)
                         throw new Error("The descriptor builder is finalized");
                 }
                 private _finalize() {
                     this._finalized = true;
                 }
                 override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
                 override<K extends ConfigurableKeys<S>>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this;
                 override<K extends ConfigurableKeys<S>>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): this {
                     this._assertBuilding();
                     const guard = (v: void | Promise<void>) => {
                         if (isPromise(v))
                             v.catch(err => this._fail(err));
                     };
                     if (isKey(nameOrServices)) {
                         if (builder) {
                             this._defer();
                             const d = new DescriptorBuilder<S, NonNullable<S[K]>>(
                                 this._lifetimeContainer,
                                 result => {
                                     this._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<T> | Exclude<ActivationType, "singleton">): this;
                 lifetime(lifetime: ILifetime<T> | ActivationType, typeId?: string): this {
                     this._assertBuilding();
                     if (isString(lifetime)) {
                         this._lifetime = this._resolveLifetime(lifetime, typeId);
                     } else {
                         this._lifetime = lifetime;
                     }
                     return this;
                 }
                 cleanup(cb: (item: T) => void): this {
                     this._assertBuilding();
                     this._cleanup = cb;
                     return this;
                 }
-                factory(f: (resolve: Resolver<S>) => T): void {
+                /*factory(f: (resolve: Resolver<S>) => T): void {
                     this._assertBuilding();
                     this._factory = f;
                     this._finalize();
                     this._complete();
+                }*/
                 value(v: T): void {
                     this._assertBuilding();
                     this._cb({
                         activate() {
                             return v;
                         }
                     });
                     this._finalize();
                 }
                 _resolveLifetime<T>(activation: ActivationType, typeId?: string | object): ILifetime<T> {
                     switch (activation) {
                         case "container":
                             return LifetimeManager.containerLifetime(this._lifetimeContainer);
                         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: unknown) {
                     if (!this._failed) {
                         this._failed = true;
                         this._eb.call(undefined, err);
                     }
                 }
             }

src/main/ts/DescriptorImpl.ts +35 -15

-            import { Descriptor, ILifetime, ConfigurableKeys, Resolver } from "./interfaces";
+            import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
-            import { ContextResolver } from "./ContextResolver";
+            import { each, isKey, key } from "./traits";
-            import { each } from "./traits";
             export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };
             export interface DescriptorImplArgs<S extends object, T> {
                 lifetime: ILifetime<T>;
-                factory: (resolve: Resolver<S>) => T;
+                factory: (refs: Record<key, never>) => T;
                 cleanup?: (item: T) => void;
                 overrides?: RegistrationOverridesMap<S>;
+                dependencies?: DepsMap<key, keyof S>;
             }
             export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
                 private readonly _overrides?: RegistrationOverridesMap<S>;
                 private readonly _lifetime: ILifetime<T>;
-                private readonly _factory: (resolve: Resolver<S>) => T;
+                private readonly _factory: (refs: Record<key, never>) => T;
                 private readonly _cleanup?: (item: T) => void;
-                constructor(args: DescriptorImplArgs<S, T>) {
+                private readonly _deps?: DepsMap<key, keyof S>;
-                    this._lifetime = args.lifetime;
-                    this._factory = args.factory;
+                constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
-                    if (args.cleanup)
+                    this._lifetime = lifetime;
-                        this._cleanup = args.cleanup;
+                    this._factory = factory;
-                    if (args.overrides)
+                    if (cleanup)
-                        this._overrides = args.overrides;
+                        this._cleanup = cleanup;
+                    if (overrides)
+                        this._overrides = overrides;
+                    if (dependencies)
+                        this._deps = dependencies;
                 }
                 activate(context: ActivationContext<S>): T {
                     if (this._lifetime.has())
                         return this._lifetime.get();
                     this._lifetime.initialize(context);
                     if (this._overrides)
                         each(this._overrides, (v, k) => context.register(k, v));
+                    const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
-                    const resolver = new ContextResolver(context);
+                        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 makeRefs = (deps?: DepsMap<key, keyof S>) => deps ?
+                        Object.keys(deps)
+                            .map(k => {
+                                const ref = deps[k];
+                                return isKey(ref) ?
+                                    { [k]: resolve({ name: ref }) } :
+                                    { [k]: resolve(ref) };
+                            })
+                            .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
+                        {} as Record<key, never>;
-                    const instance = this._factory.call(undefined, resolver.resolve.bind(resolver));
+                    const instance = this._factory.call(undefined, makeRefs(this._deps));
                     this._lifetime.store(instance, this._cleanup);
                     return instance;
                 }
                 toString() {
                     return `[object DescriptorImpl, lifetime=${String(this._lifetime)}]`;
                 }
             }

src/main/ts/FluentConfiguration.ts +5 -6

             import { DescriptorBuilder } from "./DescriptorBuilder";
             import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, ExtractRequired } from "./interfaces";
             import { ServiceContainer } from "./interfaces";
             import { argumentNotNull, each, isKey } from "./traits";
             export class FluentConfiguration<S extends object, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
                 private _builders: Partial<RegistrationBuildersMap<S>> = {};
                 /** Adds a declaration of the services to the current config.
                  *
                  * @template D The map of the services
                  * @returns self
                  */
                 declare<D extends Partial<Pick<S, keyof D & keyof S>>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
                     return this as FluentConfiguration<S & D, Y | ConfigurableKeys<D>>;
                 }
                 /** Adds compile-time information about the already provided services
                  *
                  * @template P The map of the provided services
                  * @returns self
                  */
                 provided<P extends Pick<S, keyof P & keyof S>>(): FluentConfiguration<S & P, Exclude<Y, keyof P>> {
                     return this as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
                 }
                 /** Register the service.
                  *
                  * @param name The name of the service
                  * @param builder The service builder
                  * @returns self
                  */
                 register<K extends Y>(name: K, builder: RegistrationBuildersMap<S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
                 /** Registers the collection of services
                  * @param config The collection of services to register.
                  * @returns self
                  */
                 register<K extends Y>(config: RegistrationBuildersMap<S, K>): FluentConfiguration<S, Exclude<Y, K>>;
                 register<K extends Y>(nameOrConfig: K | RegistrationBuildersMap<S, K>, builder?: RegistrationBuildersMap<S>[K]) {
                     if (isKey(nameOrConfig)) {
                         argumentNotNull(builder, "builder");
                         this._builders[nameOrConfig] = builder;
                     } else {
                         each(nameOrConfig, (v, k) => this.register(k, v));
                     }
                     return this as FluentConfiguration<S, Exclude<Y, K>>;
                 }
                 /**
                  * This method is used to enable a compile time check of the configuration.
                  * If there are not configured services in the configuration the compiler
                  * will trigger the error.
                  *
                  * @param missing Empty object literal should always be specified.
                  * @returns self
                  */
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 done<M extends ExtractRequired<S,Y>>(missing: M) {
                     return this;
                 }
-                apply<A extends Partial<S>>(target: ServiceContainer<A>) {
+                apply<T extends ServiceContainer<S>>(target: T) {
                     let pending = 1;
-                    const _t2 = target as ServiceContainer<S>;
                     const reject = (ex: unknown) => { throw ex; };
                     const complete = () => !--pending;
                     each(this._builders, (v, k) => {
                         pending++;
-                        const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(_t2,
+                        const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(
+                            target,
                             result => {
-                                _t2.register(k, result);
+                                target.register(k, result);
                                 complete();
                             },
                             reject
                         );
                         v(d);
                     });
                     if (!complete())
                         throw new Error("The configuration didn't complete.");
-                    return _t2 as ServiceContainer<A & S>;
+                    return target as T & ServiceContainer<S>;
                 }
             }

src/main/ts/interfaces.ts +19 -3

             import { ActivationContext } from "./ActivationContext";
+            import { key } from "./traits";
             export type primitive = number | string | null | undefined | symbol;
             export interface IDestroyable {
                 destroy(): void;
             }
             /**
              * @template S Карта доступных зависимостей
              */
             export interface Resolver<S extends object> {
                 /**
                  * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
                  * отложенную активацию и значение по-умолчанию для сервисов
                  * @template K Ключ сервиса из {@link S}
                  * @template O Тип параметра {@link opts} используется для выведения типа
                  *   возвращаемого значения.
                  * @param name Ключ сервиса, который будет разрешен.
                  * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
                  *   будет возвращен фабричный метод для получения зависимости. Если не указан,
                  *   то считается `false`.
                  * @param {any=} opts.default Значение по умолчанию, если в контейнере указанный
                  *   сервис не зарегистрирован
                  * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
                  * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
                  */
                 <K extends keyof S, O extends { lazy: true; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
                 <K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
             }
-            export interface DescriptorBuilder<S extends object, T> {
+            export type DepsMap<K extends key, SK extends key> = { [k in K]: SK | Ref<SK, boolean, unknown> };
+            export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L} | { name: K, lazy?: L, default: D };
+            export type Resolved<S, K extends keyof S, L, D> =
+                L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> |  (unknown extends D ? never : D);
+            export interface IDescriptorBuilder<S extends object, T, R extends object = object> {
                 /**
                  *
                  * @param f
                  */
-                factory(f: (resolve: Resolver<S>) => T): void;
+                factory(f: (refs: R) => T): void;
+                wants<X extends DepsMap<Exclude<key, keyof R>, keyof S>>(refs: X):
+                    IDescriptorBuilder<S, T, R & {
+                        [k in keyof X]:
+                        X[k] extends keyof S ? NonNullable<S[X[k]]> :
+                        X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S,K & keyof S,L,D>:
+                        never
+                    }>
                 override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
                 override<K extends ConfigurableKeys<S>>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
                 lifetime(lifetime: "singleton", typeId: string | number | object): this;
                 lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
                 cleanup(cb: (item: T) => void): this;
                 value(v: T): void;
             }
-            export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>) => void;
+            export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T>) => void;
             export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
                 [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[k]>>
             };
             export interface Descriptor<S extends object, T> {
                 activate(context: ActivationContext<S>): T;
             }
             export type ConfigurableDescriptor<S extends object, K extends ConfigurableKeys<S>> = Descriptor<ContainerServices<S>, ConfigurableServices<S>[K]>;
             export type RegistrationMap<S extends object, K extends keyof S = keyof S> = {
                 [k in K]-?: Descriptor<S, S[k]>;
             };
             export interface ProvidedServices<S extends object> {
                 container: ServiceLocator<ContainerServices<S>>;
                 childContainer: ServiceContainer<S>;
             }
             export type ProvidedKeys = keyof ProvidedServices<object>;
             export type ContainerKeys<S extends object> = keyof ContainerServices<S>;
             export type Mix<S, X> = { [k in keyof (S & X)]: k extends keyof X ? X[k] : S[k & keyof S] };
             export type ContainerServices<S extends object> = Mix<S, ProvidedServices<S>>;
             export type ConfigurableKeys<S extends object> = Exclude<keyof S, ProvidedKeys>;
             export type ConfigurableServices<S extends object> = Pick<S, ConfigurableKeys<S>>;
             export interface ServiceLocator<S extends object> {
                 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 LifetimeContainer {
                 createLifetime<T>(): ILifetime<T>;
             }
             export interface ServiceContainer<S extends object> extends ServiceLocator<ContainerServices<S>>, LifetimeContainer, IDestroyable {
                 register<K extends ConfigurableKeys<S>>(name: K, service: ConfigurableDescriptor<S, K>): void;
                 register<K extends ConfigurableKeys<S>>(services: { [k in K]: ConfigurableDescriptor<S, K> }): void;
                 createChildContainer(): ServiceContainer<S>;
             }
             export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
             /**
              * Интерфейс для управления жизнью экземпляра объекта. Каждая регистрация имеет
              * свой собственный объект `ILifetime`, который создается при первой активации
              */
             export interface ILifetime<T> {
                 /** Проверяет, что уже создан экземпляр объекта */
                 has(): boolean;
                 get(): T;
                 initialize(context: ActivationContext<object>): void;
                 store(item: T, cleanup?: (item: T) => void): void;
             }
             export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };

src/test/ts/t/container.ts +16 -9

             /* eslint max-classes-per-file: ["error", 20] */
             import { describe, it } from "mocha";
-            import {LifetimeManager} from "../LifetimeManager";
+            import { Container } from "../Container";
-            import {Container} from "../Container";
             import { fluent } from "../traits";
             class Foo {
                 foo = "foo";
             }
             class Bar {
                 bar = "bar";
-                constructor(foo?: () => Foo) {}
+                constructor(foo?: () => Foo) { }
             }
             interface Services {
                 foo: Foo;
                 bar?: Bar;
                 baz: Foo;
             }
             interface ServicesB {
                 // will give errors
                 // baz: Bar;
                 baz: Foo;
                 zoo?: Foo;
             }
             interface SharedServices {
                 foo: Foo;
                 bar?: Bar;
                 baz: Bar;
             }
             const config = fluent()
                 .declare<Services>()
                 .declare<ServicesB>()
                 .register({
                     bar: it => it
-                        .lifetime("context")
+                        .lifetime("context") // тип активации, время жизни
-                        .factory($ => new Bar($("zoo", {lazy: true, default: new Foo()}))),
+                        .wants({
-                    foo: it => it.factory($ => new Foo()),
+                            zoo: "zoo", // зависимость
+                            zoo$: { name: "zoo", lazy: true } // отложенная активация,
+                            //фабричный метод
+                        })
+                        .factory(({ zoo$ }) => // фабрика получает объект с именованными зависимостями
+                            // удобно для деструктурирования
+                            new Bar(zoo$) // создается экземпляр сервиса
+                        ),
+                    foo: it => it.factory(() => new Foo()),
                     baz: it => it.value(new Foo())
                 })
                 .done({});
-                declare const container: Container<SharedServices>;
+            declare const container: Container<Record<string, never>>;
             const c2 = config.apply(container);
-            c2.resolve("baz");
  No newline at end of file
+            c2.resolve("foo");
  No newline at end of file

src/main/ts/ContextResolver.ts removed 0 -19

NO CONTENT: file was removed

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