@spinajs/di 2.0.180 → 2.0.181

package/lib/cjs/decorators.js

@@ -1,304 +1,304 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Singleton = exports.PerInstanceCheck = exports.PerInstance = exports.NewInstance = exports.PerChildInstance = exports.LazyInject = exports.Autoinject = exports.Inject = exports.Injectable = exports.AddDependency = exports.AddDependencyForProperty = exports.DI_DESCRIPTION_SYMBOL = void 0;
-const enums_js_1 = require("./enums.js");
-const DI = __importStar(require("./root.js"));
-const helpers_js_1 = require("./helpers.js");
-exports.DI_DESCRIPTION_SYMBOL = '__DI_INJECTION_DESCRIPTOR__';
-function AddDependencyForProperty(callback) {
-    return (target, propertyKey, indexOrDescriptor) => {
-        let descriptor = Reflect.getOwnMetadata(exports.DI_DESCRIPTION_SYMBOL, target.constructor);
-        if (!descriptor) {
-            descriptor = {
-                inject: [],
-                resolver: enums_js_1.ResolveType.Singleton,
-            };
-            Reflect.defineMetadata(exports.DI_DESCRIPTION_SYMBOL, descriptor, target.constructor);
-        }
-        if (callback) {
-            callback(descriptor, target, propertyKey, indexOrDescriptor);
-        }
-    };
-}
-exports.AddDependencyForProperty = AddDependencyForProperty;
-function AddDependency(callback) {
-    return (target, propertyKey, indexOrDescriptor) => {
-        let descriptor = Reflect.getOwnMetadata(exports.DI_DESCRIPTION_SYMBOL, target);
-        if (!descriptor) {
-            descriptor = {
-                inject: [],
-                resolver: enums_js_1.ResolveType.Singleton,
-            };
-            Reflect.defineMetadata(exports.DI_DESCRIPTION_SYMBOL, descriptor, target);
-        }
-        if (callback) {
-            callback(descriptor, target, propertyKey, indexOrDescriptor);
-        }
-    };
-}
-exports.AddDependency = AddDependency;
-/**
- *
- * Class with this decorator is automatically registered in DI container an can be resolved.
- * NOTE: we dont need to register class before resolving. Injectable decorator is mainly used in extensions & plugins
- * to register implementation that can be resolved by framework or other parts without knowing about specific implementations eg.
- * avaible database drivers.
- *
- * @param as - register class in DI container as something else.
- *
- * @example
- * ```typescript
- *
- * @Injectable(OrmDriver)
- * class MysqlOrmDriver{
- *
- * // implementation ...
- * }
- *
- *
- * // somewhere else in code
- * const avaibleDrivers = DI.resolve(Array.of(OrmDriver));
- *
- *
- * ```
- *
- */
-function Injectable(as) {
-    return (target) => {
-        if (as) {
-            DI.register(target).as(as);
-        }
-        else {
-            DI.register(target).asSelf();
-        }
-    };
-}
-exports.Injectable = Injectable;
-/**
- * Sets dependency injection guidelines - what to inject for specified class. If multiple instances are registered at specified type,
- * only first one is resolved and injected
- * @param args - what to inject - class definitions
- * @example
- * ```javascript
- *
- * @Inject(Bar)
- * class Foo{
- *
- *  @Inject(Bar)
- *  barInstance : Bar;
- *
- *  constructor(bar : Bar){
- *      // bar is injected when Foo is created via DI container
- *      this.barInstance = bar;
- *  }
- *
- *  someFunc(){
- *
- *    this._barInstance.doSmth();
- *  }
- * }
- *
- * ```
- */
-function Inject(...args) {
-    return AddDependency((descriptor) => {
-        for (const a of args) {
-            // avoid injecting duplicates
-            if (!descriptor.inject.find((i) => {
-                if ((0, helpers_js_1.isTypedArray)(i)) {
-                    if ((0, helpers_js_1.isTypedArray)(a)) {
-                        return i.Type === a.Type;
-                    }
-                    else {
-                        return i.Type === a;
-                    }
-                }
-                else {
-                    return i.inject === a;
-                }
-            })) {
-                descriptor.inject.push({
-                    autoinject: false,
-                    autoinjectKey: '',
-                    inject: a,
-                    mapFunc: null,
-                });
-            }
-        }
-    });
-}
-exports.Inject = Inject;
-/**
- * Automatically injects dependency based on reflected property type. Uses experimental typescript reflection api
- * If decorator is applied to array property all registered type instances are injected, otherwise only first / only that exists
- *
- * @param injectType - when injecting array of some type, type must be explicitly provided. Typescript reflection cant reflect declared array types
- * @param mapFunc - when injecting array we sometimes need services mapped by some kind of key, so later we dont need to search o(n) elements for specific service, but reference by key/name
- * @example
- * ```javascript
- * class Foo{
- *
- *  @Autoinject
- *  barInstance : Bar;
- *
- *  constructor(){
- *      // ....
- *  }
- *
- *  someFunc(){
- *
- *    // automatically injected dependency is avaible now
- *    this.barInstance.doSmth();
- *  }
- * }
- *
- * ```
- */
-function Autoinject(typeOrOptions, options) {
-    return AddDependencyForProperty((descriptor, target, propertyKey) => {
-        let type = Reflect.getMetadata('design:type', target, propertyKey);
-        const isArray = type.name === 'Array' || type.name === 'Map';
-        let opt = options;
-        if ((0, helpers_js_1.isConstructor)(typeOrOptions)) {
-            if (isArray && !typeOrOptions) {
-                throw new Error('you must provide inject type when injecting array');
-            }
-            type = typeOrOptions;
-        }
-        else {
-            opt = typeOrOptions;
-        }
-        descriptor.inject.push({
-            autoinject: true,
-            autoinjectKey: propertyKey,
-            inject: isArray ? Array.ofType(typeOrOptions) : type,
-            mapFunc: opt?.mapFunc,
-            options: opt?.options,
-        });
-    });
-}
-exports.Autoinject = Autoinject;
-/**
- * Lazy injects service to object. Use only with class properties
- *
- * @param service - class or name of service to inject
- *
- * @example
- * ```javascript
- *
- * class Foo{
- * ...
- *
- *  @LazyInject(Bar)
- *  _barInstance : Bar; // _barInstance is not yet resolved
- *
- *  someFunc(){
- *    // barInstance is resolved only when first accessed
- *    this._barInstance.doSmth();
- *  }
- * }
- *
- * ```
- */
-function LazyInject(service) {
-    return (target, key) => {
-        const type = Reflect.getMetadata('design:type', target, key);
-        // property getter
-        const getter = () => {
-            if (!service) {
-                return DI.resolve(type);
-            }
-            else {
-                if (typeof service === 'string') {
-                    return DI.get(service);
-                }
-                else {
-                    return DI.resolve(service);
-                }
-            }
-        };
-        // Create new property with getter and setter
-        Object.defineProperty(target, key, {
-            get: getter,
-        });
-    };
-}
-exports.LazyInject = LazyInject;
-/**
- * Per child instance injection decorator - object is resolved once per container - child containers have own instances.
- */
-function PerChildInstance() {
-    return AddDependency((descriptor) => {
-        descriptor.resolver = enums_js_1.ResolveType.PerChildContainer;
-    });
-}
-exports.PerChildInstance = PerChildInstance;
-/**
- * NewInstance injection decorator - every time class is injected - its created from scratch
- */
-function NewInstance() {
-    return AddDependency((descriptor) => {
-        descriptor.resolver = enums_js_1.ResolveType.NewInstance;
-    });
-}
-exports.NewInstance = NewInstance;
-/**
- * If we have multiple registered types at one base type
- * we can resolve only one by default. Per instance means, that
- * we can resolve all types registered at base type once. Limitaiton is
- * that, you should call resolve not on base type, but on target type.
- *
- * In comparison, Singleton flag means that only one instance can be resolved
- * for base class
- */
-function PerInstance() {
-    return AddDependency((descriptor) => {
-        descriptor.resolver = enums_js_1.ResolveType.PerInstance;
-    });
-}
-exports.PerInstance = PerInstance;
-/**
- *
- * Before resolve, check function on all resolved instances of given type is called with creation options
- * It is used for ensuring that for eg. only one instance of service with provided
- * options is resolved, but allow to create with other option set
- *
- * @returns
- */
-function PerInstanceCheck() {
-    return AddDependency((descriptor) => {
-        descriptor.resolver = enums_js_1.ResolveType.PerInstanceCheck;
-    });
-}
-exports.PerInstanceCheck = PerInstanceCheck;
-/**
- * Singleton injection decorator - every time class is resolved - its created only once globally ( even in child DI containers )
- */
-function Singleton() {
-    return AddDependency();
-}
-exports.Singleton = Singleton;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Singleton = exports.PerInstanceCheck = exports.PerInstance = exports.NewInstance = exports.PerChildInstance = exports.LazyInject = exports.Autoinject = exports.Inject = exports.Injectable = exports.AddDependency = exports.AddDependencyForProperty = exports.DI_DESCRIPTION_SYMBOL = void 0;
+const enums_js_1 = require("./enums.js");
+const DI = __importStar(require("./root.js"));
+const helpers_js_1 = require("./helpers.js");
+exports.DI_DESCRIPTION_SYMBOL = '__DI_INJECTION_DESCRIPTOR__';
+function AddDependencyForProperty(callback) {
+    return (target, propertyKey, indexOrDescriptor) => {
+        let descriptor = Reflect.getOwnMetadata(exports.DI_DESCRIPTION_SYMBOL, target.constructor);
+        if (!descriptor) {
+            descriptor = {
+                inject: [],
+                resolver: enums_js_1.ResolveType.Singleton,
+            };
+            Reflect.defineMetadata(exports.DI_DESCRIPTION_SYMBOL, descriptor, target.constructor);
+        }
+        if (callback) {
+            callback(descriptor, target, propertyKey, indexOrDescriptor);
+        }
+    };
+}
+exports.AddDependencyForProperty = AddDependencyForProperty;
+function AddDependency(callback) {
+    return (target, propertyKey, indexOrDescriptor) => {
+        let descriptor = Reflect.getOwnMetadata(exports.DI_DESCRIPTION_SYMBOL, target);
+        if (!descriptor) {
+            descriptor = {
+                inject: [],
+                resolver: enums_js_1.ResolveType.Singleton,
+            };
+            Reflect.defineMetadata(exports.DI_DESCRIPTION_SYMBOL, descriptor, target);
+        }
+        if (callback) {
+            callback(descriptor, target, propertyKey, indexOrDescriptor);
+        }
+    };
+}
+exports.AddDependency = AddDependency;
+/**
+ *
+ * Class with this decorator is automatically registered in DI container an can be resolved.
+ * NOTE: we dont need to register class before resolving. Injectable decorator is mainly used in extensions & plugins
+ * to register implementation that can be resolved by framework or other parts without knowing about specific implementations eg.
+ * avaible database drivers.
+ *
+ * @param as - register class in DI container as something else.
+ *
+ * @example
+ * ```typescript
+ *
+ * @Injectable(OrmDriver)
+ * class MysqlOrmDriver{
+ *
+ * // implementation ...
+ * }
+ *
+ *
+ * // somewhere else in code
+ * const avaibleDrivers = DI.resolve(Array.of(OrmDriver));
+ *
+ *
+ * ```
+ *
+ */
+function Injectable(as) {
+    return (target) => {
+        if (as) {
+            DI.register(target).as(as);
+        }
+        else {
+            DI.register(target).asSelf();
+        }
+    };
+}
+exports.Injectable = Injectable;
+/**
+ * Sets dependency injection guidelines - what to inject for specified class. If multiple instances are registered at specified type,
+ * only first one is resolved and injected
+ * @param args - what to inject - class definitions
+ * @example
+ * ```javascript
+ *
+ * @Inject(Bar)
+ * class Foo{
+ *
+ *  @Inject(Bar)
+ *  barInstance : Bar;
+ *
+ *  constructor(bar : Bar){
+ *      // bar is injected when Foo is created via DI container
+ *      this.barInstance = bar;
+ *  }
+ *
+ *  someFunc(){
+ *
+ *    this._barInstance.doSmth();
+ *  }
+ * }
+ *
+ * ```
+ */
+function Inject(...args) {
+    return AddDependency((descriptor) => {
+        for (const a of args) {
+            // avoid injecting duplicates
+            if (!descriptor.inject.find((i) => {
+                if ((0, helpers_js_1.isTypedArray)(i)) {
+                    if ((0, helpers_js_1.isTypedArray)(a)) {
+                        return i.Type === a.Type;
+                    }
+                    else {
+                        return i.Type === a;
+                    }
+                }
+                else {
+                    return i.inject === a;
+                }
+            })) {
+                descriptor.inject.push({
+                    autoinject: false,
+                    autoinjectKey: '',
+                    inject: a,
+                    mapFunc: null,
+                });
+            }
+        }
+    });
+}
+exports.Inject = Inject;
+/**
+ * Automatically injects dependency based on reflected property type. Uses experimental typescript reflection api
+ * If decorator is applied to array property all registered type instances are injected, otherwise only first / only that exists
+ *
+ * @param injectType - when injecting array of some type, type must be explicitly provided. Typescript reflection cant reflect declared array types
+ * @param mapFunc - when injecting array we sometimes need services mapped by some kind of key, so later we dont need to search o(n) elements for specific service, but reference by key/name
+ * @example
+ * ```javascript
+ * class Foo{
+ *
+ *  @Autoinject
+ *  barInstance : Bar;
+ *
+ *  constructor(){
+ *      // ....
+ *  }
+ *
+ *  someFunc(){
+ *
+ *    // automatically injected dependency is avaible now
+ *    this.barInstance.doSmth();
+ *  }
+ * }
+ *
+ * ```
+ */
+function Autoinject(typeOrOptions, options) {
+    return AddDependencyForProperty((descriptor, target, propertyKey) => {
+        let type = Reflect.getMetadata('design:type', target, propertyKey);
+        const isArray = type.name === 'Array' || type.name === 'Map';
+        let opt = options;
+        if ((0, helpers_js_1.isConstructor)(typeOrOptions)) {
+            if (isArray && !typeOrOptions) {
+                throw new Error('you must provide inject type when injecting array');
+            }
+            type = typeOrOptions;
+        }
+        else {
+            opt = typeOrOptions;
+        }
+        descriptor.inject.push({
+            autoinject: true,
+            autoinjectKey: propertyKey,
+            inject: isArray ? Array.ofType(typeOrOptions) : type,
+            mapFunc: opt?.mapFunc,
+            options: opt?.options,
+        });
+    });
+}
+exports.Autoinject = Autoinject;
+/**
+ * Lazy injects service to object. Use only with class properties
+ *
+ * @param service - class or name of service to inject
+ *
+ * @example
+ * ```javascript
+ *
+ * class Foo{
+ * ...
+ *
+ *  @LazyInject(Bar)
+ *  _barInstance : Bar; // _barInstance is not yet resolved
+ *
+ *  someFunc(){
+ *    // barInstance is resolved only when first accessed
+ *    this._barInstance.doSmth();
+ *  }
+ * }
+ *
+ * ```
+ */
+function LazyInject(service) {
+    return (target, key) => {
+        const type = Reflect.getMetadata('design:type', target, key);
+        // property getter
+        const getter = () => {
+            if (!service) {
+                return DI.resolve(type);
+            }
+            else {
+                if (typeof service === 'string') {
+                    return DI.get(service);
+                }
+                else {
+                    return DI.resolve(service);
+                }
+            }
+        };
+        // Create new property with getter and setter
+        Object.defineProperty(target, key, {
+            get: getter,
+        });
+    };
+}
+exports.LazyInject = LazyInject;
+/**
+ * Per child instance injection decorator - object is resolved once per container - child containers have own instances.
+ */
+function PerChildInstance() {
+    return AddDependency((descriptor) => {
+        descriptor.resolver = enums_js_1.ResolveType.PerChildContainer;
+    });
+}
+exports.PerChildInstance = PerChildInstance;
+/**
+ * NewInstance injection decorator - every time class is injected - its created from scratch
+ */
+function NewInstance() {
+    return AddDependency((descriptor) => {
+        descriptor.resolver = enums_js_1.ResolveType.NewInstance;
+    });
+}
+exports.NewInstance = NewInstance;
+/**
+ * If we have multiple registered types at one base type
+ * we can resolve only one by default. Per instance means, that
+ * we can resolve all types registered at base type once. Limitaiton is
+ * that, you should call resolve not on base type, but on target type.
+ *
+ * In comparison, Singleton flag means that only one instance can be resolved
+ * for base class
+ */
+function PerInstance() {
+    return AddDependency((descriptor) => {
+        descriptor.resolver = enums_js_1.ResolveType.PerInstance;
+    });
+}
+exports.PerInstance = PerInstance;
+/**
+ *
+ * Before resolve, check function on all resolved instances of given type is called with creation options
+ * It is used for ensuring that for eg. only one instance of service with provided
+ * options is resolved, but allow to create with other option set
+ *
+ * @returns
+ */
+function PerInstanceCheck() {
+    return AddDependency((descriptor) => {
+        descriptor.resolver = enums_js_1.ResolveType.PerInstanceCheck;
+    });
+}
+exports.PerInstanceCheck = PerInstanceCheck;
+/**
+ * Singleton injection decorator - every time class is resolved - its created only once globally ( even in child DI containers )
+ */
+function Singleton() {
+    return AddDependency();
+}
+exports.Singleton = Singleton;
 //# sourceMappingURL=decorators.js.map

