@adaas/a-concept 0.1.7 → 0.1.9

package/src/global/A-Error/A_Error.class.ts

@@ -10,6 +10,7 @@ import { A_FormatterHelper } from '@adaas/a-concept/helpers/A_Formatter.helper';
 import { A_Context } from '../A-Context/A-Context.class';
 import { A_TypeGuards } from '@adaas/a-concept/helpers/A_TypeGuards.helper';
 import { ASEID } from '../ASEID/ASEID.class';
+import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from '@adaas/a-concept/constants/env.constants';
 
 
 export class A_Error<
@@ -51,6 +52,10 @@ export class A_Error<
      * ASEID of the error instance
      */
     protected _aseid!: ASEID;
+    /**
+     * Title of the error
+     */
+    protected _title!: string;
     /**
      * Possible Scope if needed to identify the error by it's execution environment
      */
@@ -133,39 +138,49 @@ export class A_Error<
         /**
          * Error message
          */
-        message: string,
+        title: string,
         /**
          * Detailed description of the error
          */
         description: string
     )
-   
     constructor(
         param1: _ConstructorType | Error | string | A_Error,
-        param2?: string 
+        param2?: string
     ) {
         //  to prevent errors accumulation in the stack trace it returns the original error if provided param1 is A_Error
-        if (param1 instanceof A_Error) {
-            return param1 as A_Error<_ConstructorType, _SerializedType>;
-        } else if (A_TypeGuards.isConstructorType<_ConstructorType>(param1)) {
-            super(param1.message);
-        } else if (param1 instanceof Error) {
-            super(param1.message);
-        } else if (A_TypeGuards.isString(param1)) {
-            super(param1);
-        } else {
-            console.log('INVALID PARAMS PROVIDED TO A_ERROR CONSTRUCTOR: ', param1);
+        switch (true) {
+            case param1 instanceof A_Error:
+                return param1 as A_Error<_ConstructorType, _SerializedType>;
 
-            throw new A_Error(
-                A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR,
-                'Invalid parameters provided to A_Error constructor'
-            );
-        }
+            case param1 instanceof Error:
+                super(param1.message);
+                break;
+
+            case A_TypeGuards.isConstructorType<_ConstructorType>(param1) && 'description' in param1:
+                super(`[${param1.title}]: ${param1.description}`);
+                break;
+
+            case A_TypeGuards.isConstructorType<_ConstructorType>(param1) && !('description' in param1):
+                super(param1.title);
+                break;
 
-        // check message length
-        this.validateMessage(this.message);
+            case A_TypeGuards.isString(param1) && !param2:
+                super(param1);
+                break;
+
+            case A_TypeGuards.isString(param1) && !!param2:
+                super(`[${param1}]: ${param2}`);
+                break;
+
+            default:
+                throw new A_Error(
+                    A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR,
+                    'Invalid parameters provided to A_Error constructor'
+                );
+        }
 
-        const initializer = this.getInitializer(param1);
+        const initializer = this.getInitializer(param1, param2);
         // the returned initializer is already bound to `this` (we used .bind(this)),
         // so calling it will run the appropriate logic on this instance:
         initializer.call(this, param1, param2);
@@ -183,13 +198,20 @@ export class A_Error<
         return this._aseid;
     }
     /**
-     * Returns an Error message what is a brief title of the error
+     * Returns the title of the error
      * 
      * Example: 'User not found', 'Validation error', 'Unauthorized access', etc.
      * 
-     * [!] Note: This message should be short and concise, less than 60 characters
-     * [!] Note: If message exceeds 60 characters, there would be an error thrown
-     * [!] Note: This message is intended to be human-readable and can be displayed in UI or logs
+     * [!] Note: This title should be short and concise, less than 60 characters
+     * [!] Note: If title exceeds 60 characters, there would be an error thrown
+     * [!] Note: This title is intended to be human-readable and can be displayed in UI or logs
+     */
+    get title(): string {
+        return this._title;
+    }
+    /**
+     * Returns an Error message what is a brief title of the error
+     * 
      */
     get message(): string {
         return super.message;
@@ -205,7 +227,7 @@ export class A_Error<
      * [!] Note: If not provided would be used a kebab-case message of the error
      */
     get code(): string {
-        return this._code || A_FormatterHelper.toKebabCase(this.message);
+        return this._code || A_FormatterHelper.toKebabCase(this.title);
     }
     /**
      * Returns the type of the error which corresponds to the static entity of the class
@@ -257,7 +279,7 @@ export class A_Error<
      * [!] Note: This description is intended to provide more context about the error and can be used for debugging or logging purposes
      */
     get description(): string {
-        return this._description || process.env.A_ERROR_DEFAULT_DESCRIPTION || A_CONSTANTS__ERROR_DESCRIPTION;
+        return this._description || process.env[A_CONSTANTS__DEFAULT_ENV_VARIABLES.A_ERROR_DEFAULT_DESCRIPTION] || A_CONSTANTS__ERROR_DESCRIPTION;
     }
     /**
      * Returns the original error if any
@@ -280,10 +302,14 @@ export class A_Error<
      */
     protected getInitializer(
         param1: _ConstructorType | Error | string | any,
+        param2?: string
     ): (param1: any, param2: any) => void | (() => void) {
         switch (true) {
-            case A_TypeGuards.isString(param1):
-                return this.fromString;
+            case A_TypeGuards.isString(param1) && !param2:
+                return this.fromMessage;
+
+            case A_TypeGuards.isString(param1) && !!param2:
+                return this.fromTitle;
 
             case param1 instanceof Error:
                 return this.fromError;
@@ -309,7 +335,7 @@ export class A_Error<
      * @param error 
      */
     protected fromError(error: Error): void {
-        this._code = A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
+        this._title = A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
 
         this._aseid = new ASEID({
             concept: (this.constructor as typeof A_Error).concept,
@@ -318,19 +344,16 @@ export class A_Error<
             id: this.code
         });
 
-        this._description = 'If you see this error please let us know.';
         this._originalError = error;
     }
     /**
-     * Initializes the A_Error instance from a string message and optional description.
+     * Initializes the A_Error instance from a message.
      * 
-     * @param message 
+     * @param title 
      * @param description 
      */
-    protected fromString(message: string, description?: string ): void {
-        this._code = A_FormatterHelper.toKebabCase(message);
-        this._scope = A_TypeGuards.isScopeInstance(description) ? description.name : undefined;
-
+    protected fromMessage(message: string): void {
+        this._title = A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
 
         this._aseid = new ASEID({
             concept: (this.constructor as typeof A_Error).concept,
@@ -339,7 +362,23 @@ export class A_Error<
             id: this.code
         });
 
-        this._description = A_TypeGuards.isString(description) ? description : undefined;
+        this._link = undefined;
+        this._originalError = undefined;
+    }
+
+
+    fromTitle(title: string, description: string): void {
+        this.validateTitle(title);
+
+        this._title = title;
+        this._description = description;
+
+        this._aseid = new ASEID({
+            concept: (this.constructor as typeof A_Error).concept,
+            scope: this._scope || (this.constructor as typeof A_Error).scope,
+            entity: (this.constructor as typeof A_Error).entity,
+            id: this.code
+        });
 
         this._link = undefined;
         this._originalError = undefined;
@@ -350,6 +389,9 @@ export class A_Error<
      * @param params 
      */
     protected fromConstructor(params: _ConstructorType): void {
+        this.validateTitle(params.title);
+
+        this._title = params.title;
         this._code = params.code;
         this._scope = params.scope ? (A_TypeGuards.isScopeInstance(params.scope) ? params.scope.name : params.scope) : undefined;
 
@@ -374,6 +416,7 @@ export class A_Error<
     toJSON(): _SerializedType {
         return {
             aseid: this.aseid.toString(),
+            title: this.title,
             code: this.code,
             type: this.type,
             message: this.message,
@@ -390,19 +433,32 @@ export class A_Error<
     // ----------------------- PROTECTED HELPERS --------------------------------
     // --------------------------------------------------------------------------
     /**
-     * Checks if the provided message exceeds 60 characters.
+     * Checks if the provided title exceeds 60 characters.
      * If it does, throws a validation A_Error.
      * 
-     * @param message 
+     * @param title 
      */
-    protected validateMessage(message: string) {
-        if (message.length > 60) {
-            throw new A_Error(A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR, 'A-Error message exceeds 60 characters limit.');
+    protected validateTitle(title: string) {
+        if (title.length > 60) {
+            throw new A_Error(
+                A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR,
+                'A-Error title exceeds 60 characters limit.'
+            );
         }
-        if (message.length === 0) {
-            throw new A_Error(A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR, 'A-Error message cannot be empty.');
+        if (title.length === 0) {
+            throw new A_Error(
+                A_CONSTANTS__ERROR_CODES.VALIDATION_ERROR,
+                'A-Error title cannot be empty.'
+            );
         }
     }
+}
+
+
+
+
 
+// message = title + description for better printing in the console
+// description = detailed information about the error
+// code = kebabcase (title)
 
-}

package/src/global/A-Error/A_Error.types.ts

@@ -15,12 +15,11 @@ export type A_TYPES__Error_Constructor<T = A_Error> = new (...args: any[]) => T;
  */
 export type A_TYPES__Error_Init = {
     /**
-     * Error message
+     * Error title
      * 
      * A short description of the error 
      */
-    message: string;
-
+    title: string;
 
     /**
      * Error code representing the type of error
@@ -65,6 +64,10 @@ export type A_TYPES__Error_Serialized = {
      * ASEID of the error
      */
     aseid: string,
+    /**
+     * A brief title of the error
+     */
+    title: string,
     /**
      * Error message
      */

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

@@ -378,7 +378,7 @@ export class A_Feature<T extends A_TYPES__FeatureAvailableComponents = A_TYPES__
             case A_TypeGuards.isErrorInstance(reason):
                 this._error = new A_FeatureError({
                     code: A_FeatureError.Interruption,
-                    message: reason.message,
+                    title: reason.title,
                     description: reason.description,
                     originalError: reason
                 });

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

@@ -386,22 +386,29 @@ export class A_Scope<
             }
             // 2) Check if it's a Component
             case A_TypeGuards.isComponentConstructor(ctor): {
-                found = this.isAllowedComponent(ctor);
+                found = this.isAllowedComponent(ctor)
+                    || !![...this.allowedComponents]
+                        .find(c => A_CommonHelper.isInheritedFrom(c, ctor));
 
                 break;
             }
             // 3) Check if it's an Entity
             case A_TypeGuards.isEntityConstructor(ctor): {
-                found = this.isAllowedEntity(ctor);
+                found = this.isAllowedEntity(ctor)
+                    || !![...this.allowedEntities]
+                        .find(e => A_CommonHelper.isInheritedFrom(e, ctor));
 
                 break;
             }
             // 4) Check if it's a Fragment
             case A_TypeGuards.isFragmentConstructor(ctor): {
-                found = this.isAllowedFragment(ctor);
+                found = this.isAllowedFragment(ctor)
+                    || !![...this.allowedFragments]
+                        .find(f => A_CommonHelper.isInheritedFrom(f, ctor));
 
                 break;
             }
+
             // check scope issuer 
             case this.issuer().constructor === ctor: {
                 found = true;
@@ -410,7 +417,11 @@ export class A_Scope<
         }
 
         if (!found && !!this._parent)
-            return this._parent.has(ctor as any);
+            try {
+                return this._parent.has(ctor as any);
+            } catch (error) {
+                return false;
+            }
 
 
         return found;

package/src/helpers/A_TypeGuards.helper.ts

@@ -322,6 +322,6 @@ export class A_TypeGuards {
      * @returns 
      */
     static isConstructorType<T extends A_TYPES__Error_Init>(param: any): param is T {
-        return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "message" in param;
+        return !!param && A_TypeGuards.isObject(param) && !(param instanceof Error) && "title" in param;
     }
 }

package/tests/A-Abstraction.test.ts

@@ -2,6 +2,8 @@ import { A_Component } from '@adaas/a-concept/global/A-Component/A-Component.cla
 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_ScopeError } from '@adaas/a-concept/global/A-Scope/A-Scope.error';
 
 jest.retryTimes(0);
 
@@ -68,5 +70,85 @@ describe('A-Abstraction Tests', () => {
         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);
+    })
+    
+});

package/tests/A-Component.test.ts

@@ -3,6 +3,8 @@ import './test.setup';
 
 import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
 import { A_Context } from '@adaas/a-concept/global/A-Context/A-Context.class';
+import { A_Concept } from '@adaas/a-concept/global/A-Concept/A-Concept.class';
+import { A_TYPES__ComponentMetaKey } from '@adaas/a-concept/global/A-Component/A-Component.constants';
 
 jest.retryTimes(0);
 
@@ -29,4 +31,26 @@ describe('A-Component tests', () => {
 
         expect(dependentComponent.dependency).toBeInstanceOf(MyComponent);
     });
-});
+    it('Should inherit component meta correctly', async () => {
+        class BaseComponent extends A_Component {
+            @A_Concept.Load()
+            test() {
+
+            }
+        }
+
+        class ChildComponent extends BaseComponent { }
+
+        const baseMeta = A_Context.meta(BaseComponent);
+        const childMeta = A_Context.meta(ChildComponent);
+
+        const baseAbstractions = baseMeta.get(A_TYPES__ComponentMetaKey.ABSTRACTIONS)
+        const childAbstractions = childMeta.get(A_TYPES__ComponentMetaKey.ABSTRACTIONS)
+
+        for (const [key, value] of baseAbstractions!) {
+            expect(childAbstractions!.has(key)).toBe(true);
+            expect(childAbstractions!.get(key)).toBe(value);
+        }
+    });
+
+}); 

package/tests/A-Concept.test.ts

@@ -105,5 +105,27 @@ describe('A-Concept tests', () => {
         expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
         expect(concept.scope.resolve(MyContext)).toEqual(sharedContext);
     });
+     it('Should allow to register multiple containers', async () => {
+        A_Context.reset();
+
+        class MyContainerA extends A_Container { }
+        class MyContainerB extends A_Container { }
+
+        const containerA = new MyContainerA({ name: 'ContainerA' });
+        const containerB = new MyContainerB({ name: 'ContainerB' });
+
+        const concept = new A_Concept({
+            name: 'TestConcept',
+            containers: [
+                containerA,
+                containerB
+            ]
+        });
+
+        expect(containerA.scope.resolve(MyContainerA)).toBeInstanceOf(MyContainerA);
+        expect(containerB.scope.resolve(MyContainerB)).toBeInstanceOf(MyContainerB);   
+
+     })
+     
 
 });

