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 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";

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;
                      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)
                      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();

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 } from "./traits";
+             import { each, isKey, key } 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>;
              }
                  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>) {
-                     this._lifetime = args.lifetime;
-                     this._factory = args.factory;
-                     if (args.cleanup)
-                         this._cleanup = args.cleanup;
-                     if (args.overrides)
-                         this._overrides = args.overrides;
+                 private readonly _deps?: DepsMap<key, keyof S>;
+                 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;
                  }
                  activate(context: ActivationContext<S>): T {
                      if (this._overrides)
                          each(this._overrides, (v, k) => context.register(k, v));
-                     const resolver = new ContextResolver(context);
+                     const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
+                         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);

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

                  }
-                 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
                      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;
                  <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;
                  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]>>

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 {
              class Bar {
                  bar = "bar";
-                 constructor(foo?: () => Foo) {}
+                 constructor(foo?: () => Foo) { }
              }
              interface Services {
                  .declare<ServicesB>()
                  .register({
                      bar: it => it
-                         .lifetime("context")
-                         .factory($ => new Bar($("zoo", {lazy: true, default: new Foo()}))),
-                     foo: it => it.factory($ => new Foo()),
+                         .lifetime("context") // тип активации, время жизни
+                         .wants({
+                             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