package/lib/cjs/enums.d.ts

@@ -1,32 +1,32 @@
-/**
- * How to resolve class
- */
-export declare enum ResolveType {
-    /**
-     * Application wise single instance. Default behaviour
-     */
-    Singleton = 0,
-    /**
-     * New instance every time is requested
-     */
-    NewInstance = 1,
-    /**
-     * New instance per child DI container.
-     */
-    PerChildContainer = 2,
-    /**
-     * Singleton per target type
-     *
-     * eg. if we have multiple registered types at one base type
-     * we can resolve any of it once
-     *
-     * In comparison, Singleton flag means that only one instance can be resolved
-     * for base class
-     */
-    PerInstance = 3,
-    /**
-     * Only one instance with given name can exists of the same service
-     */
-    PerInstanceCheck = 4
-}
+/**
+ * How to resolve class
+ */
+export declare enum ResolveType {
+    /**
+     * Application wise single instance. Default behaviour
+     */
+    Singleton = 0,
+    /**
+     * New instance every time is requested
+     */
+    NewInstance = 1,
+    /**
+     * New instance per child DI container.
+     */
+    PerChildContainer = 2,
+    /**
+     * Singleton per target type
+     *
+     * eg. if we have multiple registered types at one base type
+     * we can resolve any of it once
+     *
+     * In comparison, Singleton flag means that only one instance can be resolved
+     * for base class
+     */
+    PerInstance = 3,
+    /**
+     * Only one instance with given name can exists of the same service
+     */
+    PerInstanceCheck = 4
+}
 //# sourceMappingURL=enums.d.ts.map