implab/implabjs-core Commit - r120:1b124b65514a

improved interfaces and more tight type checking

cin -

r120:1b124b65514a ioc ts support

parent child

Context file:

r120:1b124b65514a

Collapse all files

src/main/ts/di/ActivationContext.ts +10 -10

             import { TraceSource } from "../log/TraceSource";
-            import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
+            import { argumentNotNull, argumentNotEmptyString } from "../safe";
-            import { Descriptor, ServiceMap, PartialServiceMap } from "./interfaces";
+            import { Descriptor, ContainerProvided, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
             import { Container } from "./Container";
             import { MapOf } from "../interfaces";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
-            export interface ActivationContextInfo<S> {
+            export interface ActivationContextInfo<S extends object> {
                 name: string;
                 service: string;
-                scope: PartialServiceMap<S>;
+                scope: ContainerServiceMap<S>;
             }
-            export class ActivationContext<S> {
+            export class ActivationContext<S extends object> {
                 _cache: MapOf<any>;
-                _services: PartialServiceMap<S>;
+                _services: ContainerServiceMap<S>;
                 _stack: ActivationContextInfo<S>[];
                 container: Container<S>;
-                constructor(container: Container<S>, services: PartialServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
+                constructor(container: Container<S>, services: ContainerServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
                     argumentNotNull(container, "container");
                     argumentNotNull(services, "services");
                     return this._name;
                 }
-                resolve<K extends keyof S, T extends S[K]>(name: K, def?: T): T {
+                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
                     const d = this._services[name];
                     if (d !== undefined) {
-                        return this.activate(d as Descriptor<S, T>, name.toString());
+                        return this.activate(d, name.toString());
                     } else {
                         if (def !== undefined && def !== null)
                             return def;
                 register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
                     argumentNotEmptyString(name, "name");
-                    this._services[name] = service;
+                    this._services[name] = service as any;
                 }
                 clone() {

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

             import { isPrimitive } from "../safe";
             import { isDescriptor } from "./traits";
-            export class AggregateDescriptor<S, T> implements Descriptor<S, T> {
+            export class AggregateDescriptor<S extends object, T> implements Descriptor<S, T> {
                 _value: any;
                 constructor(value: any) {

src/main/ts/di/Annotations.ts +11 -9

             type WalkDependencies<D, S> = D extends primitive ? D :
                 { [K in keyof D]: ExtractDependency<D[K], S> };
-            export class Builder<T, 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) => {
-                        return constructor as C & { service: Builder<T, S> };
                     };
                 }
             }
-            interface Declaration<S> {
+            interface Declaration<S extends object> {
                 define<T>(): Builder<T, S>;
                 dependency<K extends keyof S>(name: K, opts: { lazy: true }): Lazy<K>;
                 config(): Config<S>;
             }
-            interface ServiceModule<T, S> {
+            type ServiceModule<T, S extends object, M extends string = "service"> = {
-                service: Builder<T, S>;
+                [m in M]: Builder<T, S>;
+            };
-            interface Config<S> {
+            export interface Config<S extends object, Y extends keyof S = keyof S> {
-                register<K extends keyof S>(name: K, builder: Builder<S[K], S>): Config<Omit<S, K>>;
+                register<K extends Y>(name: K, builder: Builder<S[K], S>): Config<S, Exclude<Y, K>>;
-                register<K extends keyof S>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<Omit<S, 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 +33 -20

             import {
                 PartialServiceMap,
-                ActivationType
+                ActivationType,
+                ContainerKeys,
+                ContainerResolve
             } from "./interfaces";
-            import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
+            import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
             import { AggregateDescriptor } from "./AggregateDescriptor";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { Container } from "./Container";
             import { ConfigError } from "./ConfigError";
             import { Cancellation } from "../Cancellation";
             import { makeResolver } from "./ResolverHelper";
-            import { ICancellation, Constructor, Factory } from "../interfaces";
+            import { ICancellation } from "../interfaces";
             import { isDescriptor } from "./traits";
-            export interface RegistrationScope<S> {
+            export interface RegistrationScope<S extends object> {
                 /** сервисы, которые регистрируются в контексте активации и таким образом
                  * могут переопределять ранее зарегистрированные сервисы. за это свойство
                  * нужно платить, кроме того порядок активации будет влиять на результат
                  * разрешения зависимостей.
                  */
-                services?: PartialServiceMap<S>;
+                services?: RegistrationMap<S>;
             }
             /**
              * Базовый интефейс конфигурации сервисов
              */
-            export interface ServiceRegistration<T, P, S> extends RegistrationScope<S> {
+            export interface ServiceRegistration<T, P, S extends object> extends RegistrationScope<S> {
                 activation?: ActivationType;
                 cleanup?: ((instance: T) => void) | string;
             }
-            export interface TypeRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+            export interface TypeRegistration<T, P extends any[], S extends object> extends ServiceRegistration<T, P, S> {
                 $type: string | (new (...params: P) => T);
             }
-            export interface FactoryRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+            export interface FactoryRegistration<T, P extends any[], S extends object> extends ServiceRegistration<T, P, S> {
                 $factory: string | ((...params: P) => T);
             }
                 parse?: boolean;
             }
-            export interface DependencyRegistration<S, K extends keyof S> extends RegistrationScope<S> {
+            export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
                 $dependency: K;
                 lazy?: boolean;
                 optional?: boolean;
-                default?: S[K];
+                default?: ContainerResolve<S, K>;
             }
+            export type Registration<T, S extends object> = T extends primitive ? T :
+                (
+                    T |
+                    { [k in keyof T]: Registration<T[k], S> } |
+                    TypeRegistration<T, any, S> |
+                    FactoryRegistration<T, any, 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,
                 return (!isPrimitive(x)) && ("$value" in x);
             }
-            export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
+            export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
                 return (!isPrimitive(x)) && ("$dependency" in x);
             }
             export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
-            export class Configuration<S> {
+            export class Configuration<S extends object> {
                 _hasInnerDescriptors = false;
-                _container: Container<S>;
+                readonly _container: Container<S>;
                 _path: Array<string>;
                     );
                 }
-                async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
+                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: object, resolver?: ModuleResolver, ct = Cancellation.none) {
+                async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
                     trace.log("applyConfiguration");
                     this._configName = "$";
                     return this._require(moduleName);
                 }
-                async _visitRegistrations(data: any, name: string) {
+                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 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);
                     return v;
                 }
-                _makeServiceParams<T, P>(data: ServiceRegistration<T, P, S>) {
+                _makeServiceParams(data: ServiceRegistration<any, any, S>) {
                     const opts: any = {
                         owner: this._container
                     };

src/main/ts/di/Container.ts +9 -9

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
-            import { ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
+            import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
-            import { Configuration } from "./Configuration";
+            import { Configuration, RegistrationMap } 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> {
+            export class Container<S extends object = any> implements Resolver<S> {
-                readonly _services: PartialServiceMap<ContainerServices<S>>;
+                readonly _services: ContainerServiceMap<S>;
                 readonly _cache: MapOf<any>;
                     return this._parent;
                 }
-                resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T {
+                resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         const context = new ActivationContext<S>(this, this._services);
                         try {
-                            return context.activate(d as Descriptor<S, T>, name.toString());
+                            return context.activate(d, 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) {
+                getService<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
                     return this.resolve(name, def);
                 }
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
-                async configure(config: string | object, opts?: any, ct = Cancellation.none) {
+                async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration<S>(this);
                     if (typeof (config) === "string") {
                     }
                 }
-                createChildContainer<S2 extends { container?: Container<S & S2> } = S>(): Container<S & S2> {
+                createChildContainer<S2 extends object = S>(): Container<S & S2> {
                     return new Container<S & S2>(this as any);
                 }

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

             import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
             import { argumentNotNull, oid } from "../safe";
-            export interface FactoryServiceDescriptorParams<S, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
+            export interface FactoryServiceDescriptorParams<S extends object, 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> {
+            export class FactoryServiceDescriptor<S extends object, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
                 constructor(opts: FactoryServiceDescriptorParams<S, T, P>) {
                     super(opts);

src/main/ts/di/ReferenceDescriptor.ts +8 -12

-            import { isNull, argumentNotEmptyString, each, keys } from "../safe";
+            import { argumentNotEmptyString, each } from "../safe";
             import { ActivationContext } from "./ActivationContext";
-            import { ServiceMap, Descriptor, PartialServiceMap } from "./interfaces";
+            import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
             import { ActivationError } from "./ActivationError";
-            export interface ReferenceDescriptorParams<S, K extends keyof S> {
+            export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
                 name: K;
                 lazy?: boolean;
                 optional?: boolean;
-                default?: S[K];
+                default?: ContainerResolve<S, K>;
                 services?: PartialServiceMap<S>;
             }
-            function defined<T>(v: T | undefined) {
+            export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
-                if (v === undefined)
+                implements Descriptor<S, ContainerResolve<S, K> | ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
-                    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;
+                _default: ContainerResolve<S, K> | undefined;
                 _services: PartialServiceMap<S>;
                     this._optional = !!opts.optional;
                     this._default = opts.default;
-                    this._services = (opts.services || {}) as ServiceMap<S>;
+                    this._services = (opts.services || {}) as PartialServiceMap<S>;
                 }
                 activate(context: ActivationContext<S>) {

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

             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) {
+            function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
                 const m = target[method];
                 if (!m || typeof m !== "function")
                 [m in keyof T]?: any;
             };
-            export interface ServiceDescriptorParams<S, T, P extends any[]> {
+            export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
                 activation?: ActivationType;
                 owner: Container<S>;
                 cleanup?: Cleaner<T>;
             }
-            export class ServiceDescriptor<S, T, P extends any[]> implements Descriptor<S, T> {
+            export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
                 _instance: T | undefined;
                 _hasInstance = false;

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

             import { Constructor, Factory } from "../interfaces";
             import { argumentNotNull, isPrimitive } from "../safe";
-            export interface TypeServiceDescriptorParams<S, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
+            export interface TypeServiceDescriptorParams<S extends object, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
                 type: Constructor<T>;
             }
-            export class TypeServiceDescriptor<S, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
+            export class TypeServiceDescriptor<S extends object, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
                 _type: Constructor;
                 constructor(opts: TypeServiceDescriptorParams<S, T, P>) {

src/main/ts/di/interfaces.ts +25 -8

@@ -1,21 +1,38
1	import { ActivationContext } from "./ActivationContext";	1	import { ActivationContext } from "./ActivationContext";
2		2
3	export interface Descriptor<S = any, T = any> {	3	export interface Descriptor<S extends object = any, T = any> {
4	activate(context: ActivationContext<S>): T;	4	activate(context: ActivationContext<S>): T;
5	}	5	}
6		6
7	export type ServiceMap<S> = {	7	export type ServiceMap<S extends object> = {
8	[k in keyof S]: Descriptor<S, S[k]>;	8	[k in keyof S]: Descriptor<S, S[k]>;
9	};	9	};
10		10
11	export type PartialServiceMap<S> = {	11	export type ContainerKeys<S extends object> = keyof S \| keyof ContainerProvided<S>;
		12
		13	export type ContainerResolve<S extends object, K> =
		14	K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
		15	K extends keyof S ? S[K] : never;
		16
		17	export type ContainerServiceMap<S extends object> = {
		18	[K in ContainerKeys<S>]: Descriptor<S, ContainerResolve<S, K>>;
		19	};
		20
		21	export type PartialServiceMap<S extends object> = {
12	[k in keyof S]?: Descriptor<S, S[k]>;	22	[k in keyof S]?: Descriptor<S, S[k]>;
13	};	23	};
14		24
15	export interface Resolver<S> {	25	export interface Resolver<S extends object> {
16	resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;	26	resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K>;
		27	}
		28
		29	export interface ContainerProvided<S extends object> {
		30	container: Resolver<S>;
17	}	31	}
18	export type ContainerServices<S> = S & {	32
19	container: Resolver<S>;	33	export type ContainerRegistered<S extends object> = /*{
20	};	34	[K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
		35	};*/
		36	Exclude<S, ContainerProvided<S>>;
		37
21	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";	38	export type ActivationType = "singleton" \| "container" \| "hierarchy" \| "context" \| "call";

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

             export function isDescriptor(x: any): x is Descriptor {
                 return (!isPrimitive(x)) &&
                     (x.activate instanceof Function);
+            }
  No newline at end of file

src/test/ts/mock/config.ts +2 -2

             config()
                 .register("bar", import("./Bar"))
-                .register("box", import("./Box"))
+                .register("box", import("./Box"), "service");
-                .register("foo", import("./Foo"), "Foo");
+                //.register("foo", import("./Foo"), "Foo");

src/test/ts/tests/ContainerTests.ts +14 -3

             import { Foo } from "../mock/Foo";
             import { Bar } from "../mock/Bar";
             import { isNull } from "../safe";
-            import { Descriptor } from "../di/interfaces";
+            import { Box } from "ts/mock/Box";
             test("Container register/resolve tests", async t => {
-                const container = new Container();
+                const container = new Container<{
+                    "bla-bla": string;
+                    "connection": string;
+                    "dbParams": {
+                        timeout: number;
+                        connection: string;
+                    }
+                }>();
                 const connection1 = "db://localhost";
             test("Container configure/resolve tests", async t => {
-                const container = new Container();
+                const container = new Container<{
+                    foo: Foo;
+                    box: Bar;
+                    bar: Bar;
+                }>();
                 await container.configure({
                     foo: {

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