implab/implabjs-core Commit - r122:118478dfa903

Added LazyReferenceDescriptor, removed lazy behaviour from ReferenceDescriptor.

cin -

r122:118478dfa903 ioc ts support

parent child

Context file:

r122:118478dfa903

Collapse all files

src/main/ts/di/LazyReferenceDescriptor.ts created 644 +84 0

@@ -0,0 +1,84
	1	import { argumentNotEmptyString, each } from "../safe";
	2	import { ActivationContext } from "./ActivationContext";
	3	import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
	4	import { ActivationError } from "./ActivationError";
	5
	6	export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
	7	name: K;
	8	optional?: boolean;
	9	default?: ContainerResolve<S, K>;
	10	services?: PartialServiceMap<S>;
	11	}
	12
	13	export class LazyReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
	14	implements Descriptor<S, ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
	15
	16	_name: K;
	17
	18	_optional = false;
	19
	20	_default: ContainerResolve<S, K> \| undefined;
	21
	22	_services: PartialServiceMap<S>;
	23
	24	constructor(opts: ReferenceDescriptorParams<S, K>) {
	25	argumentNotEmptyString(opts && opts.name, "opts.name");
	26	this._name = opts.name;
	27	this._optional = !!opts.optional;
	28	this._default = opts.default;
	29
	30	this._services = (opts.services \|\| {}) as PartialServiceMap<S>;
	31	}
	32
	33	activate(context: ActivationContext<S>) {
	34	// добавляем сервисы
	35	if (this._services) {
	36	each(this._services, (v, k) => context.register(k, v));
	37	}
	38
	39	const saved = context.clone();
	40
	41	return (cfg?: PartialServiceMap<S>) => {
	42	// защищаем контекст на случай исключения в процессе
	43	// активации
	44	const ct = saved.clone();
	45	try {
	46	if (cfg) {
	47	each(cfg, (v, k) => ct.register(k, v));
	48	}
	49
	50	return this._optional ? ct.resolve(this._name, this._default) : ct
	51	.resolve(this._name);
	52	} catch (error) {
	53	throw new ActivationError(this._name.toString(), ct.getStack(), error);
	54	}
	55	};
	56
	57	}
	58
	59	toString() {
	60	const opts = [];
	61	if (this._optional)
	62	opts.push("optional");
	63
	64	opts.push("lazy");
	65
	66	const parts = [
	67	"@ref "
	68	];
	69	if (opts.length) {
	70	parts.push("{");
	71	parts.push(opts.join());
	72	parts.push("} ");
	73	}
	74
	75	parts.push(this._name.toString());
	76
	77	if (this._default !== undefined && this._default !== null) {
	78	parts.push(" = ");
	79	parts.push(String(this._default));
	80	}
	81
	82	return parts.join("");
	83	}
	84	}

src/main/ts/di/Annotations.ts +2 0

             import { primitive } from "../safe";
             import { TypeRegistration } from "./Configuration";
             export interface InjectOptions {
                 lazy?: boolean;
             }
             export interface Dependency<K extends keyof any> {
                 $dependency: K;
                 lazy?: boolean;
             }
             export interface Lazy<K extends keyof any> extends Dependency<K> {
                 lazy: true;
             }
             type Compatible<T1, T2> = T2 extends T1 ? any : never;
             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
             type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
                 D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
                 WalkDependencies<D, S>;
             type WalkDependencies<D, S> = D extends primitive ? D :
                 { [K in keyof D]: ExtractDependency<D[K], S> };
             export class Builder<T, S extends object> {
                 declare<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
                     };
                 }
                 inject<P extends any[]>(...args: P) {
                     return <X extends { [m in M]: (...args: any) => any }, M extends keyof (T | X)>(
                         target: X,
                         memberName: M,
                         descriptor: TypedPropertyDescriptor<Compatible<(...args: ExtractDependency<P, S>) => any, T[M]>>
                     ) => {
                     };
                 }
                 getDescriptor(): TypeRegistration<new () => T, S> {
                     throw new Error();
                 }
             }
             export interface DependencyOptions<T> {
                 optional?: boolean;
                 default?: T;
             }
             export interface LazyDependencyOptions<T> extends DependencyOptions<T> {
                 lazy: true;
             }
             interface Declaration<S extends object> {
                 define<T>(): Builder<T, S>;
                 dependency<K extends keyof S>(name: K, opts: LazyDependencyOptions<S[K]>): Lazy<K>;
                 dependency<K extends keyof S>(name: K, opts?: DependencyOptions<S[K]>): Dependency<K>;
                 config(): Config<S>;
             }
             type ServiceModule<T, S extends object, M extends string = "service"> = {
                 [m in M]: Builder<T, S>;
             };
