implab/implabjs-core Commit - r118:6738ac4c3072

configuration interfaces moved to di/Configuration module...

cin -

r118:6738ac4c3072 ioc ts support

parent child

Context file:

r118:6738ac4c3072

Collapse all files

src/main/ts/di/traits.ts created 644 +7 0

@@ -0,0 +1,7
	1	import { isPrimitive } from "../safe";
	2	import { Descriptor } from "./interfaces";
	3
	4	export function isDescriptor(x: any): x is Descriptor {
	5	return (!isPrimitive(x)) &&
	6	(x.activate instanceof Function);
	7	}

src/main/ts/di/AggregateDescriptor.ts +7 -6

-            import { Descriptor, isDescriptor, Parse } from "./interfaces";
+            import { Descriptor } from "./interfaces";
             import { ActivationContext } from "./ActivationContext";
             import { isPrimitive } from "../safe";
+            import { isDescriptor } from "./traits";
-            export class AggregateDescriptor<T> implements Descriptor<Parse<T>> {
+            export class AggregateDescriptor<S, T> implements Descriptor<S, T> {
-                _value: T;
+                _value: any;
-                constructor(value: T) {
+                constructor(value: any) {
                     this._value = value;
                 }
-                activate<S>(context: ActivationContext<S>) {
+                activate(context: ActivationContext<S>): T {
                     return this._parse(this._value, context, "$value");
                 }
-                _parse<S, V>(value: V, context: ActivationContext<S>, path: string): Parse<V> {
+                _parse(value: any, context: ActivationContext<S>, path: string): any {
                     if (isPrimitive(value))
                         return value as any;
                     if (isDescriptor(value))
                         return context.activate(value, path);
                     if (value instanceof Array)
                         return value.map((x, i) => this._parse(x, context, `${path}[${i}]`)) as any;
                     const t: any = {};
                     for (const p in value)
                         t[p] = this._parse(value[p], context, `${path}.${p}`);
                     return t;
                 }
                 toString() {
                     return "@walk";
                 }
             }

src/main/ts/di/Annotations.ts +27 -10

             import { Constructor } from "../interfaces";
+            import { primitive } from "../safe";
             export interface InjectOptions {
                 lazy?: boolean;
             }
             interface Dependency<K extends keyof any> {
                 $dependency: K;
                 lazy?: boolean;
             }
             interface Lazy<K extends keyof any> extends Dependency<K> {
                 lazy: true;
             }
-            type Setter<T = any> = (v: T) => void;
             type Compatible<T1, T2> = T1 extends T2 ? 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> : VisitDependency<D, S>;
+            type ExtractDependency<D, S> = D extends { $dependency: infer K } ?
+                D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> :
+                WalkDependencies<D, S>;
-            type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
+            type WalkDependencies<D, S> = D extends primitive ? D :
+                { [K in keyof D]: ExtractDependency<D[K], S> };
-            interface Config<S> {
+            interface Services<S> {
-                dependency<K extends keyof S>(name: K): Dependency<K>;
+                get<K extends keyof S>(name: K): Dependency<K>;
                 lazy<K extends keyof S>(name: K): Lazy<K>;
-                build<T>(): Builder<T, S>;
+                build<T extends object>(): Builder<T, S>;
             }
-            export declare function services<S extends object>(): Config<S>;
+            export declare function services<S extends object>(): Services<S>;
+            export declare function build<T = never, S = any>(): Builder<T, S>;
             export class Builder<T, S> {
                 consume<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
                     };
                 }
-                inject<K extends keyof S>(dependency: K) {
+                inject<P extends any[]>(...args: P) {
                     // K = "bar"
                     // M = "setValue"
                     // S[K] = Bar
                     // T[M] = (value: string) => void
                     // P[m] = (value: V) => void
-                    return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
+                    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]>>
+                    ) => {
                     };
                 }
                 cast<T2 extends T>(): Builder<T2, S> {
                     return this as Builder<T2, S>;
                 }
+                get<K extends keyof S>(name: K): Dependency<K> {
+                    throw new Error();
                 }
+                lazy<K extends keyof S>(name: K): Lazy<K> {
+                    throw new Error();
+                }
+            }

src/main/ts/di/Configuration.ts +85 -45

             import {
-                ServiceRegistration,
+                PartialServiceMap,
-                TypeRegistration,
+                ActivationType
-                FactoryRegistration,
-                ServiceMap,
-                isDescriptor,
-                isDependencyRegistration,
-                DependencyRegistration,
-                ValueRegistration,
-                ActivationType,
-                isValueRegistration,
-                isTypeRegistration,
-                isFactoryRegistration,
-                PartialServiceMap
             } 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";
+            import { ICancellation, Constructor, Factory } from "../interfaces";
+            import { isDescriptor } from "./traits";
+            export interface RegistrationScope<S> {
+                /** сервисы, которые регистрируются в контексте активации и таким образом
+                 * могут переопределять ранее зарегистрированные сервисы. за это свойство
+                 * нужно платить, кроме того порядок активации будет влиять на результат
+                 * разрешения зависимостей.
+                 */
+                services?: PartialServiceMap<S>;
+            }
+            /**
+             * Базовый интефейс конфигурации сервисов
+             */
+            export interface ServiceRegistration<T, P, S> extends RegistrationScope<S> {
+                activation?: ActivationType;
+                params?: P;
+                inject?: object | object[];
+                cleanup?: ((instance: T) => void) | string;
+            }
+            export interface TypeRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+                $type: string | (new (...params: P) => T);
+            }
+            export interface FactoryRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+                $factory: string | ( (...params: P) => T);
+            }
+            export interface ValueRegistration<T> {
+                $value: T;
+                parse?: boolean;
+            }
+            export interface DependencyRegistration<S, K extends keyof S> extends RegistrationScope<S> {
+                $dependency: K;
+                lazy?: boolean;
+                optional?: boolean;
+                default?: S[K];
+            }
+            const _activationTypes: { [k in ActivationType]: number; } = {
+                singleton: 1,
+                container: 2,
+                hierarchy: 3,
+                context: 4,
+                call: 5
+            };
+            export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
+                return (!isPrimitive(x)) && ("$type" in x);
+            }
+            export function isFactoryRegistration(x: any): x is FactoryRegistration<any, 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>(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> {
                 _hasInnerDescriptors = false;
                 _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: 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: 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: any, name: string) {
                     this._enter(name);
                     if (data.constructor &&
                         data.constructor.prototype !== Object.prototype)
                         throw new Error("Configuration must be a simple object");
                     const o: PartialServiceMap<S> = {};
                     const keys = Object.keys(data);
                     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<T>(data: T, name: string): Promise<any> {
+                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 as T & object, name);
+                    return this._visitObject(data, name);
                 }
-                async _visitObject<T extends object>(data: T, name: string) {
+                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<T, P>(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") {
+                        opts.activation = data.activation;
-                            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<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>({
                         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<T, P>(data: TypeRegistration<T, P, S>, name: string) {
+                async _visitTypeRegistration(data: TypeRegistration<any, 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(
+                    const d = new TypeServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
-                async _visitFactoryRegistration<T, P>(data: FactoryRegistration<T, P, S>, name: string) {
+                async _visitFactoryRegistration(data: FactoryRegistration<any, 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(
+                    const d = new FactoryServiceDescriptor<S, any, any[]>(
                         await mapAll(opts)
                     );
                     this._leave();
                     return d;
                 }
             }

src/main/ts/di/Container.ts +3 -2

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { isDescriptor, ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             import { MapOf } from "../interfaces";
+            import { isDescriptor } from "./traits";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container<S = any> implements Resolver<S> {
-                readonly _services: PartialServiceMap<S, ContainerServices<S>>;
+                readonly _services: PartialServiceMap<ContainerServices<S>>;
                 readonly _cache: MapOf<any>;
                 readonly _cleanup: (() => void)[];
                 readonly _root: Container<S>;
                 readonly _parent?: Container<S>;
                 _disposed: boolean;
                 constructor(parent?: Container<S>) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this) as any;
                     this._disposed = false;
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (def !== undefined)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     } else {
                         const context = new ActivationContext<S>(this, this._services);
                         try {
                             return context.activate(d as Descriptor<S, T>, name.toString());
                         } catch (error) {
                             throw new ActivationError(name.toString(), context.getStack(), error);
                         }
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService<K extends keyof S, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T) {
                     return this.resolve(name, def);
                 }
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>): this;
                 register(services: PartialServiceMap<S>): this;
                 register<K extends keyof S>(nameOrCollection: K | ServiceMap<S>, service?: Descriptor<S, S[K]>) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection as ServiceMap<S>;
                         for (const name in data) {
                             if (Object.prototype.hasOwnProperty.call(data, name)) {
                                 this.register(name, data[name] as Descriptor<S, S[keyof S]>);
                             }
                         }
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection as K] = service as any;
                     }
                     return this;
                 }
                 onDispose(callback: () => void) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     if (this._disposed)
                         return;
                     this._disposed = true;
                     for (const f of this._cleanup)
                         f();
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | object, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer<S2 extends { container?: Container<S & S2> } = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }
                 has(id: string | number) {
                     return id in this._cache;
                 }
                 get(id: string | number) {
                     return this._cache[id];
                 }
                 store(id: string | number, value: any) {
                     return (this._cache[id] = value);
                 }
             }

src/main/ts/di/FactoryServiceDescriptor.ts +1 -2

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { argumentNotNull, oid } from "../safe";
-            import { ActivationType } from "./interfaces";
             export interface FactoryServiceDescriptorParams<S, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
                 factory: (...args: P) => T;
             }
             export class FactoryServiceDescriptor<S, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
                 constructor(opts: FactoryServiceDescriptorParams<S, T, P>) {
                     super(opts);
                     argumentNotNull(opts && opts.factory, "opts.factory");
                     // bind to null
                     this._factory = (...args) => opts.factory.apply(null, args as any);
-                    if (opts.activation === ActivationType.Singleton) {
+                    if (opts.activation === "singleton") {
                         this._cacheId = oid(opts.factory);
                     }
                 }
             }

src/main/ts/di/ReferenceDescriptor.ts +2 -2

             import { isNull, argumentNotEmptyString, each, keys } from "../safe";
             import { ActivationContext } from "./ActivationContext";
             import { ServiceMap, Descriptor, PartialServiceMap } from "./interfaces";
             import { ActivationError } from "./ActivationError";
             export interface ReferenceDescriptorParams<S, K extends keyof S> {
                 name: K;
                 lazy?: boolean;
                 optional?: boolean;
                 default?: S[K];
                 services?: PartialServiceMap<S>;
             }
             function defined<T>(v: T | undefined) {
                 if (v === undefined)
                     throw Error();
                 return v;
             }
             export class ReferenceDescriptor<S = any, K extends keyof S = keyof S> implements Descriptor<S, S[K] | ((args?: PartialServiceMap<S> ) => S[K])> {
                 _name: K;
                 _lazy = false;
                 _optional = false;
                 _default: S[K] | undefined;
-                _services: ServiceMap<S>;
+                _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 ServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {
                     // добавляем сервисы
                     if (this._services) {
                         each(this._services, (v, k) => context.register(k, v));
                     }
                     if (this._lazy) {
                         const saved = context.clone();
                         return (cfg?: PartialServiceMap<S>) => {
                             // защищаем контекст на случай исключения в процессе
                             // активации
                             const ct = saved.clone();
                             try {
                                 if (cfg) {
-                                    each(cfg as ServiceMap<S>, (v, k) => ct.register(k, v));
+                                    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;
                     }
                 }
                 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("");
                 }
             }

src/main/ts/di/ServiceDescriptor.ts +11 -10

             import { ActivationContext } from "./ActivationContext";
-            import { Descriptor, ActivationType, ServiceMap, isDescriptor, Parse, PartialServiceMap } from "./interfaces";
+            import { Descriptor, ServiceMap, PartialServiceMap, ActivationType } from "./interfaces";
             import { Container } from "./Container";
-            import { argumentNotNull, isPrimitive, each, keys, isNull } from "../safe";
+            import { argumentNotNull, isPrimitive, keys, isNull } from "../safe";
             import { TraceSource } from "../log/TraceSource";
+            import { isDescriptor } from "./traits";
             let cacheId = 0;
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             function injectMethod<T, M extends keyof T, S, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
                 if (!m || typeof m !== "function")
                     throw new Error("Method '" + method + "' not found");
                 if (args instanceof Array)
                     return m.apply(target, _parse(args, context, "." + method));
                 else
                     return m.call(target, _parse(args, context, "." + method));
             }
             function makeClenupCallback<T>(target: T, method: Cleaner<T>): () => void;
             function makeClenupCallback(target: any, method: any) {
                 if (typeof (method) === "string") {
                     return () => {
                         target[method]();
                     };
                 } else {
                     return () => {
                         method(target);
                     };
                 }
             }
-            function _parse<T, S>(value: T, context: ActivationContext<S>, path: string): Parse<T> {
+            function _parse(value: any, context: ActivationContext<any>, path: string): any {
                 if (isPrimitive(value))
                     return value as any;
                 trace.debug("parse {0}", path);
                 if (isDescriptor(value))
                     return context.activate(value, path);
                 if (value instanceof Array)
                     return value.map((x, i) => _parse(x, context, `${path}[${i}]`)) as any;
                 const t: any = {};
                 keys(value).forEach(p => t[p] = _parse(value[p], context, `${path}.${p}`));
                 return t;
             }
             export type Cleaner<T> = ((x: T) => void) | keyof Extract<T, { [M in keyof T]: () => void }>;
             export type InjectionSpec<T> = {
                 [m in keyof T]?: any;
             };
             export interface ServiceDescriptorParams<S, T, P extends any[]> {
                 activation?: ActivationType;
                 owner: Container<S>;
                 params?: P;
                 inject?: InjectionSpec<T>[];
                 services?: PartialServiceMap<S>;
                 cleanup?: Cleaner<T>;
             }
             export class ServiceDescriptor<S, T, P extends any[]> implements Descriptor<S, T> {
                 _instance: T | undefined;
                 _hasInstance = false;
-                _activationType = ActivationType.Call;
+                _activationType: ActivationType = "call";
                 _services: ServiceMap<S>;
                 _params: P | undefined;
                 _inject: InjectionSpec<T>[];
                 _cleanup: Cleaner<T> | undefined;
                 _cacheId: any;
                 _owner: Container<S>;
                 constructor(opts: ServiceDescriptorParams<S, T, P>) {
                     argumentNotNull(opts, "opts");
                     argumentNotNull(opts.owner, "owner");
                     this._owner = opts.owner;
                     if (!isNull(opts.activation))
                         this._activationType = opts.activation;
                     if (!isNull(opts.params))
                         this._params = opts.params;
                     this._inject = opts.inject || [];
                     this._services = (opts.services || {}) as ServiceMap<S>;
                     if (opts.cleanup) {
                         if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
                             throw new Error(
                                 "The cleanup parameter must be either a function or a function name");
                         this._cleanup = opts.cleanup;
                     }
                 }
                 activate(context: ActivationContext<S>) {
                     // if we have a local service records, register them first
                     let instance: T;
                     // ensure we have a cache id
                     if (!this._cacheId)
                         this._cacheId = ++cacheId;
                     switch (this._activationType) {
-                        case ActivationType.Singleton: // SINGLETON
+                        case "singleton": // SINGLETON
                             // if the value is cached return it
                             if (this._hasInstance)
                                 return this._instance;
                             // singletons are bound to the root container
                             const container = context.container.getRootContainer();
                             if (container.has(this._cacheId)) {
                                 instance = container.get(this._cacheId);
                             } else {
                                 instance = this._create(context);
                                 container.store(this._cacheId, instance);
                                 if (this._cleanup)
                                     container.onDispose(
                                         makeClenupCallback(instance, this._cleanup));
                             }
                             this._hasInstance = true;
                             return (this._instance = instance);
-                        case ActivationType.Container: // CONTAINER
+                        case "container": // CONTAINER
                             // return a cached value
                             if (this._hasInstance)
                                 return this._instance;
                             // create an instance
                             instance = this._create(context);
                             // the instance is bound to the container
                             if (this._cleanup)
                                 this._owner.onDispose(
                                     makeClenupCallback(instance, this._cleanup));
                             // cache and return the instance
                             this._hasInstance = true;
                             return (this._instance = instance);
-                        case ActivationType.Context: // CONTEXT
+                        case "context": // CONTEXT
                             // return a cached value if one exists
                             if (context.has(this._cacheId))
                                 return context.get(this._cacheId);
                             // context context activated instances are controlled by callers
                             return context.store(this._cacheId, this._create(context));
-                        case ActivationType.Call: // CALL
+                        case "call": // CALL
                             // per-call created instances are controlled by callers
                             return this._create(context);
-                        case ActivationType.Hierarchy: // HIERARCHY
+                        case "hierarchy": // HIERARCHY
                             // hierarchy activated instances are behave much like container activated
                             // except they are created and bound to the child container
                             // return a cached value
                             if (context.container.has(this._cacheId))
                                 return context.container.get(this._cacheId);
                             instance = this._create(context);
                             if (this._cleanup)
                                 context.container.onDispose(makeClenupCallback(
                                     instance,
                                     this._cleanup));
                             return context.container.store(this._cacheId, instance);
                         default:
                             throw new Error("Invalid activation type: " + this._activationType);
                     }
                 }
                 isInstanceCreated() {
                     return this._hasInstance;
                 }
                 getInstance() {
                     return this._instance;
                 }
                 _factory(...params: any[]): T {
                     throw Error("Not implemented");
                 }
                 _create(context: ActivationContext<S>) {
                     trace.debug(`constructing ${context._name}`);
-                    if (this._activationType !== ActivationType.Call &&
+                    if (this._activationType !== "call" &&
                         context.visit(this._cacheId) > 0)
                         throw new Error("Recursion detected");
                     if (this._services) {
                         keys(this._services).forEach(p => context.register(p, this._services[p]));
                     }
                     let instance: T;
                     if (this._params === undefined) {
                         instance = this._factory();
                     } else if (this._params instanceof Array) {
                         instance = this._factory.apply(this, _parse(this._params, context, "args"));
                     } else {
                         instance = this._factory(_parse(this._params, context, "args"));
                     }
                     if (this._inject) {
                         this._inject.forEach(spec => {
                             for (const m in spec)
                                 injectMethod(instance, m, context, spec[m]);
                         });
                     }
                     return instance;
                 }
             }

src/main/ts/di/interfaces.ts +6 -73

@@ -1,88 +1,21
1	import { isPrimitive, primitive } from "../safe";
2	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
3	import { Constructor, Factory } from "../interfaces";
4		2
5	export interface Descriptor<S = any, T = any> {	3	export interface Descriptor<S = any, T = any> {
6	activate(context: ActivationContext<S>): T;	4	activate(context: ActivationContext<S>): T;
7	}	5	}
8		6
9	export function isDescriptor(x: any): x is Descriptor {	7	export type ServiceMap<S> = {
10	return (!isPrimitive(x)) &&	8	[k in keyof S]: Descriptor<S, S[k]>;
11	(x.activate instanceof Function);
12	}
13
14	export type ServiceMap<S, S2 extends S = S> = {
15	[k in keyof S2]: Descriptor<S, S2[k]>;
16	};	9	};
17		10
18	export type PartialServiceMap<S, S2 ~~extends~~ S = S> = ~~Partial~~<~~ServiceMap~~<S, S2>>;	11	export type PartialServiceMap<S> = {
19		12	[k in keyof S]?: Descriptor<S, S[k]>;
20	export enum ActivationType {	13	};
21	Singleton = 1,
22	Container,
23	Hierarchy,
24	Context,
25	Call
26	}
27
28	export interface RegistrationWithServices<S> {
29	services?: ServiceMap<S>;
30	}
31
32	export interface ServiceRegistration<T, P, S> extends RegistrationWithServices<S> {
33
34	activation?: "singleton" \| "container" \| "hierarchy" \| "context" \| "call";
35
36	params?: P;
37
38	inject?: object \| object[];
39
40	cleanup?: ((instance: T) => void) \| string;
41	}
42
43	export interface TypeRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
44	$type: string \| Constructor<T>;
45	}
46
47	export interface FactoryRegistration<T, P, S> extends ServiceRegistration<T, P, S> {
48	$factory: string \| Factory<T>;
49	}
50
51	export interface ValueRegistration<T> {
52	$value: T;
53	parse?: boolean;
54	}
55
56	export interface DependencyRegistration<S, K extends keyof S> extends RegistrationWithServices<S> {
57	$dependency: K;
58	lazy?: boolean;
59	optional?: boolean;
60	default?: S[K];
61	}
62
63	export type Parse<T> = T extends primitive ? T:
64	T extends Descriptor<infer V> ? V :
65	{ [K in keyof T]: Parse<T[K]> };
66		14
67	export interface Resolver<S> {	15	export interface Resolver<S> {
68	resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;	16	resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;
69	}	17	}
70	export type ContainerServices<S> = S & {	18	export type ContainerServices<S> = S & {
71	container: Resolver<S>;	19	container: Resolver<S>;
72	};	20	};
73		21	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";
74	export function isTypeRegistration(x: any): x is TypeRegistration<any, any, any> {
75	return (!isPrimitive(x)) && ("$type" in x);
76	}
77
78	export function isFactoryRegistration(x: any): x is FactoryRegistration<any, any, any> {
79	return (!isPrimitive(x)) && ("$factory" in x);
80	}
81
82	export function isValueRegistration(x: any): x is ValueRegistration<any> {
83	return (!isPrimitive(x)) && ("$value" in x);
84	}
85
86	export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
87	return (!isPrimitive(x)) && ("$dependency" in x);
88	}

src/test/ts/mock/Bar.ts +11 -11

             import { Foo } from "./Foo";
-            // import { config } from "./config";
+            import { build } from "./config";
-            // const service = config.build("bar");
+            const service = build<Bar>();
-            // @service.consume({
+            @service.consume({
-            //     f: config.dependency("foo"),
+                foo: service.get("foo"),
-            //     nested: {
+                nested: {
-            //         lazy: config.lazy("foo")
+                    lazy: service.lazy("foo")
-            //     }
-            // })
+            })
             export class Bar {
                 barName = "bar";
                 _v: Foo | undefined;
-                constructor(_opts: {
+                constructor(_opts?: {
-                    foo: Foo;
+                    foo?: Foo;
-                    nested: {
+                    nested?: {
                         lazy: () => Foo
                     }
                 }) {
                     if (_opts && _opts.foo)
                         this._v = _opts.foo;
                 }
                 getFoo() {
                     if (this._v === undefined)
                         throw new Error("The foo isn't set");
                     return this._v;
                 }
             }

src/test/ts/mock/Box.ts +6 -3

             import { services } from "../di/Annotations";
             import { Bar } from "./Bar";
+            import { Foo } from "./Foo";
             // declare required dependencies
             const config = services<{
                  bar: Bar;
+                 foo: Foo;
             }>();
             // export service descriptor
             export const service = config.build<Box<Bar>>();
-            @service.consume(config.dependency("bar"))
+            @service.consume(config.get("bar"))
             export class Box<T> {
                 private _value: T | undefined;
                 constructor(value: T) {
                     this._value = value;
                 }
-                // @service.inject("bar")
+                @service.inject( config.get("bar"))
-                setValue(value: T) {
+                setValue(value?: T) {
                     this._value = value;
+                    return value;
                 }
                 setObj(value: object) {
                 }
                 getValue() {
                     if (this._value === undefined)
                         throw new Error("Trying to get a value from the empty box");
                     return this._value;
                 }
             }

src/test/ts/mock/config.ts +8 -19

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { Box } from "./Box";
-            import { primitive } from "../safe";
+            import { Builder } from "../di/Annotations";
-            import { Constructor } from "../interfaces";
             interface Services {
                 foo: Foo;
                 bar: Bar;
                 box: Box<Foo>;
                 host: string;
             }
-            interface TypeDescriptor<T, C extends Constructor<T>> {
+            const services = {
-                $type: C;
+                build: <T>() => {
+                    return new Builder<T, Services>();
+                }
+            };
-                params: Wrap<ConstructorParameters<C>>;
+            namespace services {
-            function typeRegistration<T, C extends Constructor<T>>(target: C, params: Wrap<ConstructorParameters<C>>): TypeDescriptor<T, C> {
-                throw new Error();
             }
-            declare function register<T>(): { type<C extends Constructor<T>>(target: C, params: Wrap<ConstructorParameters<C>>): TypeDescriptor<T, C>};
+            export = services;
-            type Wrap<T> = T extends primitive ? T :
-                { [k in keyof T]: Wrap<T[k]> } | TypeDescriptor<T, Constructor<T>>;
-            const config: Wrap<Services> = {
-                foo: typeRegistration(Foo, []),
-                bar: typeRegistration(Bar, [{ foo: null as any, nested: null as any }]),
-                box: register<Box<Foo>>().type(Box, [{ $type: Bar, params: [] }]),
-                host: ""
-            };

src/test/ts/tests/ContainerTests.ts +1 0

             import { test } from "./TestTraits";
             import { Container } from "../di/Container";
             import { ReferenceDescriptor } from "../di/ReferenceDescriptor";
             import { AggregateDescriptor } from "../di/AggregateDescriptor";
             import { ValueDescriptor } from "../di/ValueDescriptor";
             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             import { isNull } from "../safe";
             import { Descriptor } from "../di/interfaces";
             test("Container register/resolve tests", async t => {
                 const container = new Container();
                 const connection1 = "db://localhost";
                 t.throws(
                     () => container.register("bla-bla", "bla-bla" as any),
                     "Do not allow to register anything other than descriptors"
                 );
                 t.doesNotThrow(
                     () => container.register("connection", new ValueDescriptor(connection1)),
                     "register ValueDescriptor"
                 );
                 t.equals(container.resolve("connection"), connection1, "resolve string value");
                 t.doesNotThrow(
                     () => container.register(
                         "dbParams",
                         new AggregateDescriptor({
                             timeout: 10,
                             connection: new ReferenceDescriptor({ name: "connection" })
                         })
                     ),
                     "register AggregateDescriptor"
                 );
                 const dbParams = container.resolve("dbParams");
                 t.equals(dbParams.connection, connection1, "should get string value 'dbParams.connection'");
             });
             test("Container configure/resolve tests", async t => {
                 const container = new Container();
                 await container.configure({
                     foo: {
                         $type: Foo
                     },
                     box: {
                         $type: Bar,
                         params: {
                             $dependency: "foo"
                         }
                     },
                     bar: {
                         $type: Bar,
                         params: {
                             db: {
                                 provider: {
                                     $dependency: "db"
                                 }
                             }
                         }
                     }
                 });
                 t.pass("should configure from js object");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 t.throws(() => container.resolve("bar"), "should not resolve dependency 'db'");
             });
             test("Load configuration from module", async t => {
                 const container = new Container();
                 await container.configure("../mock/config1", { contextRequire: require });
                 t.pass("The configuration should load");
                 const f1 = container.resolve("foo");
                 t.assert(!isNull(f1), "foo should be not null");
                 const b1 = container.resolve("bar") as Bar;
                 t.assert(!isNull(b1), "bar should not be null");
                 t.assert(!isNull(b1._v), "bar.foo should not be null");
             });

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