@adaas/a-concept 0.1.58 → 0.1.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-concept",
-  "version": "0.1.58",
+  "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

@@ -933,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
@@ -963,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
@@ -1460,7 +1469,7 @@ export class A_Scope<
                                 // 2) Parent resolution
                                 case parent && typeof parent.layerOffset === 'number': {
                                     const targetParent = this.parentOffset(parent.layerOffset);
-                                    if(!targetParent) {
+                                    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}`

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'
+        ]);
+
+    })
 });