@adaas/a-concept 0.1.56 → 0.1.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "description": "A-Concept is a framework to build new Applications within or outside the ADAAS ecosystem. This framework is designed to be modular structure regardless environment and program goal.",
   "license": "Apache-2.0",
   "main": "./dist/index.cjs",

package/src/global/A-Dependency/A-Dependency-Flat.decorator.ts

@@ -0,0 +1,68 @@
+
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Meta } from "@adaas/a-concept/global/A-Meta/A-Meta.class";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.constants";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.constants";
+import { A_TypeGuards } from "@adaas/a-concept/helpers/A_TypeGuards.helper";
+import { A_TYPES__A_InjectDecorator_Meta, A_TYPES__InjectableTargets } from "../A-Inject/A-Inject.types";
+import { A_TYPES__A_Dependency_FlatDecoratorReturn } from "./A-Dependency.types";
+import { A_DependencyError } from "./A-Dependency.error";
+import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+
+
+/**
+ * Should indicate which dependency is required
+ */
+export function A_Dependency_Flat(): A_TYPES__A_Dependency_FlatDecoratorReturn {
+
+    return function (
+        target: A_TYPES__InjectableTargets,
+        methodName: string | symbol | undefined,
+        parameterIndex: number
+    ) {
+        // for Error handling purposes
+        const componentName = A_CommonHelper.getComponentName(target)
+
+        if (!A_TypeGuards.isTargetAvailableForInjection(target)) {
+            throw new A_DependencyError(
+                A_DependencyError.InvalidDependencyTarget,
+                `A-Dependency cannot be used on the target of type ${typeof target} (${componentName})`
+            );
+        }
+
+        // determine the method name or 'constructor' for constructor injections
+        const method = methodName ? String(methodName) : 'constructor';
+        let metaKey;
+
+        switch (true) {
+            case A_TypeGuards.isComponentConstructor(target) || A_TypeGuards.isComponentInstance(target):
+                metaKey = A_TYPES__ComponentMetaKey.INJECTIONS;
+                break;
+
+            case A_TypeGuards.isContainerInstance(target):
+                metaKey = A_TYPES__ContainerMetaKey.INJECTIONS;
+                break;
+        }
+
+        // get existing meta or create a new one
+        const existedMeta = A_Context.meta(target).get(metaKey) || new A_Meta();
+        // get existing injections for the method or create a new array
+        const paramsArray: A_TYPES__A_InjectDecorator_Meta = existedMeta.get(method) || [];
+
+        // set the parameter injection info
+        paramsArray[parameterIndex] = {
+            ...(paramsArray[parameterIndex] || {}),
+            flat: true,
+        }
+        // save back the updated injections array
+        existedMeta.set(method, paramsArray);
+
+        // save back the updated meta info
+        A_Context
+            .meta(target)
+            .set(
+                metaKey,
+                existedMeta
+            );
+    }
+}

package/src/global/A-Dependency/A-Dependency.class.ts

@@ -1,4 +1,5 @@
 import { A_Dependency_Default } from "./A-Dependency-Default.decorator";
+import { A_Dependency_Flat } from "./A-Dependency-Flat.decorator";
 import { A_Dependency_Load } from "./A-Dependency-Load.decorator";
 import { A_Dependency_Parent } from "./A-Dependency-Parent.decorator";
 import { A_Dependency_Require } from "./A-Dependency-Require.decorator";
@@ -41,6 +42,16 @@ export class A_Dependency {
         return A_Dependency_Parent;
     }
 
+    /**
+     * Allows to indicate that the dependency should be resolved in a flat manner
+     * Only in the same scope, without going up to parent scopes
+     * 
+     * @returns 
+     */
+    static get Flat(): typeof A_Dependency_Flat {
+        return A_Dependency_Flat;
+    }
+
     protected _name: string;
 
     /**

package/src/global/A-Dependency/A-Dependency.types.ts

@@ -32,4 +32,10 @@ export type A_TYPES__A_Dependency_ParentDecoratorReturn<T = any> = (
     target: T,
     propertyKey: string | symbol | undefined,
     parameterIndex: number
+) => void
+
+export type A_TYPES__A_Dependency_FlatDecoratorReturn<T = any> = (
+    target: T,
+    propertyKey: string | symbol | undefined,
+    parameterIndex: number
 ) => void

package/src/global/A-Inject/A-Inject.types.ts

@@ -39,6 +39,7 @@ export type A_TYPES__A_InjectDecorator_Meta = Array<{
     parent?: {
         layerOffset?: number
     },
+    flat?: boolean
     create?: boolean
     instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>,
 }>;

package/src/global/A-Scope/A-Scope.class.ts

@@ -200,6 +200,35 @@ export class A_Scope<
         initializer.call(this, param1, param2);
     }
 
+    /**
+     * Generator to iterate through all parent scopes
+     */
+    *parents(): Generator<A_Scope> {
+        let currentParent = this._parent;
+        while (currentParent) {
+            yield currentParent;
+            currentParent = currentParent._parent;
+        }
+    }
+
+    /**
+     * This method is used to retrieve a parent scope at a specific level
+     * 
+     * @param level 
+     * @returns 
+     */
+    parentAtLevel(level: number): A_Scope | undefined {
+        let currentParent = this._parent;
+        let currentLevel = 0;
+        while (currentParent) {
+            if (currentLevel === level) {
+                return currentParent;
+            }
+            currentParent = currentParent._parent;
+            currentLevel++;
+        }
+        return undefined;
+    }
 
 
     /**
@@ -461,7 +490,7 @@ export class A_Scope<
     ): boolean {
 
         let found = this.hasFlat(ctor as any);
-        
+
         if (!found && !!this._parent)
             try {
                 return this._parent.has(ctor as any);

package/src/global/A-Stage/A-Stage.class.ts

@@ -140,29 +140,38 @@ export class A_Stage {
                             return this._feature;
 
                         default: {
-                            const { target, require, create, defaultArgs, parent } = arg;
+                            const { target, require, create, defaultArgs, parent, flat } = arg;
 
 
                             let dependency;
                             let targetScope = scope;
 
-                            if (parent && typeof parent.layerOffset === 'number') {
-                                let parentScope = scope.parent;
 
-                                let offset = parent.layerOffset;
-
-                                while (offset < -1 && parentScope) {
-                                    parentScope = parentScope.parent;
-                                    offset++;
+                            switch (true) {
+                                // 1) Flat resolution
+                                case flat: {
+                                    dependency = targetScope.resolveFlat(target);
+                                    break;
                                 }
-
-                                if (parentScope) {
-                                    dependency = parentScope.resolve(target);
-                                    targetScope = parentScope;
+                                // 2) Parent resolution
+                                case parent && typeof parent.layerOffset === 'number': {
+                                    const targetParent = targetScope.parentAtLevel(parent.layerOffset);
+                                    if (!targetParent) {
+                                        throw new A_StageError(
+                                            A_StageError.ArgumentsResolutionError,
+                                            `Unable to resolve parent scope at layer offset ${parent.layerOffset} for argument ${A_CommonHelper.getComponentName(arg.target)} for stage ${this.name} in scope ${scope.name}`
+                                        );
+                                    }
+                                    dependency = targetParent.resolve(target);
+                                    targetScope = targetParent;
+
+                                    break;
+                                }
+                                // 3) Normal resolution
+                                default: {
+                                    dependency = targetScope.resolve(target);
+                                    break;
                                 }
-
-                            } else {
-                                dependency = targetScope.resolve(target);
                             }
 
                             if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {