Import other modules into monorepo

src/di/decorator/injection.ts

@@ -0,0 +1,151 @@
+import 'reflect-metadata'
+import {collect, Collection} from "../../util";
+import {
+    DependencyKey,
+    DependencyRequirement,
+    DEPENDENCY_KEYS_METADATA_KEY,
+    DEPENDENCY_KEYS_PROPERTY_METADATA_KEY,
+    isInstantiable,
+    InjectionType,
+    DEPENDENCY_KEYS_SERVICE_TYPE_KEY,
+    PropertyDependency,
+} from "../types";
+import {Container} from "../Container";
+
+/**
+ * Get a collection of dependency requirements for the given target object.
+ * @param {Object} target
+ * @return Collection<DependencyRequirement>
+ */
+function initDependencyMetadata(target: Object): Collection<DependencyRequirement> {
+    const paramTypes = Reflect.getMetadata('design:paramtypes', target)
+    return collect<DependencyKey>(paramTypes).map<DependencyRequirement>((type, idx) => {
+        return {
+            paramIndex: idx,
+            key: type,
+            overridden: false,
+        }
+    })
+}
+
+/**
+ * Class decorator that marks a class as injectable. When this is applied, dependency
+ * metadata for the constructors params is resolved and stored in metadata.
+ * @constructor
+ */
+export const Injectable = (): ClassDecorator => {
+    return (target) => {
+        const meta = initDependencyMetadata(target)
+        const existing = Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target)
+        const new_meta = new Collection<DependencyRequirement>()
+
+        if ( existing ) {
+            const max_new = meta.max('paramIndex')
+            const max_existing = existing.max('paramIndex')
+            for ( let i = 0; i <= Math.max(max_new, max_existing); i++ ) {
+                const existing_dr = existing.firstWhere('paramIndex', '=', i)
+                const new_dr = meta.firstWhere('paramIndex', '=', i)
+
+                if ( existing_dr && !new_dr ) {
+                    new_meta.push(existing_dr)
+                } else if ( new_dr && !existing_dr ) {
+                    new_meta.push(new_dr)
+                } else if ( new_dr && existing_dr ) {
+                    if ( existing_dr.overridden ) {
+                        new_meta.push(existing_dr)
+                    } else {
+                        new_meta.push(new_dr)
+                    }
+                }
+            }
+        } else {
+            new_meta.concat(meta)
+        }
+
+        Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, new_meta, target)
+    }
+}
+
+/**
+ * Mark the given class property to be injected by the container.
+ * If a `key` is specified, that DependencyKey will be injected.
+ * Otherwise, the DependencyKey is inferred from the type annotation.
+ * @param key
+ * @constructor
+ */
+export const Inject = (key?: DependencyKey): PropertyDecorator => {
+    return (target, property) => {
+        let propertyMetadata = Reflect.getMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, target?.constructor || target) as Collection<PropertyDependency>
+        if ( !propertyMetadata ) {
+            propertyMetadata = new Collection<PropertyDependency>()
+            Reflect.defineMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, propertyMetadata, target?.constructor || target)
+        }
+
+        const type = Reflect.getMetadata('design:type', target, property)
+        if ( !key && type ) key = type
+
+        if ( key ) {
+            const existing = propertyMetadata.firstWhere('property', '=', property)
+            if ( existing ) {
+                existing.key = key
+            } else {
+                propertyMetadata.push({ property, key })
+            }
+        }
+
+        Reflect.defineMetadata(DEPENDENCY_KEYS_PROPERTY_METADATA_KEY, propertyMetadata, target?.constructor || target)
+    }
+}
+
+/**
+ * Parameter decorator to manually mark a parameter as being an injection target on injectable
+ * classes. This can be used to override the dependency key of a given parameter.
+ * @param {DependencyKey} key
+ * @constructor
+ */
+export const InjectParam = (key: DependencyKey): ParameterDecorator => {
+    return (target, property, paramIndex) => {
+        if ( !Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target) ) {
+            Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, initDependencyMetadata(target), target)
+        }
+
+        const meta = Reflect.getMetadata(DEPENDENCY_KEYS_METADATA_KEY, target)
+        const req = meta.firstWhere('paramIndex', '=', paramIndex)
+        if ( req ) {
+            req.key = key
+            req.overridden = true
+        } else {
+            meta.push({
+                paramIndex,
+                key,
+                overridden: true
+            })
+        }
+
+        Reflect.defineMetadata(DEPENDENCY_KEYS_METADATA_KEY, meta, target)
+    }
+}
+
+/**
+ * Class decorator that registers the class as a singleton instance in the global container.
+ * @param {string} name
+ */
+export const Singleton = (name?: string): ClassDecorator => {
+    return (target) => {
+        if ( isInstantiable(target) ) {
+            const injectionType: InjectionType = {
+                type: name ? 'named' : 'singleton',
+                ...(name ? { name } : {})
+            }
+
+            Reflect.defineMetadata(DEPENDENCY_KEYS_SERVICE_TYPE_KEY, injectionType, target)
+            Injectable()(target)
+
+            if ( name ) {
+                Container.getContainer().registerNamed(name, target)
+            } else {
+                Container.getContainer().register(target)
+            }
+        }
+    }
+}