package/tests/A-Container.test.ts

@@ -0,0 +1,16 @@
+import { A_Container } from '@adaas/a-concept/global/A-Container/A-Container.class';
+import './test.setup';
+import { A_Scope } from '@adaas/a-concept/global/A-Scope/A-Scope.class';
+
+
+describe('A-Container tests', () => {
+
+    it('Should Allow to create a concept', async () => {
+        const container = new A_Container();
+        expect(container).toBeInstanceOf(A_Container);
+        expect(container.scope).toBeDefined();
+        expect(container.scope).toBeInstanceOf(A_Scope);
+    });
+
+
+});

package/tests/A-Error.test.ts

@@ -2,6 +2,7 @@ import { A_CONSTANTS__DEFAULT_ENV_VARIABLES } from "@adaas/a-concept/constants/e
 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";
+import { A_FormatterHelper } from "@adaas/a-concept/helpers/A_Formatter.helper";
 
 jest.retryTimes(0);
 
@@ -13,7 +14,8 @@ describe('A-Error Tests', () => {
 
         expect(error).toBeDefined();
         expect(error.message).toBe('Test error');
-        expect(error.code).toBe('test-error');
+        expect(error.title).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.code).toBe(A_FormatterHelper.toKebabCase(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR));
         expect(error.type).toBe('a-error');
     });
 
