@adaas/a-concept 0.1.57 → 0.1.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "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-Scope/A-Scope.class.ts

@@ -214,20 +214,31 @@ export class A_Scope<
     /**
      * This method is used to retrieve a parent scope at a specific level
      * 
+     * [!] Note that if the level is out of bounds, undefined is returned
+     * [!!] Uses negative values for levels (e.g. -1 for immediate parent, -2 for grandparent, etc.)
+     * 
      * @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++;
+    parentOffset(
+        /**
+         * Level of the parent scope to retrieve
+         * 
+         * Examples:
+         * - level 0 - immediate parent
+         * - level -1 - grandparent
+         * - level -2 - great-grandparent
+         */
+        layerOffset: number
+    ): A_Scope | undefined {
+        let parentScope = this.parent;
+
+        while (layerOffset < -1 && parentScope) {
+            parentScope = parentScope.parent;
+            layerOffset++;
         }
-        return undefined;
+
+        return parentScope;
     }
 
 
@@ -1425,7 +1436,7 @@ export class A_Scope<
                         const componentName = A_CommonHelper.getComponentName(arg.target)
 
                         if ('instructions' in arg && !!arg.instructions) {
-                            const { target, instructions } = arg
+                            const { target, parent, flat, instructions } = arg
                             const dependency = this.resolve(target as any, instructions);
                             if (!dependency)
                                 throw new A_ScopeError(
@@ -1435,17 +1446,47 @@ export class A_Scope<
 
                             return dependency;
                         } else {
-                            const { target, require, create, defaultArgs } = arg;
+                            const { target, require, create, defaultArgs, parent, flat, } = arg;
+
+                            let dependency;
+
+                            // ----------------- Resolution Strategies -----------------
+                            switch (true) {
+                                // 1) Flat resolution
+                                case flat: {
+                                    dependency = this.resolveFlat(target);
+                                    break;
+                                }
+                                // 2) Parent resolution
+                                case parent && typeof parent.layerOffset === 'number': {
+                                    const targetParent = this.parentOffset(parent.layerOffset);
+                                    if(!targetParent) {
+                                        throw new A_ScopeError(
+                                            A_ScopeError.ResolutionError,
+                                            `Unable to resolve parent scope at offset ${parent.layerOffset} for dependency ${componentName} for component ${component.name} in scope ${this.name}`
+                                        );
+                                    }
+                                    dependency = targetParent.resolve(target);
+
+                                    break;
+                                }
+                                // 3) Normal resolution
+                                default: {
+                                    dependency = this.resolve(target);
+                                    break;
+                                }
+                            }
 
-                            let dependency = this.resolve(target as any);
+                            // ----------------- Post-Resolution Actions -----------------
 
+                            // 1) Create default instance in case when allowed
                             if (create && !dependency && A_TypeGuards.isAllowedForDependencyDefaultCreation(target)) {
-                                const newDependency = new target(...defaultArgs);
+                                dependency = new target(...defaultArgs);
 
-                                this.register(newDependency);
-                                return newDependency;
+                                this.register(dependency);
                             }
 
+                            // 2) Throw error in case when required but not resolved
                             if (require && !dependency) {
                                 throw new A_ScopeError(
                                     A_ScopeError.ResolutionError,
@@ -1453,6 +1494,8 @@ export class A_Scope<
                                 );
                             }
 
+
+                            //  Finally, return the dependency (either resolved or undefined)
                             return dependency;
                         }
                     });

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

