@adaas/a-concept 0.1.57 → 0.1.59

package/package.json

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

@@ -714,7 +714,10 @@ export class A_Context {
             .filter(c => c !== A_Component && c !== A_Container && c !== A_Entity)
             .map(c => `${c.name}.${name}`);
 
-        // const callName = `${component.constructor.name}.${name}`;
+
+
+        // const callNames = [`${component.constructor.name}.${name}`];
+        // const callNames = [`BaseComponent.testFeature`];
 
         const steps: A_TYPES__A_StageStep[] = [];
 

package/src/global/A-Feature/A-Feature-Extend.decorator.ts

@@ -153,7 +153,6 @@ export function A_Feature_Extend(
             .meta(target)
             .get(metaKey);
 
-
         // Get the existed metadata or create a new one
         const meta = A_Context
             .meta(target)
@@ -177,6 +176,23 @@ export function A_Feature_Extend(
             ...(existedMeta.get(targetRegexp.source) || [])
         ];
 
+        //  ensure that other regexps are preserved
+        for (const [key, handlers] of existedMeta.entries()) {
+
+            const indexInAnother = handlers.findIndex(item => item.handler === propertyKey);
+
+            //  if the same handler exists in another regexp, remove it
+            if (key !== targetRegexp.source && indexInAnother !== -1) {
+                handlers.splice(indexInAnother, 1);
+                //  if no handlers left for this regexp, remove the regexp entry
+                if (handlers.length === 0) {
+                    existedMeta.delete(key);
+                } else {
+                    existedMeta.set(key, handlers);
+                }
+            }
+        }
+
         const existedIndex = existedMetaValue.findIndex(item => item.handler === propertyKey);
 
         const extension = {
@@ -197,8 +213,7 @@ export function A_Feature_Extend(
             existedMetaValue.push(extension);
         }
 
-        // Add the new method to the metadata
-        existedMetaValue.push();
+
 
         // Set the metadata of the method to define a custom Feature with name
         existedMeta.set(targetRegexp.source, existedMetaValue);

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;
     }
 
 
@@ -922,7 +933,16 @@ export class A_Scope<
          */
         entity: A_TYPES__Entity_Constructor<T>
     ): T | undefined
-
+    resolve<T extends A_Entity>(
+        /**
+         * Provide an entity constructor to resolve its instance or an array of instances from the scope
+         */
+        entity: A_TYPES__Entity_Constructor<T>,
+        /**
+         * Only Aseid Provided, in this case one entity will be returned
+         */
+        instructions: { query: { aseid: string | ASEID } }
+    ): T | undefined
     resolve<T extends A_Entity>(
         /**
          * Provide an entity constructor to resolve its instance or an array of instances from the scope
@@ -952,7 +972,7 @@ export class A_Scope<
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         constructorName: string
     ): T | undefined
-    // base definition
+    // ------------------------------------ base definition ------------------------------------
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         /**
          * Provide a component, fragment or entity constructor or an array of constructors to resolve its instance(s) from the scope
@@ -1425,7 +1445,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 +1455,47 @@ export class A_Scope<
 
                             return dependency;
                         } else {
-                            const { target, require, create, defaultArgs } = arg;
+                            const { target, require, create, defaultArgs, parent, flat, } = arg;
 
-                            let dependency = this.resolve(target as any);
+                            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;
+                                }
+                            }
+
+                            // ----------------- 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 +1503,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');
+    });
 
 });

package/tests/A-Feature.test.ts

@@ -666,4 +666,96 @@ describe('A-Feature tests', () => {
 
 
     });
+    it('Should override extensions meta for inherited method with the same name', async () => {
+
+        const resultChain: string[] = [];
+
+        class BaseComponent extends A_Component {
+
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [BaseComponent]
+            })
+            async test() {
+                resultChain.push('BaseComponent.test');
+            }
+
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [BaseComponent]
+            })
+            async test2() {
+                resultChain.push('BaseComponent.test2');
+            }
+        }
+
+
+        class ChildComponent_A extends BaseComponent {
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [ChildComponent_A]
+            })
+            async test() {
+                resultChain.push('ChildComponent_A.test');
+            }
+        }
+
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A] });
+
+        const extensionsMeta = A_Context.meta(ChildComponent_A).get(A_TYPES__ComponentMetaKey.EXTENSIONS)!.entries();
+
+        await testScope.resolve(ChildComponent_A)!.call('testFeature');
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test',
+            'BaseComponent.test2'
+        ]);
+    })
+
+    it('Should properly define inheritance chain of the features', async () => {
+
+        const resultChain: string[] = [];
+
+        class BaseComponent extends A_Component {
+
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [BaseComponent]
+            })
+            async test() {
+                resultChain.push('BaseComponent.test');
+            }
+        }
+
+        class ChildComponent_A extends BaseComponent {
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [ChildComponent_A]
+            })
+            async test() {
+                resultChain.push('ChildComponent_A.test');
+            }
+        }
+
+        class ChildComponent_B extends BaseComponent {
+            @A_Feature.Extend({
+                name: 'testFeature',
+                scope: [ChildComponent_B]
+            })
+            async test() {
+                resultChain.push('ChildComponent_B.test');
+            }
+        }
+
+
+        const testScope = new A_Scope({ name: 'TestScope', components: [ChildComponent_A, ChildComponent_B] });
+
+        await testScope.resolve(ChildComponent_A)!.call('testFeature');
+
+        expect(resultChain).toEqual([
+            'ChildComponent_A.test'
+        ]);
+
+    })
 });