implab/implabjs-core Commit - r113:22cf333c0b34

working on IoC configuration

cin -

r113:22cf333c0b34 ioc ts support

parent child

Context file:

r113:22cf333c0b34

Collapse all files

src/main/ts/di/ActivationError.ts +1 -1

              import { ActivationContextInfo } from "./ActivationContext";
              export class ActivationError {
                  activationStack: ActivationContextInfo[];
                  service: string;
                  innerException: any;
                  message: string;
-                 constructor(service: string, activationStack: ActivationContextInfo[], innerException) {
+                 constructor(service: string, activationStack: ActivationContextInfo[], innerException: any) {
                      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: " + this.service.toString());
                      if (this.innerException)
                          parts.push("caused by: " + this.innerException.toString());
                      if (this.activationStack) {
                          parts.push("at");
                          this.activationStack
                              .forEach(x => parts.push(`    ${x.name} ${x.service}`));
                      }
                      return parts.join("\n");
                  }
              }

src/main/ts/di/AggregateDescriptor.ts +4 -4

              import { Descriptor, isDescriptor } from "./interfaces";
              import { ActivationContext } from "./ActivationContext";
              import { isPrimitive } from "../safe";
-             export class AggregateDescriptor implements Descriptor {
-                 _value: object;
+             export class AggregateDescriptor<T> implements Descriptor<T> {
+                 _value: T;
-                 constructor(value: object) {
+                 constructor(value: T) {
                      this._value = value;
                  }
                  activate(context: ActivationContext) {
                      return this._parse(this._value, context, "$value");
                  }
                  // TODO: make async
-                 _parse(value, context: ActivationContext, path: string) {
+                 _parse(value: T, context: ActivationContext, path: string) {
                      if (isPrimitive(value))
                          return value;
                      if (isDescriptor(value))
                          return context.activate(value, path);
                      if (value instanceof Array)
                          return value.map((x, i) => this._parse(x, context, `${path}[${i}]`));
                      const t = {};
                      for (const p of Object.keys(value))
                          t[p] = this._parse(value[p], context, `${path}.${p}`);
                      return t;
                  }
                  toString() {
                      return "@walk";
                  }
              }

src/main/ts/di/Configuration.ts +18 -16

              import {
                  ServiceRegistration,
                  TypeRegistration,
                  FactoryRegistration,
                  ServiceMap,
                  isDescriptor,
                  isDependencyRegistration,
                  DependencyRegistration,
                  ValueRegistration,
                  ActivationType,
                  isValueRegistration,
                  isTypeRegistration,
                  isFactoryRegistration
              } from "./interfaces";
              import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } 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";
              const trace = TraceSource.get("@implab/core/di/Configuration");
-             async function mapAll(data: object | any[], map?: (v, k) => any): Promise<any> {
+             async function mapAll(data: any | any[], map?: (v: any, k: keyof 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;
              type _key = string | number;
              export class Configuration {
                  _hasInnerDescriptors = false;
                  _container: Container;
                  _path: Array<_key>;
-                 _configName: string;
+                 _configName: string | undefined;
-                 _require: ModuleResolver;
+                 _require: ModuleResolver | undefined;
                  constructor(container: Container) {
                      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(null, contextRequire);
+                     const r = await makeResolver(undefined, contextRequire);
                      const config = await r(moduleName, ct);
                      await this._applyConfiguration(
                          config,
                          await makeResolver(moduleName, contextRequire),
                          ct
                      );
                  }
                  async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
                      argumentNotNull(data, "data");
                      await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                  }
                  async _applyConfiguration(data: object, resolver?: ModuleResolver, ct = Cancellation.none) {
                      trace.log("applyConfiguration");
                      this._configName = "$";
                      if (resolver)
                          this._require = resolver;
                      let services: ServiceMap;
                      try {
                          services = await this._visitRegistrations(data, "$");
                      } catch (e) {
                          throw this._makeError(e);
                      }
                      this._container.register(services);
                  }
-                 _makeError(inner) {
+                 _makeError(inner: any) {
                      const e = new ConfigError("Failed to load configuration", inner);
-                     e.configName = this._configName;
+                     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);
                          return localName ? get(localName, m) : 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, name: _key) {
+                 async _visitRegistrations(data: any, name: _key) {
                      this._enter(name);
                      if (data.constructor &&
                          data.constructor.prototype !== Object.prototype)
                          throw new Error("Configuration must be a simple object");
                      const o: ServiceMap = {};
                      const keys = Object.keys(data);
                      const services = await mapAll(data, async (v, k) => {
                          const d = await this._visit(v, k);
                          return isDescriptor(d) ? d : new AggregateDescriptor(d);
                      }) as ServiceMap;
                      this._leave();
                      return services;
                  }
-                 _enter(name: _key) {
-                     this._path.push(name);
+                 _enter(name: keyof any) {
+                     this._path.push(name.toString());
                      trace.debug(">{0}", name);
                  }
                  _leave() {
                      const name = this._path.pop();
                      trace.debug("<{0}", name);
                  }
-                 async _visit(data, name: string) {
+                 async _visit<T extends object>(data: T, name: keyof T) {
                      if (isPrimitive(data) || isDescriptor(data))
                          return data;
                      if (isDependencyRegistration(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: object, name: _key) {
                      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: _key) {
                      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) {
+                 _makeServiceParams<T, P, S>(data: ServiceRegistration<T, P, S>) {
                      const opts: any = {
                          owner: this._container
                      };
                      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) {
                          if (typeof (data.activation) === "string") {
                              switch (data.activation.toLowerCase()) {
                                  case "singleton":
                                      opts.activation = ActivationType.Singleton;
                                      break;
                                  case "container":
                                      opts.activation = ActivationType.Container;
                                      break;
                                  case "hierarchy":
                                      opts.activation = ActivationType.Hierarchy;
                                      break;
                                  case "context":
                                      opts.activation = ActivationType.Context;
                                      break;
                                  case "call":
                                      opts.activation = ActivationType.Call;
                                      break;
                                  default:
                                      throw new Error("Unknown activation type: " +
                                          data.activation);
                              }
                          } else {
                              opts.activation = Number(data.activation);
                          }
                      }
                      if (data.cleanup)
                          opts.cleanup = data.cleanup;
                      return opts;
                  }
-                 async _visitValueRegistration(data: ValueRegistration, name: _key) {
+                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: _key) {
                      this._enter(name);
                      const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                      this._leave();
                      return d;
                  }
-                 async _visitDependencyRegistration(data: DependencyRegistration, name: _key) {
+                 async _visitDependencyRegistration<S, K extends keyof S>(data: DependencyRegistration<S, K>, name: keyof S) {
                      argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                      this._enter(name);
-                     const d = new ReferenceDescriptor({
+                     const d = new ReferenceDescriptor<S, K>({
                          name: data.$dependency,
                          lazy: data.lazy,
                          optional: data.optional,
                          default: data.default,
                          services: data.services && await this._visitRegistrations(data.services, "services")
                      });
                      this._leave();
                      return d;
                  }
-                 async _visitTypeRegistration(data: TypeRegistration, name: _key) {
+                 async _visitTypeRegistration<T, P, S>(data: TypeRegistration<T, P, S>, name: _key) {
                      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);
                      }
                      const d = new TypeServiceDescriptor(
                          await mapAll(opts)
                      );
                      this._leave();
                      return d;
                  }
-                 async _visitFactoryRegistration(data: FactoryRegistration, name: _key) {
+                 async _visitFactoryRegistration<T, P, S>(data: FactoryRegistration<T, P, S>, name: _key) {
                      argumentOfType(data.$factory, Function, "data.$factory");
                      this._enter(name);
                      const opts = this._makeServiceParams(data);
                      opts.factory = data.$factory;
                      const d = new FactoryServiceDescriptor(
                          await mapAll(opts)
                      );
                      this._leave();
                      return d;
                  }
              }

src/main/ts/di/ReferenceDescriptor.ts +10 -9

              import { isNull, argumentNotEmptyString, each } from "../safe";
              import { ActivationContext } from "./ActivationContext";
              import { ServiceMap, Descriptor } from "./interfaces";
              import { ActivationError } from "./ActivationError";
-             export interface ReferenceDescriptorParams {
-                 name: string;
+             export interface ReferenceDescriptorParams<S, K extends keyof S> {
+                 name: K;
                  lazy?: boolean;
                  optional?: boolean;
-                 default?;
+                 default?: S[K];
                  services?: ServiceMap;
              }
-             export class ReferenceDescriptor implements Descriptor {
-                 _name: string;
+             export class ReferenceDescriptor<S, K extends keyof S> implements Descriptor<S[K]> {
+                 _name: K;
                  _lazy = false;
                  _optional = false;
                  _default: any;
                  _services: ServiceMap;
-                 constructor(opts: ReferenceDescriptorParams) {
+                 constructor(opts: ReferenceDescriptorParams<S, K>) {
                      argumentNotEmptyString(opts && opts.name, "opts.name");
                      this._name = opts.name;
                      this._lazy = !!opts.lazy;
                      this._optional = !!opts.optional;
                      this._default = opts.default;
-                     this._services = opts.services;
+                     this._services = opts.services || {};
                  }
                  activate(context: ActivationContext, name: string) {
                      // добавляем сервисы
                      if (this._services) {
                          for (const p of Object.keys(this._services))
                              context.register(p, this._services[p]);
                      }
                      if (this._lazy) {
                          const saved = context.clone();
                          return (cfg: ServiceMap) => {
                              // защищаем контекст на случай исключения в процессе
                              // активации
                              const ct = saved.clone();
                              try {
                                  if (cfg) {
                                      for (const k in cfg)
                                          ct.register(k, cfg[k]);
                                  }
                                  return this._optional ? ct.resolve(this._name, this._default) : ct
                                      .resolve(this._name);
                              } catch (error) {
-                                 throw new ActivationError(this._name, ct.getStack(), error);
+                                 throw new ActivationError(this._name.toString(), ct.getStack(), error);
                              }
                          };
                      } else {
                          // добавляем сервисы
                          if (this._services) {
                              for (const p of Object.keys(this._services))
                                  context.register(p, this._services[p]);
                          }
                          const v = this._optional ?
                              context.resolve(this._name, this._default) :
                              context.resolve(this._name);
                          return v;
                      }
                  }
                  toString() {
                      const opts = [];
                      if (this._optional)
                          opts.push("optional");
                      if (this._lazy)
                          opts.push("lazy");
                      const parts = [
                          "@ref "
                      ];
                      if (opts.length) {
                          parts.push("{");
                          parts.push(opts.join());
                          parts.push("} ");
                      }
-                     parts.push(this._name);
+                     parts.push(this._name.toString());
                      if (!isNull(this._default)) {
                          parts.push(" = ");
                          parts.push(this._default);
                      }
                      return parts.join("");
                  }
              }

src/main/ts/di/ValueDescriptor.ts +3 -3

              import { Descriptor } from "./interfaces";
-             export class ValueDescriptor implements Descriptor {
-                 _value;
+             export class ValueDescriptor<T> implements Descriptor<T> {
+                 _value: T;
-                 constructor(value) {
+                 constructor(value: T) {
                      this._value = value;
                  }
                  activate() {
                      return this._value;
                  }
                  toString() {
                      return `@type=${typeof this._value}`;
                  }
              }

src/main/ts/di/interfaces.ts +24 -24

-             import { isNull, isPrimitive } from "../safe";
+             import { isPrimitive } from "../safe";
              import { ActivationContext } from "./ActivationContext";
              import { Constructor, Factory } from "../interfaces";
-             export interface Descriptor {
-                 activate(context: ActivationContext, name?: string);
+             export interface Descriptor<T = any> {
+                 activate(context: ActivationContext, name?: string): T;
              }
-             export function isDescriptor(x): x is Descriptor {
+             export function isDescriptor(x: any): x is Descriptor {
                  return (!isPrimitive(x)) &&
                      (x.activate instanceof Function);
              }
-             export interface ServiceMap {
-                 [s: string]: Descriptor;
+             export type ServiceMap<S = any> = {
+                 [k in keyof S]: Descriptor<S[k]>;
              }
              export enum ActivationType {
                  Singleton = 1,
                  Container,
                  Hierarchy,
                  Context,
                  Call
              }
-             export interface RegistrationWithServices {
-                 services?: object;
+             export interface RegistrationWithServices<S> {
+                 services?: ServiceMap<S>;
              }
-             export interface ServiceRegistration extends RegistrationWithServices {
+             export interface ServiceRegistration<T, P, S> extends RegistrationWithServices<S> {
                  activation?: "singleton" | "container" | "hierarchy" | "context" | "call";
-                 params?;
+                 params?: P;
                  inject?: object | object[];
-                 cleanup?: (instance) => void | string;
+                 cleanup?: ((instance: T) => void) | string;
              }
-             export interface TypeRegistration extends ServiceRegistration {
-                 $type: string | Constructor;
+             export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
+                 $type: string | Constructor<T>;
              }
-             export interface FactoryRegistration extends ServiceRegistration {
-                 $factory: string | Factory;
+             export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
+                 $factory: string | Factory<T>;
              }
-             export interface ValueRegistration {
-                 $value;
+             export interface ValueRegistration<T> {
+                 $value: T;
                  parse?: boolean;
              }
-             export interface DependencyRegistration extends RegistrationWithServices {
-                 $dependency: string;
+             export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
+                 $dependency: K;
                  lazy?: boolean;
                  optional?: boolean;
-                 default?;
+                 default?: S[K];
              }
-             export function isTypeRegistration(x): x is TypeRegistration {
+             export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
                  return (!isPrimitive(x)) && ("$type" in x);
              }
-             export function isFactoryRegistration(x): x is FactoryRegistration {
+             export function isFactoryRegistration(x: any): x is FactoryRegistration<any, any, any> {
                  return (!isPrimitive(x)) && ("$factory" in x);
              }
-             export function isValueRegistration(x): x is ValueRegistration {
+             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                  return (!isPrimitive(x)) && ("$value" in x);
              }
-             export function isDependencyRegistration(x): x is DependencyRegistration {
+             export function isDependencyRegistration(x: any): x is DependencyRegistration<any, string | number | symbol> {
                  return (!isPrimitive(x)) && ("$dependency" in x);
              }

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