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 {
+            export class AggregateDescriptor<T> implements Descriptor<T> {
-                _value: object;
+                _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) {
+                _enter(name: keyof any) {
-                    this._path.push(name);
+                    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 {
+            export interface ReferenceDescriptorParams<S, K extends keyof S> {
-                name: string;
+                name: K;
                 lazy?: boolean;
                 optional?: boolean;
-                default?;
+                default?: S[K];
                 services?: ServiceMap;
             }
-            export class ReferenceDescriptor implements Descriptor {
+            export class ReferenceDescriptor<S, K extends keyof S> implements Descriptor<S[K]> {
-                _name: string;
+                _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 {
+            export class ValueDescriptor<T> implements Descriptor<T> {
-                _value;
+                _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 {
+            export interface Descriptor<T = any> {
-                activate(context: ActivationContext, name?: string);
+                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 {
+            export type ServiceMap<S = any> = {
-                [s: string]: Descriptor;
+                [k in keyof S]: Descriptor<S[k]>;
             }
             export enum ActivationType {
                 Singleton = 1,
                 Container,
                 Hierarchy,
                 Context,
                 Call
             }
-            export interface RegistrationWithServices {
+            export interface RegistrationWithServices<S> {
-                services?: object;
+                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 {
+            export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
-                $type: string | Constructor;
+                $type: string | Constructor<T>;
             }
-            export interface FactoryRegistration extends ServiceRegistration {
+            export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
-                $factory: string | Factory;
+                $factory: string | Factory<T>;
             }
-            export interface ValueRegistration {
+            export interface ValueRegistration<T> {
-                $value;
+                $value: T;
                 parse?: boolean;
             }
-            export interface DependencyRegistration extends RegistrationWithServices {
+            export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
-                $dependency: string;
+                $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