@@ -24,7 +26,8 @@ describe('A-Error Tests', () => {
 
         expect(error).toBeDefined();
         expect(error.message).toBe('Original error');
-        expect(error.code).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.title).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.code).toBe(A_FormatterHelper.toKebabCase(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR));
         expect(error.type).toBe('a-error');
         expect(error.originalError).toBe(originalError);
     });
@@ -36,7 +39,8 @@ describe('A-Error Tests', () => {
 
         expect(error).toBeDefined();
         expect(error).toBe(originalError);
-        expect(error.message).toBe('Original A_Error');
+        expect(error.title).toBe('Original A_Error');
+        expect(error.message).toBe('[Original A_Error]: This is the original error');
         expect(error.code).toBe('original-a-error');
         expect(error.type).toBe('a-error');
         expect(error.description).toBe('This is the original error');
@@ -48,13 +52,14 @@ describe('A-Error Tests', () => {
         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',
+            title: 'Custom error message',
             description: 'This is a custom error description',
             originalError
         });
 
         expect(error).toBeDefined();
-        expect(error.message).toBe('Custom error message');
+        expect(error.title).toBe('Custom error message');
+        expect(error.message).toBe('[Custom error message]: This is a custom error description');
         expect(error.code).toBe('test-code');
         expect(error.type).toBe('a-error');
         expect(error.description).toBe('This is a custom error description');
@@ -66,11 +71,12 @@ describe('A-Error Tests', () => {
         const originalError = new A_Error('Original A_Error', 'This is the original error');
 
         const error = new A_Error({
-            message: 'Custom error message',
+            title: 'Custom error message',
             originalError: originalError
         });
 
         expect(error).toBeDefined();
+        expect(error.title).toBe('Custom error message');
         expect(error.message).toBe('Custom error message');
         expect(error.code).toBe('custom-error-message');
         expect(error.type).toBe('a-error');
@@ -84,20 +90,26 @@ describe('A-Error Tests', () => {
         const error = new MyError('Test inherited error');
 
         expect(error).toBeDefined();
+        expect(error.title).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.code).toBe(A_FormatterHelper.toKebabCase(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR));
         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');
+
+        expect(originalError.title).toBe('Original A_Error');
+
+
         const error = new A_Error(originalError);
 
         const serialized = error.toJSON();
 
         expect(serialized).toBeDefined();
-        expect(serialized.message).toBe('Original A_Error');
+        expect(serialized.title).toBe('Original A_Error');
+        expect(serialized.message).toBe('[Original A_Error]: This is the original error');
         expect(serialized.code).toBe('original-a-error');
         expect(serialized.type).toBe('a-error');
         expect(serialized.scope).toBe('root');
@@ -115,7 +127,8 @@ describe('A-Error Tests', () => {
 
         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.title).toBe(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+        expect(error.code).toBe(A_FormatterHelper.toKebabCase(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR));
         expect(error.type).toBe('a-error');
         expect(error.aseid.concept).toBe('my-project');
         expect(error.aseid.scope).toBe('my-scope');