+            type PromiseOrValue<T> = PromiseLike<T> | T;
             export interface Config<S extends object, Y extends keyof S = keyof S> {
                 register<K extends Y>(name: K, builder: Builder<S[K], S>): Config<S, Exclude<Y, K>>;
                 register<K extends Y>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<S, Exclude<Y, K>>;
                 register<K extends Y, M extends string>(name: K, m: Promise<ServiceModule<S[K], S, M>>, x: M): Config<S, Exclude<Y, K>>;
             }
             export declare function declare<S extends object>(): Declaration<S>;

src/main/ts/di/Configuration.ts +4 -3

             import {
                 PartialServiceMap,
                 ActivationType,
                 ContainerKeys,
                 ContainerResolve
             } from "./interfaces";
             import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } 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";
             import { isDescriptor } from "./traits";
+            import { LazyReferenceDescriptor } from "./LazyReferenceDescriptor";
             export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
                 services?: RegistrationMap<S>;
             }
             /**
              * Базовый интефейс конфигурации сервисов
              */
             export interface ServiceRegistration<T, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 params?: any;
                 inject?: object | object[];
                 cleanup?: ((instance: T) => void) | string;
             }
             export interface TypeRegistration<C extends new () => any, S extends object> extends ServiceRegistration<InstanceType<C>, S> {
                 $type: string | C;
             }
             export interface FactoryRegistration<F extends () => any, S extends object> extends ServiceRegistration<ReturnType<F>, S> {
                 $factory: string | F;
             }
             export interface ValueRegistration<T> {
                 $value: T;
                 parse?: boolean;
             }
             export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: ContainerResolve<S, K>;
             }
             export interface LazyDependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends DependencyRegistration<S, K> {
                 lazy: true;
             }
             export type Registration<T, S extends object> = T extends primitive ? T :
                 (
                     T |
                     { [k in keyof T]: Registration<T[k], S> } |
                     TypeRegistration<new () => T, S> |
                     FactoryRegistration<() => T, S> |
                     ValueRegistration<any> |
                     DependencyRegistration<S, keyof S>
                 );
             export type RegistrationMap<S extends object> = {
                 [k in keyof S]?: Registration<S[k], S>;
             };
             const _activationTypes: { [k in ActivationType]: number; } = {
                 singleton: 1,
                 container: 2,
                 hierarchy: 3,
                 context: 4,
                 call: 5
             };
             export function isTypeRegistration(x: any): x is TypeRegistration<new () => any, any> {
                 return (!isPrimitive(x)) && ("$type" in x);
             }
             export function isFactoryRegistration(x: any): x is FactoryRegistration<() => any, any> {
                 return (!isPrimitive(x)) && ("$factory" in x);
             }
             export function isValueRegistration(x: any): x is ValueRegistration<any> {
                 return (!isPrimitive(x)) && ("$value" in x);
             }
             export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export function isActivationType(x: string): x is ActivationType {
                 return typeof x === "string" && x in _activationTypes;
             }
             const trace = TraceSource.get("@implab/core/di/Configuration");
             async function mapAll(data: any[], map?: (v: any, k: number) => any): Promise<any[]>;
             async function mapAll(data: any, map?: (v: any, k: string) => any): Promise<any>;
             async function mapAll(data: any, map?: (v: any, k: 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;
             export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
                 readonly _container: Container<S>;
                 _path: Array<string>;
                 _configName: string | undefined;
                 _require: ModuleResolver | undefined;
                 constructor(container: Container<S>) {
                     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(undefined, contextRequire);
                     const config = await r(moduleName, ct);
                     await this._applyConfiguration(
                         config,
                         await makeResolver(moduleName, contextRequire),
                         ct
                     );
                 }
                 async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
                     argumentNotNull(data, "data");
                     await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
                 }
                 async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     if (resolver)
                         this._require = resolver;
                     let services: PartialServiceMap<S>;
                     try {
                         services = await this._visitRegistrations(data, "$");
                     } catch (e) {
                         throw this._makeError(e);
                     }
                     this._container.register(services);
                 }
                 _makeError(inner: any) {
                     const e = new ConfigError("Failed to load configuration", inner);
                     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: RegistrationMap<S>, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const services = await mapAll(data, async (v, k) => {
                         const d = await this._visit(v, k.toString());
                         return isDescriptor(d) ? d : new AggregateDescriptor(d);
                     }) as PartialServiceMap<S>;
                     this._leave();
                     return services;
                 }
                 _enter(name: string) {
                     this._path.push(name.toString());
                     trace.debug(">{0}", name);
                 }
                 _leave() {
                     const name = this._path.pop();
                     trace.debug("<{0}", name);
                 }
                 async _visit(data: any, name: string): Promise<any> {
                     if (isPrimitive(data) || isDescriptor(data))
                         return data;
                     if (isDependencyRegistration<S>(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: any, name: string) {
                     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: string) {
                     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<any, 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) {
                         opts.activation = data.activation;
                     }
                     if (data.cleanup)
                         opts.cleanup = data.cleanup;
                     return opts;
                 }
                 async _visitValueRegistration<T>(data: ValueRegistration<T>, name: string) {
                     this._enter(name);
                     const d = data.parse ? new AggregateDescriptor(data.$value) : new ValueDescriptor(data.$value);
                     this._leave();
                     return d;
                 }
                 async _visitDependencyRegistration<K extends keyof S>(data: DependencyRegistration<S, K>, name: string) {
                     argumentNotEmptyString(data && data.$dependency, "data.$dependency");
                     this._enter(name);
-                    const d = new ReferenceDescriptor<S, K>({
+                    const options = {
                         name: data.$dependency,
-                        lazy: data.lazy,
                         optional: data.optional,
                         default: data.default,
                         services: data.services && await this._visitRegistrations(data.services, "services")
-                    });
+                    };
+                    const d = data.lazy ? new LazyReferenceDescriptor<S, K>(options) : new ReferenceDescriptor<S, K>(options);
                     this._leave();
                     return d;
                 }
                 async _visitTypeRegistration(data: TypeRegistration<new () => any, S>, name: string) {
                     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<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
                 async _visitFactoryRegistration(data: FactoryRegistration<() => any, S>, name: string) {
                     argumentOfType(data.$factory, Function, "data.$factory");
                     this._enter(name);
                     const opts = this._makeServiceParams(data);
                     opts.factory = data.$factory;
                     const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/di/ReferenceDescriptor.ts +3 -30

             import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
-            import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
-                lazy?: boolean;
                 optional?: boolean;
                 default?: ContainerResolve<S, K>;
                 services?: PartialServiceMap<S>;
             }
             export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
-                implements Descriptor<S, ContainerResolve<S, K> | ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
+                implements Descriptor<S, ContainerResolve<S, K>> {
                 _name: K;
-                _lazy = false;
                 _optional = false;
                 _default: ContainerResolve<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                 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 || {}) as PartialServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
-                    if (this._lazy) {
+                    const res = this._optional ?
-                        const saved = context.clone();
-                        return (cfg?: PartialServiceMap<S>) => {
-                            // защищаем контекст на случай исключения в процессе
-                            // активации
-                            const ct = saved.clone();
-                            try {
-                                if (cfg) {
-                                    each(cfg, (v, k) => ct.register(k, v));
-                                return this._optional ? ct.resolve(this._name, this._default) : ct
-                                    .resolve(this._name);
-                            } catch (error) {
-                                throw new ActivationError(this._name.toString(), ct.getStack(), error);
-                        };
-                    } else {
-                        const v = this._optional ?
                         context.resolve(this._name, this._default) :
                         context.resolve(this._name);
-                        return v;
+                    return res;
                 }
                 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.toString());
                     if (this._default !== undefined && this._default !== null) {
                         parts.push(" = ");
                         parts.push(String(this._default));
                     }
                     return parts.join("");
                 }
             }

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