@@ -155,7 +155,7 @@ export class A_Stage {
                                 }
                                 // 2) Parent resolution
                                 case parent && typeof parent.layerOffset === 'number': {
-                                    const targetParent = targetScope.parentAtLevel(parent.layerOffset);
+                                    const targetParent = targetScope.parentOffset(parent.layerOffset);
                                     if (!targetParent) {
                                         throw new A_StageError(
                                             A_StageError.ArgumentsResolutionError,

package/tests/A-Dependency.test.ts

@@ -89,5 +89,203 @@ describe('A-Dependency tests', () => {
         expect(instance!.component).toBeInstanceOf(MyCustomEntity);
         expect(instance!.component.foo).toBe('bar');
     });
+    it('Should resolve only dependency on the same level with Flat directive', async () => {
+        class ParentComponent extends A_Component { }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Flat()
+                @A_Inject(ParentComponent) public parentComponent?: ParentComponent,
+            ) {
+                super();
+
+            }
+        }
+
+        const parentScope = new A_Scope({ components: [ParentComponent] });
+        const childScope = new A_Scope({ components: [ChildComponent] }, { parent: parentScope });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.parentComponent).toBeUndefined();
+    });
+
+    it('Should resolve create dependency with Create directive', async () => {
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Default({ name: 'Entity A' })
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+        const childScope = new A_Scope({ components: [ChildComponent], entities: [MyEntity_A] });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.myEntityA).toBeInstanceOf(MyEntity_A);
+        expect(instance!.myEntityA.name).toBe('Entity A');
+    });
+    it('Should resolve Parent entity if it exists, even if Default provided', async () => {
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Default({ name: 'Child Entity' })
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+        const parentScope = new A_Scope({ entities: [new MyEntity_A({ name: 'Parent Entity' })] });
+        const childScope = new A_Scope({ components: [ChildComponent] }, { parent: parentScope });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.myEntityA).toBeInstanceOf(MyEntity_A);
+        expect(instance!.myEntityA.name).toBe('Parent Entity');
+    });
+    it('Should resolve dependencies properly with combination of Directives', async () => {
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Flat()
+                @A_Dependency.Default({ name: 'Child Entity' })
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+        const parentScope = new A_Scope({ entities: [new MyEntity_A({ name: 'Parent Entity' })] });
+        const childScope = new A_Scope({ components: [ChildComponent] }, { parent: parentScope });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.myEntityA).toBeInstanceOf(MyEntity_A);
+        expect(instance!.myEntityA.name).toBe('Child Entity');
+    })
+    it('Should resolve dependency from parent scope with  Parent Directive', async () => {
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Parent()
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+        const parentScope = new A_Scope({
+            name: 'Parent Scope',
+            entities: [new MyEntity_A({ name: 'Parent Entity' })]
+        });
+        const childScope = new A_Scope({
+            name: 'Child Scope',
+            components: [ChildComponent],
+            entities: [new MyEntity_A({ name: 'Child Entity' })]
+        }, { parent: parentScope });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.myEntityA).toBeInstanceOf(MyEntity_A);
+        expect(instance!.myEntityA.name).toBe('Parent Entity');
+    });
+    it('Should resolve dependency from parent scope with  Parent Directive and offset', async () => {
+
+        class MyEntity_A extends A_Entity<{ name: string }> {
+            name!: string;
+
+            fromNew(newEntity: { name: string; }): void {
+                super.fromNew(newEntity);
+                this.name = newEntity.name;
+            }
+        }
+
+        class ChildComponent extends A_Component {
+            constructor(
+                @A_Dependency.Parent(-2)
+                @A_Inject(MyEntity_A) public myEntityA: MyEntity_A,
+            ) {
+                super();
+
+            }
+        }
+
+        const grandparentScope = new A_Scope({
+            name: 'Grandparent Scope',
+            entities: [new MyEntity_A({ name: 'Grandparent Entity' })]
+        });
+        
+        const parentScope = new A_Scope({
+            name: 'Parent Scope',
+            entities: [new MyEntity_A({ name: 'Parent Entity' })]
+        }, { parent: grandparentScope });
+
+        const childScope = new A_Scope({
+            name: 'Child Scope',
+            components: [ChildComponent],
+            entities: [new MyEntity_A({ name: 'Child Entity' })]
+        }, { parent: parentScope });
+
+        const instance = childScope.resolve(ChildComponent);
+
+        expect(instance).toBeDefined();
+        expect(instance).toBeInstanceOf(ChildComponent);
+        expect(instance!.myEntityA).toBeInstanceOf(MyEntity_A);
+        expect(instance!.myEntityA.name).toBe('Grandparent Entity');
+    });
 
 });