@adaas/a-concept 0.1.17 → 0.1.19

package/tests/A-Abstraction.test.ts

@@ -3,198 +3,202 @@ import './test.setup'
 import { A_Concept } from '@adaas/a-concept/global/A-Concept/A-Concept.class';
 import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
+import { A_Scope } from '@adaas/a-concept/global/A-Scope/A-Scope.class';
+import { A_TYPES__ConceptAbstractions } from '@adaas/a-concept/global/A-Concept/A-Concept.constants';
+import { A_Inject } from '@adaas/a-concept/global/A-Inject/A-Inject.decorator';
+import { A_Feature } from '@adaas/a-concept/global/A-Feature/A-Feature.class';
 
 jest.retryTimes(0);
 
 describe('A-Abstraction Tests', () => {
-    it('It should be possible to extend abstraction on A-Component level', async () => {
-        class MyComponent extends A_Component {
-            private _test: number = 0
+    // it('It should be possible to extend abstraction on A-Component level', async () => {
+    //     class MyComponent extends A_Component {
+    //         private _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
+    // });
+
+    // it('It should be possible to extend abstraction on A-Container level', async () => {
+    //     class MyContainer extends A_Container {
+    //         private _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
+    // });
+
+
+    // it('It should be possible to proceed Concept Abstraction', async () => {
+    //     class MyComponent extends A_Component {
+    //         _test2: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test2++;
+    //         }
+    //     }
+
+    //     class MyContainer extends A_Container {
+    //         _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
+
+    //     const myContainer = new MyContainer({
+    //         name: 'MyContainer',
+    //         components: [MyComponent]
+    //     });
+
+    //     const testConcept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [myContainer]
+    //     });
+
+    //     await testConcept.load();
+
+
+    //     const resolvedComponent = myContainer.scope.resolve(MyComponent);
+
+    //     expect(resolvedComponent).toBeInstanceOf(MyComponent);
+    //     expect(myContainer._test).toBe(1);
+    //     expect(resolvedComponent._test2).toBe(1);
+
+    // });
+    // it('Should allow to extend abstraction with multiple containers', async () => {
+    //     A_Context.reset();
+
+    //     class MyContainerA extends A_Container {
+    //         _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
+    //     class MyContainerB extends A_Container {
+    //         _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
+
+    //     const containerA = new MyContainerA({ name: 'ContainerA' });
+    //     const containerB = new MyContainerB({ name: 'ContainerB' });
+
+    //     const concept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [
+    //             containerA,
+    //             containerB
+    //         ]
+    //     });
+
+    //     await concept.load();
+
+    //     expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
+    //     expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
+
+    //     expect(containerA._test).toBe(1);
+    //     expect(containerB._test).toBe(1);
+
+    // })
+    // it('Should allow to define an async abstraction extension', async () => {
+    //     A_Context.reset();
+
+    //     class MyContainerA extends A_Container {
+    //         _test: number = 0
+
+    //         @A_Concept.Load()
+    //         async myMethod() {
+    //             this._test = 5;
+    //         }
+    //     }
+    //     class MyContainerB extends A_Container {
+    //         _test: number = 0
+
+    //         @A_Concept.Load()
+    //         myMethod() {
+    //             this._test++;
+    //         }
+    //     }
 
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
-    });
-
-    it('It should be possible to extend abstraction on A-Container level', async () => {
-        class MyContainer extends A_Container {
-            private _test: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
-    });
-
-
-    it('It should be possible to proceed Concept Abstraction', async () => {
-        class MyComponent extends A_Component {
-            _test2: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test2++;
-            }
-        }
-
-        class MyContainer extends A_Container {
-            _test: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
-
-        const myContainer = new MyContainer({
-            name: 'MyContainer',
-            components: [MyComponent]
-        });
-
-        const testConcept = new A_Concept({
-            name: 'TestConcept',
-            containers: [myContainer]
-        });
-
-        await testConcept.load();
-
-
-        const resolvedComponent = myContainer.scope.resolve(MyComponent);
-
-        expect(resolvedComponent).toBeInstanceOf(MyComponent);
-        expect(myContainer._test).toBe(1);
-        expect(resolvedComponent._test2).toBe(1);
-
-    });
-    it('Should allow to extend abstraction with multiple containers', async () => {
-        A_Context.reset();
-
-        class MyContainerA extends A_Container {
-            _test: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
-        class MyContainerB extends A_Container {
-            _test: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
-
-        const containerA = new MyContainerA({ name: 'ContainerA' });
-        const containerB = new MyContainerB({ name: 'ContainerB' });
-
-        const concept = new A_Concept({
-            name: 'TestConcept',
-            containers: [
-                containerA,
-                containerB
-            ]
-        });
-
-        await concept.load();
-
-        expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
-        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
-
-        expect(containerA._test).toBe(1);
-        expect(containerB._test).toBe(1);
-
-    })
-    it('Should allow to define an async abstraction extension', async () => {
-        A_Context.reset();
-
-        class MyContainerA extends A_Container {
-            _test: number = 0
-
-            @A_Concept.Load()
-            async myMethod() {
-                this._test = 5;
-            }
-        }
-        class MyContainerB extends A_Container {
-            _test: number = 0
-
-            @A_Concept.Load()
-            myMethod() {
-                this._test++;
-            }
-        }
 
+    //     const containerA = new MyContainerA({ name: 'ContainerA' });
+    //     const containerB = new MyContainerB({ name: 'ContainerB' });
+
+    //     const concept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [
+    //             containerA,
+    //             containerB
+    //         ]
+    //     });
+
+    //     await concept.load();
+
+    //     expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
+    //     expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
+
+    //     expect(containerA._test).toBe(5);
+    //     expect(containerB._test).toBe(1);
+    // })
+    // it('Should execute abstraction in a proper order', async () => {
+    //     A_Context.reset();
+
+    //     const order: string[] = [];
+
+    //     class MyContainerA extends A_Container {
+
+    //         @A_Concept.Load()
+    //         async step1() {
+    //             order.push('step1');
+    //         }
 
-        const containerA = new MyContainerA({ name: 'ContainerA' });
-        const containerB = new MyContainerB({ name: 'ContainerB' });
-
-        const concept = new A_Concept({
-            name: 'TestConcept',
-            containers: [
-                containerA,
-                containerB
-            ]
-        });
-
-        await concept.load();
-
-        expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
-        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);
-
-        expect(containerA._test).toBe(5);
-        expect(containerB._test).toBe(1);
-    })
-    it('Should execute abstraction in a proper order', async () => {
-        A_Context.reset();
-
-        const order: string[] = [];
-
-        class MyContainerA extends A_Container {
-
-            @A_Concept.Load()
-            async step1() {
-                order.push('step1');
-            }
-
-            @A_Concept.Load()
-            async step2() {
-                order.push('step2');
-            }
-        }
-        class MyContainerB extends A_Container {
-
-            @A_Concept.Load()
-            async step3() {
-                order.push('step3');
-            }
-
-            @A_Concept.Load()
-            async step4() {
-                order.push('step4');
-            }
-        }
-
-
-        const containerA = new MyContainerA({ name: 'ContainerA' });
-        const containerB = new MyContainerB({ name: 'ContainerB' });
-
-        const concept = new A_Concept({
-            name: 'TestConcept',
-            containers: [
-                containerA,
-                containerB
-            ]
-        });
-
-        await concept.load();
-
-        expect(order).toEqual(['step1', 'step2', 'step3', 'step4']);
-    })
+    //         @A_Concept.Load()
+    //         async step2() {
+    //             order.push('step2');
+    //         }
+    //     }
+    //     class MyContainerB extends A_Container {
+
+    //         @A_Concept.Load()
+    //         async step3() {
+    //             order.push('step3');
+    //         }
+
+    //         @A_Concept.Load()
+    //         async step4() {
+    //             order.push('step4');
+    //         }
+    //     }
+
+
+    //     const containerA = new MyContainerA({ name: 'ContainerA' });
+    //     const containerB = new MyContainerB({ name: 'ContainerB' });
+
+    //     const concept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [
+    //             containerA,
+    //             containerB
+    //         ]
+    //     });
+
+    //     await concept.load();
+
+    //     expect(order).toEqual(['step1', 'step2', 'step3', 'step4']);
+    // })
     it('Should execute abstraction in order with dependencies', async () => {
         A_Context.reset();
 
@@ -203,14 +207,20 @@ describe('A-Abstraction Tests', () => {
         class MyContainerA extends A_Container {
 
             @A_Concept.Load()
-            async step1() {
+            async step1(
+                @A_Inject(A_Feature) feature: A_Feature,
+            ) {
+                // console.log(`Executing step1 in stage: ${feature.stage?.name}`);
                 order.push('step1');
             }
 
             @A_Concept.Load({
                 after: ['MyComponentA.step3']
             })
-            async step2() {
+            async step2(
+                @A_Inject(A_Feature) feature: A_Feature,
+            ) {
+                // console.log(`Executing step2 in stage: ${feature.stage?.name}`);
                 order.push('step2');
             }
         }
@@ -218,7 +228,10 @@ describe('A-Abstraction Tests', () => {
         class MyComponentA extends A_Component {
 
             @A_Concept.Load()
-            async step3() {
+            async step3(
+                @A_Inject(A_Feature) feature: A_Feature,
+            ) {
+                // console.log(`Executing step3 in stage: ${feature.stage?.name}`);
                 order.push('step3');
             }
         }
@@ -227,14 +240,20 @@ describe('A-Abstraction Tests', () => {
         class MyContainerB extends A_Container {
 
             @A_Concept.Load()
-            async step4() {
+            async step4(
+                @A_Inject(A_Feature) feature: A_Feature,
+            ) {
+                // console.log(`Executing step4 in stage: ${feature.stage?.name}`);
                 order.push('step4');
             }
 
             @A_Concept.Load({
                 before: ['MyContainerB.step4']
             })
-            async step5() {
+            async step5(
+                @A_Inject(A_Feature) feature: A_Feature,
+            ) {
+                // console.log(`Executing step5 in stage: ${feature.stage?.name}`);
                 order.push('step5');
             }
         }
@@ -255,4 +274,69 @@ describe('A-Abstraction Tests', () => {
 
         expect(order).toEqual(['step1', 'step3', 'step2', 'step5', 'step4']);
     })
+    // it('Should inherit abstraction extensions', async () => {
+    //     const executionOrder: string[] = [];
+
+    //     // 1) create a base component with some abstraction
+    //     class My_Component extends A_Component {
+
+    //         @A_Concept.Load()
+    //         async feature1() {
+    //             executionOrder.push('stepOne');
+    //         }
+    //     }
+
+
+    //     class My_Child_Component extends My_Component { }
+
+    //     const concept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [
+    //             new A_Container({
+    //                 name: 'TestContainer',
+    //                 components: [My_Child_Component],
+    //             })
+    //         ]
+    //     });
+
+    //     await concept.load();
+
+    //     expect(executionOrder).toEqual(['stepOne']);
+    // });
+    // it('Should allow to override abstraction extensions', async () => {
+    //     const executionOrder: string[] = [];
+
+    //     // 1) create a base component with some abstraction
+    //     class My_Component extends A_Component {
+
+    //         @A_Concept.Load()
+    //         async feature1() {
+    //             executionOrder.push('stepOne');
+    //         }
+    //     }
+
+
+    //     class My_Child_Component extends My_Component {
+    //         @A_Concept.Load()
+    //         async feature1() {
+    //             // do nothing
+    //             executionOrder.push('stepTwo');
+
+    //         }
+    //     }
+
+    //     const concept = new A_Concept({
+    //         name: 'TestConcept',
+    //         containers: [
+    //             new A_Container({
+    //                 name: 'TestContainer',
+    //                 components: [My_Child_Component],
+    //             })
+    //         ]
+    //     });
+
+    //     await concept.load();
+
+    //     expect(executionOrder).toEqual(['stepTwo']);
+    // });
 });

package/tests/A-Feature.test.ts

@@ -6,6 +6,7 @@ import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
 import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_Caller } from '@adaas/a-concept/global/A-Caller/A_Caller.class';
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
+import { A_TYPES__ComponentMetaKey } from '@adaas/a-concept/global/A-Component/A-Component.constants';
 
 jest.retryTimes(0);
 
@@ -253,7 +254,7 @@ describe('A-Feature tests', () => {
 
             @A_Feature.Define()
             async feature2() {
-               await this.call('feature2');
+                await this.call('feature2');
             }
 
             @A_Feature.Extend({
@@ -281,4 +282,86 @@ describe('A-Feature tests', () => {
         // 5) check the results
         expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
     });
+    it('Should inherit feature definitions & extensions', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
+
+            @A_Feature.Define({ invoke: false })
+            async feature1() {
+                executionOrder.push('stepOne');
+
+                await this.call('feature1');
+            }
+
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepTwo');
+            }
+        }
+
+
+        class My_Child_Component extends My_Component { }
+
+
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
+
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Child_Component);
+        expect(myComponent).toBeInstanceOf(My_Child_Component);
+
+        await myComponent.feature1();
+
+        expect(executionOrder).toEqual(['stepOne', 'stepTwo']);
+    });
+
+    it('Should allow override feature extension', async () => {
+        const executionOrder: string[] = [];
+
+        // 1) create a base component with some feature
+        class My_Component extends A_Component {
+
+            @A_Feature.Define({ invoke: true })
+            async feature1() {
+                executionOrder.push('stepOne');
+            }
+
+            @A_Feature.Extend({
+                name: 'feature1',
+            })
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepTwo');
+            }
+        }
+
+
+        class My_Child_Component extends My_Component {
+
+            async feature1Extension(
+                @A_Inject(A_Scope) scope: A_Scope
+            ) {
+                executionOrder.push('stepThree');
+            }
+        }
+
+
+        // 2) create a running scope 
+        const scope = new A_Scope({ name: 'TestScope', components: [My_Child_Component] });
+
+        // 3) create an instance of the component from the scope
+        const myComponent = scope.resolve(My_Child_Component);
+        expect(myComponent).toBeInstanceOf(My_Child_Component);
+
+        await myComponent.feature1();
+
+        expect(executionOrder).toEqual(['stepOne', 'stepThree']);
+    });
 });