@adaas/a-concept 0.0.64 → 0.1.1

package/tests/A-Concept.test.ts

@@ -1,8 +1,6 @@
 import './test.setup';
-
-import { A_Command } from "@adaas/a-concept/global/A-Command/A-Command.class";
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Concept } from "@adaas/a-concept/global/A-Concept/A_Concept.class";
+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_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
@@ -17,8 +15,8 @@ describe('A-Concept tests', () => {
     it('Should Allow to create a concept', async () => {
         const concept = new A_Concept({ name: 'TestConcept' });
         expect(concept).toBeInstanceOf(A_Concept);
-        expect(concept.Scope).toBeDefined();
-        expect(concept.Scope).toBeInstanceOf(A_Scope);
+        expect(concept.scope).toBeDefined();
+        expect(concept.scope).toBeInstanceOf(A_Scope);
     });
     it('Should allow to load a concept', async () => {
         const concept = new A_Concept({ name: 'TestConcept' });
@@ -36,7 +34,7 @@ describe('A-Concept tests', () => {
     it('Should allow to provide all base entities to the concept', async () => {
         A_Context.reset();
 
-        class MyCommand extends A_Command { }
+        class MyEntityA extends A_Entity { }
         class MyEntity extends A_Entity { }
         class MyComponent extends A_Component { }
         class MyContainer extends A_Container { }
@@ -44,24 +42,23 @@ describe('A-Concept tests', () => {
 
         const concept = new A_Concept({
             name: 'TestConcept',
-            commands: [MyCommand],
-            entities: [new MyEntity()],
+            entities: [new MyEntity(), MyEntityA],
             components: [MyComponent],
             containers: [new MyContainer({ name: 'test' })],
             fragments: [new MyContext({ name: 'test' })]
         });
 
 
-        expect(concept.Scope.resolveConstructor('MyCommand')).toBe(MyCommand);
-        expect(concept.Scope.resolve(MyEntity)).toBeInstanceOf(MyEntity);
-        expect(concept.Scope.resolve(MyComponent)).toBeInstanceOf(MyComponent);
-        expect(concept.Scope.resolve(MyContext)).toBeInstanceOf(MyContext);
+        expect(concept.scope.resolveConstructor('MyEntityA')).toBe(MyEntityA);
+        expect(concept.scope.resolve(MyEntity)).toBeInstanceOf(MyEntity);
+        expect(concept.scope.resolve(MyComponent)).toBeInstanceOf(MyComponent);
+        expect(concept.scope.resolve(MyContext)).toBeInstanceOf(MyContext);
     });
     it('Should allow to separate entities by containers', async () => {
         A_Context.reset();
 
-        class MyCommandA extends A_Command { }
-        class MyCommandB extends A_Command { }
+        class MyEntityA extends A_Entity { }
+        class MyEntityB extends A_Entity { }
         class MyComponentA extends A_Component { }
         class MyComponentB extends A_Component { }
         class MyContainer extends A_Container { }
@@ -69,14 +66,14 @@ describe('A-Concept tests', () => {
 
         const containerA = new MyContainer({
             name: 'test',
-            commands: [MyCommandA],
+            entities: [MyEntityA],
             components: [MyComponentA]
 
         });
 
         const containerB = new MyContainer({
             name: 'test2',
-            commands: [MyCommandB],
+            entities: [MyEntityB],
             components: [MyComponentB]
         })
 
@@ -95,18 +92,18 @@ describe('A-Concept tests', () => {
         const containerAScope = A_Context.scope(containerA)
         const containerBScope = A_Context.scope(containerB)
 
-        expect(containerAScope.resolveConstructor('MyCommandA')).toBe(MyCommandA);
+        expect(containerAScope.resolveConstructor('MyEntityA')).toBe(MyEntityA);
         expect(() => {
-            containerAScope.resolveConstructor('MyCommandB');
+            containerAScope.resolveConstructor('MyEntityB');
         }).toThrow();
 
-        expect(containerBScope.resolveConstructor('MyCommandB')).toBe(MyCommandB);
+        expect(containerBScope.resolveConstructor('MyEntityB')).toBe(MyEntityB);
         expect(() => {
-            containerBScope.resolveConstructor('MyCommandA');
+            containerBScope.resolveConstructor('MyEntityA');
         }).toThrow();
 
-        expect(concept.Scope.resolve(MyContext)).toEqual(sharedContext);
-        expect(concept.Scope.resolve(MyContext)).toEqual(sharedContext);
+        expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
+        expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
     });
 
 });

package/tests/A-Entity.test.ts

@@ -3,9 +3,9 @@ import './test.setup';
 import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
 import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
 import { A_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
-import { A_TYPES__Entity_JSON } from "@adaas/a-concept/global/A-Entity/A-Entity.types";
+import { A_TYPES__Entity_Serialized } from '@adaas/a-concept/global/A-Entity/A-Entity.types';
 import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
-import { ASEID } from "@adaas/a-utils";
+import { ASEID } from '@adaas/a-concept/global/ASEID/ASEID.class';
 
 jest.retryTimes(0);
 
@@ -17,11 +17,11 @@ describe('A-Entity tests', () => {
         const entity = new A_Entity();
 
         expect(entity.aseid).toBeInstanceOf(ASEID);
-        expect(entity.aseid.scope).toBe('core');
-        expect(entity.aseid.namespace).toBe('a-concept');
+        expect(entity.aseid.scope).toBe('root');
+        expect(entity.aseid.concept).toBe('a-concept');
 
     });
-    it('Should Allow to create an entity with overridden ASEID Scope or Namespace', async () => {
+    it('Should Allow to create an entity with overridden ASEID Scope or Concept', async () => {
         class MyEntity extends A_Entity {
             static get entity(): string {
                 return 'my-entity-test';
@@ -31,8 +31,8 @@ describe('A-Entity tests', () => {
                 return 'custom-scope';
             }
 
-            static get namespace(): string {
-                return 'custom-namespace';
+            static get concept(): string {
+                return 'custom-concept';
             }
         }
 
@@ -40,13 +40,13 @@ describe('A-Entity tests', () => {
 
         expect(entity.aseid).toBeInstanceOf(ASEID);
         expect(entity.aseid.scope).toBe('custom-scope');
-        expect(entity.aseid.namespace).toBe('custom-namespace');
+        expect(entity.aseid.concept).toBe('custom-concept');
         expect(entity.aseid.entity).toBe('my-entity-test');
 
     });
-    it('Should Allow to create an entity with overridden ASEID Scope or Namespace from ENV Variables', async () => {
-        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE] = 'env-scope';
-        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE] = 'env-namespace';
+    it('Should Allow to create an entity with overridden ASEID Scope or Concept from ENV Variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] = 'env-scope';
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] = 'env-concept';
 
         A_Context.reset();
 
@@ -54,17 +54,17 @@ describe('A-Entity tests', () => {
 
         expect(entity.aseid).toBeInstanceOf(ASEID);
         expect(entity.aseid.scope).toBe('env-scope');
-        expect(entity.aseid.namespace).toBe('env-namespace');
+        expect(entity.aseid.concept).toBe('env-concept');
 
-        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_DEFAULT_SCOPE];
-        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAMESPACE];
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE];
+        delete process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME];
 
         A_Context.reset();
     });
     it('Should Allow to create an entity from ASEID', async () => {
         const entity = new A_Entity(
             new ASEID({
-                namespace: 'default',
+                concept: 'default',
                 scope: 'default',
                 entity: 'entity-a',
                 id: Math.floor(Math.random() * 1000000000).toString(),
@@ -79,13 +79,13 @@ describe('A-Entity tests', () => {
     });
     it('Should Allow to create an entity from object', async () => {
 
-        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_Serialized> {
             foo!: string;
 
             fromNew(newEntity: { foo: string; }): void {
                 super.fromNew(newEntity);
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -105,10 +105,10 @@ describe('A-Entity tests', () => {
     });
     it('Should Allow to rewrite initializer method without changes to other methods', async () => {
 
-        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_Serialized> {
             foo!: string;
 
-            protected getInitializer(props?: string | { foo: string; } | ({ foo: string; } & A_TYPES__Entity_JSON) | ASEID | undefined): (props: any) => void | (() => void) {
+            protected getInitializer(props?: string | { foo: string; } | ({ foo: string; } & A_TYPES__Entity_Serialized) | ASEID | undefined): (props: any) => void | (() => void) {
                 if (typeof props === 'object' && props !== null && 'foo' in props) {
                     return this.fromFoo.bind(this);
                 }
@@ -123,7 +123,7 @@ describe('A-Entity tests', () => {
             fromNew(newEntity: { foo: string; }): void {
                 super.fromNew(newEntity);
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -151,12 +151,12 @@ describe('A-Entity tests', () => {
     });
     it('Should allow to serialize and deserialize an entity', async () => {
 
-        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_JSON> {
+        class MyEntity extends A_Entity<{ foo: string }, { foo: string } & A_TYPES__Entity_Serialized> {
             public foo!: string;
 
             fromNew(newEntity: { foo: string; }): void {
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -164,13 +164,13 @@ describe('A-Entity tests', () => {
                 this.foo = newEntity.foo;
             }
 
-            fromJSON(serialized: { foo: string; } & A_TYPES__Entity_JSON): void {
+            fromJSON(serialized: { foo: string; } & A_TYPES__Entity_Serialized): void {
                 this.aseid = new ASEID(serialized.aseid);
                 this.foo = serialized.foo;
                 return;
             }
 
-            toJSON(): { foo: string } & A_TYPES__Entity_JSON {
+            toJSON(): { foo: string } & A_TYPES__Entity_Serialized {
                 return {
                     ...super.toJSON(),
                     foo: this.foo,

package/tests/A-Error.test.ts

@@ -0,0 +1,129 @@
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/env.constants";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Error } from "@adaas/a-concept/global/A-Error/A_Error.class";
+import { A_CONSTANTS__ERROR_CODES, A_CONSTANTS__ERROR_DESCRIPTION } from "@adaas/a-concept/global/A-Error/A_Error.constants";
+
+jest.retryTimes(0);
+
+describe('A-Error Tests', () => {
+
+    it('It Should be possible to create an A_Error instance', async () => {
+
+        const error = new A_Error('Test error');
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Test error');
+        expect(error.code).toBe('test-error');
+        expect(error.type).toBe('a-error');
+    });
+
+    it('It Should be possible to create an A_Error instance from another error', async () => {
+
+        const originalError = new Error('Original error');
+        const error = new A_Error(originalError);
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Original error');
+        expect(error.code).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.type).toBe('a-error');
+        expect(error.originalError).toBe(originalError);
+    });
+
+    it('It Should be possible to create an A_Error instance from another A_Error', async () => {
+
+        const originalError = new A_Error('Original A_Error', 'This is the original error');
+        const error = new A_Error(originalError);
+
+        expect(error).toBeDefined();
+        expect(error).toBe(originalError);
+        expect(error.message).toBe('Original A_Error');
+        expect(error.code).toBe('original-a-error');
+        expect(error.type).toBe('a-error');
+        expect(error.description).toBe('This is the original error');
+        expect(error.originalError).toBeUndefined()
+
+    });
+    it('It Should be possible to create an A_Error instance from another A_Error with custom code and description', async () => {
+
+        const originalError = new A_Error('Original A_Error', 'This is the original error');
+        const error = new A_Error({
+            code: 'test-code',
+            message: 'Custom error message',
+            description: 'This is a custom error description',
+            originalError
+        });
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Custom error message');
+        expect(error.code).toBe('test-code');
+        expect(error.type).toBe('a-error');
+        expect(error.description).toBe('This is a custom error description');
+        expect(error.originalError).toBe(originalError);
+    });
+
+    it('It Should be possible to create an A_Error instance from another A_Error with only custom message', async () => {
+
+        const originalError = new A_Error('Original A_Error', 'This is the original error');
+
+        const error = new A_Error({
+            message: 'Custom error message',
+            originalError: originalError
+        });
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Custom error message');
+        expect(error.code).toBe('custom-error-message');
+        expect(error.type).toBe('a-error');
+        expect(error.description).toBe(A_CONSTANTS__ERROR_DESCRIPTION);
+        expect(error.originalError).toBe(originalError);
+    });
+
+    it('It Should be possible to create an inherited A_Error instance', async () => {
+        class MyError extends A_Error { }
+
+        const error = new MyError('Test inherited error');
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Test inherited error');
+        expect(error.code).toBe('test-inherited-error');
+        expect(error.type).toBe('my-error');
+    });
+
+    it('It should be possible to serialize  an A_Error instance', async () => {
+
+        const originalError = new A_Error('Original A_Error', 'This is the original error');
+        const error = new A_Error(originalError);
+
+        const serialized = error.toJSON();
+
+        expect(serialized).toBeDefined();
+        expect(serialized.message).toBe('Original A_Error');
+        expect(serialized.code).toBe('original-a-error');
+        expect(serialized.type).toBe('a-error');
+        expect(serialized.scope).toBe('root');
+        expect(serialized.description).toBe('This is the original error');
+        expect(serialized.originalError).toBeUndefined();
+    });
+
+    it('It should be possible to change scope and concept via ENV variables', async () => {
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] = 'my-project';
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] = 'my-scope';
+
+        A_Context.reset();
+
+        const error = new A_Error('Test error in custom concept and scope');
+
+        expect(error).toBeDefined();
+        expect(error.message).toBe('Test error in custom concept and scope');
+        expect(error.code).toBe('test-error-in-custom-concept-and-scope');
+        expect(error.type).toBe('a-error');
+        expect(error.aseid.concept).toBe('my-project');
+        expect(error.aseid.scope).toBe('my-scope');
+        expect(error.scope).toBe('my-scope');
+
+        // Reset env variables
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_NAME] = undefined;
+        process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_CONCEPT_ROOT_SCOPE] = undefined;
+    });
+
+});

package/tests/A-Feature.test.ts

@@ -1,45 +1,51 @@
 import './test.setup';
 
-import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Inject } from "@adaas/a-concept/global/A-Inject/A-Inject.decorator";
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
-import { A_FeatureCaller } from "@adaas/a-concept/global/A-Feature/A-FeatureCaller.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';
 
 jest.retryTimes(0);
 
 describe('A-Feature tests', () => {
-    it('Should Allow to create a feature from undefined', async () => {
+    it('Should Allow to create a feature from component', async () => {
+        const testComponent = new A_Component()
+        A_Context.root.register(testComponent);
+
         const feature = new A_Feature({
-            name: 'TestFeature',
-            scope: new A_Scope({ name: 'TestScope' }),
-            steps: [],
-            caller: new A_Component()
+            name: 'testFeature',
+            component: testComponent,
         });
+
+        expect(feature).toBeInstanceOf(A_Feature);
+        expect(feature.scope.parent).toBe(A_Context.root);
+
     });
     it('Should Allow to create a feature with steps', async () => {
+        const template = [
+            {
+                name: 'A_Component.testHandler',
+                component: A_Component,
+                handler: 'testHandler',
+            }
+        ]
+
         const feature = new A_Feature({
-            name: 'TestFeature',
-            scope: new A_Scope({ name: 'TestScope' }),
-            steps: [
-                {
-                    name: 'A_Component.testHandler',
-                    component: A_Component,
-                    handler: 'testHandler',
-                    behavior: 'sync',
-                    before: [],
-                    after: []
-                }
-            ],
-            caller: new A_Component()
+            name: 'testFeature',
+            scope: new A_Scope(),
+            template
         });
+
+        expect(feature).toBeInstanceOf(A_Feature);
     });
     it('Should be possible to execute a feature with steps as a template on the component', async () => {
         // 1) create a base component with some feature
         class MyExtendedComponent extends A_Component {
 
             async testHandler(
-                @A_Inject(A_FeatureCaller) caller: MyComponent
+                @A_Inject(A_Caller) caller: MyComponent
             ) {
                 caller.sum = 2;
             }
@@ -58,6 +64,11 @@ describe('A-Feature tests', () => {
                     behavior: 'sync',
                     before: [],
                     after: []
+                },
+                {
+                    name: 'MyExtendedComponent.testHandler',
+                    component: MyExtendedComponent,
+                    handler: 'testHandler'
                 }]
             })
             async testHandler() { }
@@ -81,12 +92,12 @@ describe('A-Feature tests', () => {
         expect(myComponent.sum).toBe(2);
 
     });
-   it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
+    it('Should be possible to execute a feature with steps as a template on the component with string component declaration', async () => {
         // 1) create a base component with some feature
         class MyExtendedComponent2 extends A_Component {
 
             async testHandler(
-                @A_Inject(A_FeatureCaller) caller: MyComponent2
+                @A_Inject(A_Caller) caller: MyComponent2
             ) {
                 caller.sum = 2;
             }
@@ -128,6 +139,4 @@ describe('A-Feature tests', () => {
         expect(myComponent.sum).toBe(2);
 
     });
-
-
 });

package/tests/A-Scope.test.ts

@@ -1,10 +1,14 @@
 import './test.setup';
 
-import { A_Command } from "@adaas/a-concept/global/A-Command/A-Command.class";
+import { A_Command } from "@adaas/a-concept/base/A-Command/A-Command.class";
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+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_Entity } from "@adaas/a-concept/global/A-Entity/A-Entity.class";
+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 { ASEID } from "@adaas/a-utils";
+import { ASEID } from '@adaas/a-concept/global/ASEID/ASEID.class';
 
 jest.retryTimes(0);
 
@@ -54,7 +58,7 @@ describe('A-Scope tests', () => {
         const parentScope = new A_Scope({ name: 'ParentScope' });
         const childScope = new A_Scope({ name: 'ChildScope' });
 
-        childScope.parent(parentScope);
+        childScope.inherit(parentScope);
 
         const component = new A_Component();
         parentScope.register(component);
@@ -68,7 +72,7 @@ describe('A-Scope tests', () => {
             public bar!: string;
             fromNew(newEntity: { bar: string; }): void {
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -92,7 +96,7 @@ describe('A-Scope tests', () => {
             public bar!: string;
             fromNew(newEntity: { bar: string; }): void {
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -116,7 +120,7 @@ describe('A-Scope tests', () => {
             public foo!: string;
             fromNew(newEntity: { foo: string; }): void {
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -137,7 +141,7 @@ describe('A-Scope tests', () => {
             public foo!: string;
             fromNew(newEntity: { foo: string; }): void {
                 this.aseid = new ASEID({
-                    namespace: 'default',
+                    concept: 'default',
                     scope: 'default',
                     entity: 'entity-a',
                     id: Math.floor(Math.random() * 1000000000).toString(),
@@ -184,7 +188,9 @@ describe('A-Scope tests', () => {
         expect(resolved3).toBe(MyEntity);
 
         expect(() => {
-            scope.resolveConstructor<MyEntity>('my__entity');
+            const res = scope.resolveConstructor<MyEntity>('mya__entity');
+
+            console.log('RESOLVED:::: ', res)
         }).toThrow();
 
         const instance = new resolved();
@@ -193,36 +199,58 @@ describe('A-Scope tests', () => {
         expect(instance.foo).toBe('bar');
 
     });
-    it('Should allow to resolve A-Command by classname', async () => {
-        class MyCommand extends A_Command<{ foo: string }, { bar: string }> {
+    it('Should allow to resolve A-Entity by classname', async () => {
+        class MyEntity extends A_Entity<{ foo: string }> {
             public foo!: string;
 
-            fromNew(newCommand: { foo: string; }): void {
-                super.fromNew(newCommand);
-                this.foo = newCommand.foo;
+            fromNew(newEntity: { foo: string; }): void {
+                super.fromNew(newEntity);
+                this.foo = newEntity.foo;
             }
 
         }
 
         const scope = new A_Scope({ name: 'TestScope' });
-        scope.register(MyCommand);
+        scope.register(MyEntity);
 
-        const resolved = scope.resolveConstructor<MyCommand>('my-command');
-        const resolved2 = scope.resolveConstructor<MyCommand>('my_command');
-        const resolved3 = scope.resolveConstructor<MyCommand>('MyCommand');
-        expect(resolved).toBe(MyCommand);
-        expect(resolved2).toBe(MyCommand);
-        expect(resolved3).toBe(MyCommand);
+        const resolved = scope.resolveConstructor<MyEntity>('my-entity');
+        const resolved2 = scope.resolveConstructor<MyEntity>('my_entity');
+        const resolved3 = scope.resolveConstructor<MyEntity>('MyEntity');
+        expect(resolved).toBe(MyEntity);
+        expect(resolved2).toBe(MyEntity);
+        expect(resolved3).toBe(MyEntity);
 
         expect(() => {
-            scope.resolveConstructor<MyCommand>('my--command');
+            scope.resolveConstructor<MyEntity>('myS-entity');
         }).toThrow();
 
 
         const instance = new resolved({ foo: 'bar' });
 
-        expect(instance).toBeInstanceOf(MyCommand);
+        expect(instance).toBeInstanceOf(MyEntity);
         expect(instance.foo).toBe('bar');
 
     });
+
+    it('Should provide a proper inheritance chain', async () => {
+        class customContainer extends A_Container { }
+        class customEntity extends A_Entity { }
+
+        const container = new customContainer({ name: 'CustomContainer', entities: [customEntity] })
+
+        const concept = new A_Concept({
+            containers: [container],
+        });
+
+        // root scope
+        expect(concept.scope).toBe(A_Context.root);
+        // root -> container.scope
+        expect(container.scope.parent).toBe(concept.scope);
+        const feature = new A_Feature({
+            name: 'test',
+            component: container
+        });
+        //  root -> container.scope -> feature.scope
+        expect(feature.scope.parent).toBe(container.scope);
+    });
 });