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