@spinajs/di 1.0.18 → 1.2.7

package/lib/array.d.ts

@@ -1,5 +1,9 @@
-/// <reference path="../typings/array.d.ts" />
 import { Class } from './types';
+declare global {
+    interface ArrayConstructor {
+        ofType<T>(type: Class<T>): TypedArray<T>;
+    }
+}
 export declare class TypedArray<R> extends Array<R> {
     Type: Class<R>;
     constructor(Type: Class<R>);

package/lib/array.js

@@ -1,6 +1,4 @@
 "use strict";
-// tslint:disable-next-line: no-reference
-/// <reference path="./../typings/array.d.ts" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedArray = void 0;
 class TypedArray extends Array {
@@ -10,7 +8,6 @@ class TypedArray extends Array {
     }
 }
 exports.TypedArray = TypedArray;
-// tslint:disable-next-line: only-arrow-functions
 Array.ofType = function (type) {
     return new TypedArray(type);
 };

package/lib/array.js.map

@@ -1 +1 @@
-{"version":3,"file":"array.js","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":";AAAA,yCAAyC;AACzC,gDAAgD;;;AAIhD,MAAa,UAAc,SAAQ,KAAQ;IACzC,YAAmB,IAAc;QAC/B,KAAK,EAAE,CAAC;QADS,SAAI,GAAJ,IAAI,CAAU;IAEjC,CAAC;CACF;AAJD,gCAIC;AAED,iDAAiD;AACjD,KAAK,CAAC,MAAM,GAAG,UAAY,IAAc;IACvC,OAAO,IAAI,UAAU,CAAI,IAAI,CAAC,CAAC;AACjC,CAAC,CAAC"}
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":";;;AAOA,MAAa,UAAc,SAAQ,KAAQ;IACzC,YAAmB,IAAc;QAC/B,KAAK,EAAE,CAAC;QADS,SAAI,GAAJ,IAAI,CAAU;IAEjC,CAAC;CACF;AAJD,gCAIC;AAED,KAAK,CAAC,MAAM,GAAG,UAAa,IAAc;IACxC,OAAO,IAAI,UAAU,CAAI,IAAI,CAAC,CAAC;AACjC,CAAC,CAAC"}

package/lib/binder.d.ts

@@ -0,0 +1,26 @@
+import { IBind, IContainer, ResolvableObject } from './interfaces';
+import { Class, Factory } from './types';
+export declare class Binder<T> implements IBind {
+    private implementation;
+    private container;
+    private isFactory;
+    private isConstructor;
+    constructor(implementation: Class<T> | Factory<T> | ResolvableObject, container: IContainer);
+    as<T>(type: string | Class<T>): this;
+    /**
+     * Add plain value to container. If value exists, it overrides content in  container cache
+     *
+     * @param type - name of added value
+     * @returns
+     */
+    asValue(type: string): this;
+    /**
+     * Add value as array entry, and push to array if already value exists.
+     * Usefull if for eg. user wants to add multiple values and not override its contents.
+     *
+     * @param type - name / or type to add
+     */
+    asArrayValue(type: string): this;
+    asSelf(): this;
+    singleInstance(): this;
+}

package/lib/binder.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Binder = void 0;
+const exceptions_1 = require("./exceptions");
+const decorators_1 = require("./decorators");
+const enums_1 = require("./enums");
+const helpers_1 = require("./helpers");
+const _1 = require(".");
+class Binder {
+    constructor(implementation, container) {
+        this.implementation = implementation;
+        this.container = container;
+        this.isFactory = (0, helpers_1.isFactory)(implementation);
+        this.isConstructor = (0, _1.isConstructor)(implementation);
+    }
+    as(type) {
+        this.container.Registry.register(type, this.implementation);
+        return this;
+    }
+    /**
+     * Add plain value to container. If value exists, it overrides content in  container cache
+     *
+     * @param type - name of added value
+     * @returns
+     */
+    asValue(type) {
+        this.container.Cache.add(type, this.implementation);
+        return this;
+    }
+    /**
+     * Add value as array entry, and push to array if already value exists.
+     * Usefull if for eg. user wants to add multiple values and not override its contents.
+     *
+     * @param type - name / or type to add
+     */
+    asArrayValue(type) {
+        if (this.container.Cache.has(type)) {
+            this.container.Cache.get(type).push(this.implementation);
+        }
+        else {
+            this.container.Cache.add(type, [this.implementation]);
+        }
+        return this;
+    }
+    asSelf() {
+        if (!this.isConstructor || this.isFactory) {
+            throw new exceptions_1.BindException('cannot register as self non class');
+        }
+        // we can safly cast to any, we checked params earlier
+        this.container.Registry.register(this.implementation, this.implementation);
+        return this;
+    }
+    singleInstance() {
+        const descriptor = {
+            inject: [],
+            resolver: enums_1.ResolveType.Singleton,
+        };
+        if (this.isFactory || !this.isConstructor) {
+            throw new exceptions_1.BindException('Cannot bind factory function as singleton.');
+        }
+        else {
+            this.implementation[`${decorators_1.DI_DESCRIPTION_SYMBOL}`] = descriptor;
+        }
+        return this;
+    }
+}
+exports.Binder = Binder;
+//# sourceMappingURL=binder.js.map

package/lib/binder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binder.js","sourceRoot":"","sources":["../src/binder.ts"],"names":[],"mappings":";;;AAAA,6CAA6C;AAC7C,6CAAqD;AACrD,mCAAsC;AACtC,uCAAsC;AAGtC,wBAAkC;AAElC,MAAa,MAAM;IAIjB,YAAoB,cAAwD,EAAU,SAAqB;QAAvF,mBAAc,GAAd,cAAc,CAA0C;QAAU,cAAS,GAAT,SAAS,CAAY;QACzG,IAAI,CAAC,SAAS,GAAG,IAAA,mBAAS,EAAC,cAAc,CAAC,CAAC;QAC3C,IAAI,CAAC,aAAa,GAAG,IAAA,gBAAa,EAAC,cAAc,CAAC,CAAC;IACrD,CAAC;IAED,EAAE,CAAI,IAAuB;QAC3B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC5D,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,IAAY;QAClB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,IAAY;QACvB,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YACjC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAW,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SACrE;aAAM;YACL,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;SACvD;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,SAAS,EAAE;YACzC,MAAM,IAAI,0BAAa,CAAC,mCAAmC,CAAC,CAAC;SAC9D;QAED,sDAAsD;QACtD,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,cAAqB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAClF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,cAAc;QACZ,MAAM,UAAU,GAA+B;YAC7C,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,mBAAW,CAAC,SAAS;SAChC,CAAC;QAEF,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACzC,MAAM,IAAI,0BAAa,CAAC,4CAA4C,CAAC,CAAC;SACvE;aAAM;YACJ,IAAI,CAAC,cAAsB,CAAC,GAAG,kCAAqB,EAAE,CAAC,GAAG,UAAU,CAAC;SACvE;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AA9DD,wBA8DC"}

package/lib/container-cache.d.ts

@@ -0,0 +1,12 @@
+import { TypedArray } from './array';
+import { IContainer } from './interfaces';
+import { Class } from './types';
+export declare class ContainerCache {
+    private container;
+    private cache;
+    constructor(container: IContainer);
+    add(key: string | Class<any> | object, instance: any): void;
+    has(key: string | Class<any> | object | TypedArray<any>, parent?: boolean): boolean;
+    get(key: string | Class<any> | TypedArray<any>, parent?: boolean): any;
+    clear(): void;
+}

package/lib/container-cache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerCache = void 0;
+const helpers_1 = require("./helpers");
+class ContainerCache {
+    constructor(container) {
+        this.container = container;
+        this.cache = new Map();
+        // add to cache container
+        // so we can inject container if needed
+        this.add(container, container);
+    }
+    add(key, instance) {
+        const tName = (0, helpers_1.getTypeName)(key);
+        if (this.has(key)) {
+            if (this.cache.get(tName).indexOf(instance) === -1) {
+                this.cache.get(tName).push(instance);
+            }
+        }
+        else {
+            this.cache.set(tName, [instance]);
+        }
+    }
+    has(key, parent) {
+        if (this.cache.has((0, helpers_1.getTypeName)(key))) {
+            return true;
+        }
+        if (parent && this.container.Parent) {
+            return this.container.Parent.Cache.has(key, parent);
+        }
+        return false;
+    }
+    get(key, parent) {
+        const tName = (0, helpers_1.getTypeName)(key);
+        if (this.cache.has(tName)) {
+            return this.cache.get(tName);
+        }
+        if (parent && this.container.Parent) {
+            return this.container.Parent.Cache.get(key, parent);
+        }
+        return [];
+    }
+    clear() {
+        this.cache.clear();
+        this.add(this.container, this.container);
+    }
+}
+exports.ContainerCache = ContainerCache;
+//# sourceMappingURL=container-cache.js.map

package/lib/container-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-cache.js","sourceRoot":"","sources":["../src/container-cache.ts"],"names":[],"mappings":";;;AACA,uCAAwC;AAIxC,MAAa,cAAc;IAGzB,YAAoB,SAAqB;QAArB,cAAS,GAAT,SAAS,CAAY;QACvC,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,EAAiB,CAAC;QAEtC,yBAAyB;QACzB,uCAAuC;QACvC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IACjC,CAAC;IAEM,GAAG,CAAC,GAAiC,EAAE,QAAa;QACzD,MAAM,KAAK,GAAG,IAAA,qBAAW,EAAC,GAAG,CAAC,CAAC;QAE/B,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACjB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;gBAClD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aACtC;SACF;aAAM;YACL,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;SACnC;IACH,CAAC;IAEM,GAAG,CAAC,GAAmD,EAAE,MAAgB;QAC9E,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAA,qBAAW,EAAC,GAAG,CAAC,CAAC,EAAE;YACpC,OAAO,IAAI,CAAC;SACb;QAED,IAAI,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YACnC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;SACrD;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,GAAG,CAAC,GAA0C,EAAE,MAAgB;QACrE,MAAM,KAAK,GAAG,IAAA,qBAAW,EAAC,GAAG,CAAC,CAAC;QAE/B,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACzB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;SAC9B;QAED,IAAI,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YACnC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;SACrD;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;CACF;AArDD,wCAqDC"}

package/lib/container.d.ts

@@ -1,20 +1,22 @@
+/// <reference types="node" />
 import 'reflect-metadata';
 import { TypedArray } from './array';
-import { IBind, IContainer, AsyncModule } from './interfaces';
+import { IBind, IContainer, IInjectDescriptor, IResolvedInjection, IToInject, AsyncModule, ResolvableObject } from './interfaces';
 import { Class, Factory } from './types';
+import { EventEmitter } from 'events';
+import { Registry } from './registry';
+import { ContainerCache } from './container-cache';
 /**
  * Dependency injection container implementation
  */
-export declare class Container implements IContainer {
+export declare class Container extends EventEmitter implements IContainer {
     /**
      * Handles information about what is registered as what
      * eg. that class IConfiguration should be resolved as DatabaseConfiguration etc.
-     * @access private
      */
     private registry;
     /**
      * Singletons cache, objects that should be created only once are stored here.
-     * @access private
      */
     private cache;
     /**
@@ -24,19 +26,28 @@ export declare class Container implements IContainer {
     /**
      * Returns container cache - map object with resolved classes as singletons
      */
-    get Cache(): Map<string, any>;
-    get Registry(): Map<string, Array<Class<any>>>;
+    get Cache(): ContainerCache;
+    get Registry(): Registry;
+    get Parent(): IContainer;
     constructor(parent?: IContainer);
     /**
-     * Clears container registry and cache.
+     * Clears container registry and cache. shorthand for container.clearCache() && container.clearRegistry()
      */
     clear(): void;
+    /**
+     * clears container registered types information
+     */
+    clearCache(): void;
+    /**
+     * Clears container resolved types
+     */
+    clearRegistry(): void;
     /**
      * Register class/interface to DI.
      * @param type - interface object to register
-     * @throws { InvalidArgument } if type is null or undefined
+     * @throws {@link InvalidArgument} if type is null or undefined
      */
-    register<T>(implementation: Class<T> | Factory<T>): IBind;
+    register<T>(implementation: Class<T> | Factory<T> | ResolvableObject): IBind;
     /**
      * Creates child DI container.
      *
@@ -45,52 +56,75 @@ export declare class Container implements IContainer {
     /**
      * Gets already resolved services. Works only for singleton classes.
      *
+     * Do not try to get service by factory func, it will always return null.
+     * If you somehowe want to cache instances created by factory functions,
+     * factory itself should do that somehow and end user should always resolve by
+     * assigned type
+     *
      * @param serviceName - name of service to get
-     * @returns { null | T} - null if no service has been resolved at given name
+     * @returns null if no service has been resolved at given name
      */
     get<T>(service: TypedArray<T>, parent?: boolean): T[];
     get<T>(service: string | Class<T>, parent?: boolean): T;
-    getRegistered<T>(service: string | Class<T>, parent?: boolean): Array<Class<any>>;
     hasRegistered<T>(service: Class<T> | string, parent?: boolean): boolean;
     /**
      * Checks if service is already resolved and exists in container cache.
      * NOTE: check is only valid for classes that are singletons.
      *
      * @param service - service name or class to check
-     * @returns { boolean } - true if service instance already exists, otherwise false.
-     * @throws { InvalidArgument } when service is null or empty
+     * @returns true if service instance already exists, otherwise false.
+     * @throws {@link InvalidArgument} when service is null or empty
      */
-    has<T>(service: string | Class<T>, parent?: boolean): boolean;
+    isResolved<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): boolean;
     /**
      *
      * Resolves single instance of class
      *
-     * @param type what to resolve, can be class definition or factory function
-     * @param options options passed to constructor / factory
+     * @param type - what to resolve, can be class definition or factory function
+     * @param options - options passed to constructor / factory
      */
-    resolve<T>(type: string, options?: any[], check?: boolean): T;
+    resolve<T>(type: string, options?: unknown[], check?: boolean): T;
     resolve<T>(type: string, check?: boolean): T;
     /**
      *
      * Resolves single instance of class
      *
-     * @param type what to resolve, can be class definition or factory function
-     * @param options options passed to constructor / factory
+     * @param type - what to resolve, can be class definition or factory function
+     * @param options - options passed to constructor / factory
      */
-    resolve<T>(type: Class<T>, options?: any[], check?: boolean): T extends AsyncModule ? Promise<T> : T;
+    resolve<T>(type: Class<T>, options?: unknown[], check?: boolean): T extends AsyncModule ? Promise<T> : T;
     resolve<T>(type: Class<T>, check?: boolean): T extends AsyncModule ? Promise<T> : T;
     /**
      *
      * Resolves all instances of given class. Under single definition can be registered multiple implementations.
      *
-     * @param type typed array of specified type. since TS does not expose array metadata and type its uses TypedArray<T> consctruct
-     * @param options options passed to constructor / factory
+     * @param type - typed array of specified type. since TS does not expose array metadata and type its uses TypedArray<T> consctruct
+     * @param options - options passed to constructor / factory
      * @param check - strict check if serivice is registered in container before resolving. Default behavior is to not check and resolve
      *
      */
-    resolve<T>(type: TypedArray<T>, options?: any[], check?: boolean): T extends AsyncModule ? Promise<T[]> : T[];
+    resolve<T>(type: TypedArray<T>, options?: unknown[], check?: boolean): T extends AsyncModule ? Promise<T[]> : T[];
     resolve<T>(type: TypedArray<T>, check?: boolean): T extends AsyncModule ? Promise<T[]> : T[];
+    getRegisteredTypes<T>(service: string | Class<T> | TypedArray<T>, parent?: boolean): (Class<unknown> | Factory<unknown>)[];
     private resolveType;
-    private _hasRegisteredType;
-    private registerSelf;
+    protected getNewInstance(typeToCreate: Class<unknown> | Factory<unknown>, a?: IResolvedInjection[], options?: unknown[]): Promise<unknown> | unknown;
+    hasRegisteredType<T>(source: Class<T> | string, type: Class<T> | string | TypedArray<T>, parent?: boolean): boolean;
+    protected resolveDependencies(toInject: IToInject<unknown>[]): (Promise<{
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    }> | {
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: unknown;
+    })[] | Promise<({
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: any;
+    } | {
+        autoinject: boolean;
+        autoinjectKey: string;
+        instance: unknown;
+    })[]>;
+    protected extractDescriptor(type: Class<unknown>): IInjectDescriptor<unknown>;
 }