@adaas/a-concept 0.1.31 → 0.1.33

package/jest.config.ts

@@ -3,6 +3,7 @@ import type { Config } from '@jest/types';
 // Sync object
 const config: Config.InitialOptions = {
     verbose: true,
+    setupFilesAfterEnv: ['<rootDir>/tests/jest.setup.ts'],
     roots: ['<rootDir>/tests'],
     transform: {
         '^.+\\.tsx?$': 'ts-jest'

package/package.json

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

@@ -206,7 +206,7 @@ export class A_Context {
         component: A_TYPES_ScopeDependentComponents,
     ): void {
         // uses only for error messages
-        const componentName = A_CommonHelper.getComponentName(component);   
+        const componentName = A_CommonHelper.getComponentName(component);
 
         const instance = this.getInstance();
 
@@ -985,7 +985,8 @@ export class A_Context {
     static isAllowedToBeRegistered(param: any): param is A_TYPES_ScopeDependentComponents {
         return A_TypeGuards.isEntityInstance(param)
             || A_TypeGuards.isComponentInstance(param)
-            || A_TypeGuards.isFragmentInstance(param);
+            || A_TypeGuards.isFragmentInstance(param)
+            || A_TypeGuards.isErrorInstance(param);
     }
 
     /**

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

@@ -232,7 +232,7 @@ export type A_TYPES__FeatureExtendDecoratorDescriptor =
  * 
  * [!] Can be applied only on A-Components
  */
-export type A_TYPES__FeatureExtendDecoratorTarget = A_Component
+export type A_TYPES__FeatureExtendDecoratorTarget = A_Component | A_Container | A_Entity
 
 /**
  * Configuration type for A_Extend decorator

package/src/global/A-Inject/A-Inject.decorator.ts

@@ -23,6 +23,8 @@ import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
 import { A_TYPES__Scope_Constructor } from "@adaas/a-concept/global/A-Scope/A-Scope.types";
 import { A_Feature } from "@adaas/a-concept/global/A-Feature/A-Feature.class";
 import { A_CommonHelper } from "@adaas/a-concept/helpers/A_Common.helper";
+import { A_TYPES__Error_Constructor } from "../A-Error/A_Error.types";
+import { A_Error } from "../A-Error/A_Error.class";
 
 
 /**
@@ -44,6 +46,14 @@ export function A_Inject<T extends A_Scope>(
      */
     scope: A_TYPES__Scope_Constructor<T>
 ): A_TYPES__A_InjectDecoratorReturn
+export function A_Inject<T extends A_Error>(
+    /***
+     * Provide the Error constructor that will be associated with the injection.
+     *
+     * [!] It returns an Instance of the Error what is executed.
+     */
+    error: A_TYPES__Error_Constructor<T>
+): A_TYPES__A_InjectDecoratorReturn
 export function A_Inject<T extends A_Feature>(
     /**
      * Provide the Feature constructor that will be associated with the injection.

package/src/global/A-Inject/A-Inject.types.ts

@@ -5,6 +5,7 @@ import { A_TYPES__Entity_Constructor } from "@adaas/a-concept/global/A-Entity/A-
 import { A_TYPES__Feature_Constructor } from "@adaas/a-concept/global/A-Feature/A-Feature.types";
 import { A_TYPES__Fragment_Constructor } from "@adaas/a-concept/global/A-Fragment/A-Fragment.types";
 import { A_TYPES__Caller_Constructor } from "@adaas/a-concept/global/A-Caller/A_Caller.types";
+import { A_TYPES__Error_Constructor } from "../A-Error/A_Error.types";
 
 
 // ============================================================================
@@ -54,6 +55,7 @@ export type A_TYPES__InjectableConstructors = A_TYPES__Component_Constructor
     | A_TYPES__Feature_Constructor
     | A_TYPES__Caller_Constructor
     | A_TYPES__Fragment_Constructor
+    | A_TYPES__Error_Constructor
     | string;
 
 

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

@@ -138,6 +138,12 @@ export class A_Scope<
      * [!] One component instance per scope
      */
     get components(): Array<InstanceType<_ComponentType[number]>> { return Array.from(this._components.values()) }
+    /**
+     * Returns an Array of errors registered in the scope
+     * 
+     * [!] One error per code
+     */
+    get errors(): Array<InstanceType<_ErrorType[number]>> { return Array.from(this._errors.values()) }
 
     /**
      * Returns the parent scope of the current scope
@@ -381,6 +387,12 @@ export class A_Scope<
          */
         fragment: A_TYPES__Fragment_Constructor<T>
     ): boolean
+    has<T extends A_Error>(
+        /**
+         * Provide an error constructor to check if it's available in the scope
+         */
+        error: A_TYPES__Error_Constructor<T>
+    ): boolean
     has(
         /**
          * Provide a string to check if a component, entity or fragment with the provided name is available in the scope
@@ -412,7 +424,11 @@ export class A_Scope<
                 const possibleEntity = Array.from(this.allowedEntities).find(e => e.name === ctor);
                 if (possibleEntity) found = true;
 
-                // 2.4 If not found in current scope, check parent scope
+                // 2.4 Check if it's an error name
+                const possibleError = Array.from(this.allowedErrors).find(e => e.name === ctor);
+                if (possibleError) found = true;
+
+                // 2.5 If not found in current scope, check parent scope
                 if (!!this._parent)
                     return this._parent.has(ctor);
 
@@ -442,7 +458,17 @@ export class A_Scope<
 
                 break;
             }
-            // 6) Check scope issuer
+
+            // 6) Check if it's an Error
+            case A_TypeGuards.isErrorConstructor(ctor): {
+                found = this.isAllowedError(ctor)
+                    || !![...this.allowedErrors]
+                        .find(e => A_CommonHelper.isInheritedFrom(e, ctor));
+
+                break;
+            }
+
+            // 7) Check scope issuer
             case this.issuer()
                 && (this.issuer()!.constructor === ctor
                     || A_CommonHelper.isInheritedFrom(this.issuer()!.constructor, ctor
@@ -598,14 +624,7 @@ export class A_Scope<
          */
         entity: A_TYPES__Entity_Constructor<T>
     ): T | undefined
-    resolve<T extends A_Scope>(
-        /**
-         * Uses only in case of resolving a single entity
-         * 
-         * Provide an entity constructor to resolve its instance from the scope
-         */
-        scope: new (...args: any[]) => T
-    ): T | undefined
+
     resolve<T extends A_Entity>(
         /**
          * Provide an entity constructor to resolve its instance or an array of instances from the scope
@@ -616,6 +635,22 @@ export class A_Scope<
          */
         instructions: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions<T>>
     ): Array<T>
+    resolve<T extends A_Scope>(
+        /**
+         * Uses only in case of resolving a single entity
+         * 
+         * Provide an entity constructor to resolve its instance from the scope
+         */
+        scope: A_TYPES__Scope_Constructor<T>
+    ): T | undefined
+    resolve<T extends A_Error>(
+        /**
+         * Uses only in case of resolving a single entity
+         * 
+         * Provide an entity constructor to resolve its instance from the scope
+         */
+        scope: A_TYPES__Error_Constructor<T>
+    ): T | undefined
     resolve<T extends A_TYPES__ScopeResolvableComponents>(
         constructorName: string
     ): T | undefined
@@ -688,7 +723,8 @@ export class A_Scope<
          * Provide the name of the component, fragment or entity to resolve
          */
         name: string
-    ): _EntityType[number] | InstanceType<_ComponentType[number]> | _FragmentType[number] | undefined {
+    ): _EntityType[number] | InstanceType<_ComponentType[number]> | _FragmentType[number] |
+        InstanceType<_ErrorType[number]> | undefined {
         // 1) Check components
         const component = Array.from(this.allowedComponents).find(
             c => c.name === name
@@ -711,6 +747,15 @@ export class A_Scope<
         );
         if (fragment) return this.resolveOnce(fragment) as _FragmentType[number];
 
+        // 4) Check errors
+        const error = Array.from(this.allowedErrors).find(
+            e => e.name === name
+                || e.name === A_FormatterHelper.toPascalCase(name)
+                || (e as any).code === name
+                || (e as any).code === A_FormatterHelper.toKebabCase(name)
+        );
+        if (error) return this.resolveOnce(error) as InstanceType<_ErrorType[number]>;
+
         // If not found in current scope, check parent scope
         if (!!this._parent) {
             return this._parent.resolveByName(name) as any;
@@ -731,6 +776,7 @@ export class A_Scope<
         instructions?: Partial<A_TYPES__A_InjectDecorator_EntityInjectionInstructions>
     ): A_TYPES__ScopeResolvableComponents | A_Scope | A_TYPES__ScopeLinkedComponents | Array<A_TYPES__ScopeResolvableComponents> | undefined {
 
+
         const componentName = A_CommonHelper.getComponentName(component);
 
         if (!component || !this.has(component))
@@ -752,6 +798,9 @@ export class A_Scope<
             case A_TypeGuards.isComponentConstructor(component): {
                 return this.resolveComponent(component);
             }
+            case A_TypeGuards.isErrorConstructor(component): {
+                return this.resolveError(component);
+            }
             default:
                 throw new A_ScopeError(
                     A_ScopeError.ResolutionError,
@@ -883,7 +932,27 @@ export class A_Scope<
             }
         }
     }
+    /**
+     * This method is used internally to resolve a single error from the scope
+     * 
+     * @param error 
+     * @returns 
+     */
+    private resolveError<T extends A_Error>(error: A_TYPES__Error_Constructor<T>): T | undefined {
+
+        const found = this.errors.find(e => e instanceof error);
 
+        switch (true) {
+            case !!found:
+                return found as T;
+
+            case !found && !!this._parent:
+                return this._parent.resolveError(error);
+
+            default:
+                return undefined;
+        }
+    }
     /**
      * This method is used internally to resolve a single fragment from the scope
      * 
@@ -1079,7 +1148,7 @@ export class A_Scope<
                 break;
             }
             // 3) In case when it's a A-Entity instance
-            case param1 instanceof A_Entity && !this._entities.has(param1.aseid.toString()): {
+            case A_TypeGuards.isEntityInstance(param1) && !this._entities.has(param1.aseid.toString()): {
 
                 if (!this.allowedEntities.has(param1.constructor as _EntityType[number]))
                     this.allowedEntities.add(param1.constructor as _EntityType[number]);
@@ -1089,7 +1158,7 @@ export class A_Scope<
                 break;
             }
             // 4) In case when it's a A-Fragment instance
-            case param1 instanceof A_Fragment: {
+            case A_TypeGuards.isFragmentInstance(param1): {
 
                 if (!this.allowedFragments.has(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>))
                     this.allowedFragments.add(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
@@ -1104,11 +1173,16 @@ export class A_Scope<
                 break;
             }
             // 5) In case when it's a A-Error instance
-            case param1 instanceof A_Error: {
+            case A_TypeGuards.isErrorInstance(param1): {
                 if (!this.allowedErrors.has(param1.constructor as _ErrorType[number]))
                     this.allowedErrors.add(param1.constructor as _ErrorType[number]);
 
-                // A_Context.register(this, param1);
+                this._errors.set(
+                    param1.code,
+                    param1 as InstanceType<_ErrorType[number]>
+                );
+
+                A_Context.register(this, param1);
                 break;
             }
 
@@ -1167,7 +1241,135 @@ export class A_Scope<
     }
 
 
+    /**
+     * This method is used to deregister the component from the scope
+     * 
+     * @param fragment 
+     */
+    deregister<T extends A_Component>(
+        /**
+         * Provide a component constructor to deregister it in the scope
+         */
+        component: A_TYPES__Component_Constructor<T>
+    ): void
+    deregister(
+        /**
+         * Provide a command instance to deregister it in the scope
+         */
+        component: A_Component
+    ): void
+    deregister<T extends A_Error>(
+        /**
+         * Provide an error constructor to deregister it in the scope
+         */
+        error: A_TYPES__Error_Constructor<T>
+    ): void
+    deregister(
+        /**
+         * Provide an error instance to deregister it in the scope
+         */
+        error: A_Error
+    ): void
+    deregister<T extends A_Fragment>(
+        /**
+         * Provide a command instance to deregister it in the scope
+         */
+        fragment: A_TYPES__Fragment_Constructor<T>
+    ): void
+    deregister(
+        /**
+         * Provide a fragment instance to deregister it in the scope
+         */
+        fragment: A_Fragment
+    ): void
+    deregister<T extends A_Entity>(
+        /**
+         * Provide an entity constructor to deregister it in the scope
+         */
+        entity: A_TYPES__Entity_Constructor<T>
+    ): void
+    deregister(
+        /**
+         * Provide an entity instance to deregister it in the scope
+         */
+        entity: A_Entity
+    ): void
+
+    deregister(
+        param1: unknown
+    ): void {
+        switch (true) {
+            // ------------------------------------------
+            // ------------ Instances ----------------
+            // ------------------------------------------
+            // 1) In case when it's a A-Component instance
+            case param1 instanceof A_Component: {
+
+                this._components.delete(param1.constructor as _ComponentType[number]);
+                A_Context.deregister(param1);
+
+                break;
+            }
+            // 3) In case when it's a A-Entity instance
+            case A_TypeGuards.isEntityInstance(param1): {
+
+                this._entities.delete(param1.aseid.toString());
+                A_Context.deregister(param1);
+                break;
+            }
+            // 4) In case when it's a A-Fragment instance
+            case A_TypeGuards.isFragmentInstance(param1): {
+
+                this._fragments.delete(param1.constructor as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
+                A_Context.deregister(param1);
 
+                break;
+            }
+            // 5) In case when it's a A-Error instance
+            case A_TypeGuards.isErrorInstance(param1): {
+
+                this._errors.delete(param1.code);
+                A_Context.deregister(param1);
+                break;
+            }
+
+            // ------------------------------------------
+            // ------------ Constructors ----------------
+            // ------------------------------------------
+            // 6) In case when it's a A-Component constructor
+            case A_TypeGuards.isComponentConstructor(param1): {
+                this.allowedComponents.delete(param1 as _ComponentType[number]);
+                break;
+            }
+            // 8) In case when it's a A-Fragment constructor
+            case A_TypeGuards.isFragmentConstructor(param1): {
+                this.allowedFragments.delete(param1 as A_TYPES__Fragment_Constructor<_FragmentType[number]>);
+                break;
+            }
+            // 9) In case when it's a A-Entity constructor
+            case A_TypeGuards.isEntityConstructor(param1): {
+                this.allowedEntities.delete(param1 as _EntityType[number]);
+                break;
+            }
+            // 10) In case when it's a A-Error constructor
+            case A_TypeGuards.isErrorConstructor(param1): {
+                this.allowedErrors.delete(param1 as _ErrorType[number]);
+                break;
+            }
+
+            // ------------------------------------------
+            // ------------ Invalid Cases ----------------
+            // ------------------------------------------
+
+            default:
+                const componentName = A_CommonHelper.getComponentName(param1);
+
+                throw new A_ScopeError(
+                    A_ScopeError.DeregistrationError,
+                    `Cannot deregister ${componentName} from the scope ${this.name}`
+                );
+        }
+    }
 
     /**
      * This method is useful when you want to serialize the scope to JSON

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

@@ -13,4 +13,5 @@ export class A_ScopeError extends A_Error {
 
     static readonly CircularInheritanceError = 'A-Scope Circular Inheritance Error';
 
+    static readonly DeregistrationError = 'A-Scope Deregistration Error';
 }

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

@@ -81,11 +81,11 @@ export type A_TYPES__ScopeLinkedComponents = A_Container | A_Feature;
 /**
  * A list of components that can be resolved by a scope
  */
-export type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity
+export type A_TYPES__ScopeResolvableComponents = A_Component | A_Fragment | A_Entity | A_Error | A_Scope;
 /**
  * A list of components that are dependent on a scope and do not have their own scope
  */
-export type A_TYPES_ScopeDependentComponents = A_Component | A_Entity | A_Fragment
+export type A_TYPES_ScopeDependentComponents = A_Component | A_Entity | A_Fragment | A_Error;
 /**
  * A list of components that are independent of a scope. They don't need a scope to be resolved
  * Those components haven't scope dependent features.

package/src/helpers/A_TypeGuards.helper.ts

@@ -307,7 +307,9 @@ export class A_TypeGuards {
     }
 
     static isAllowedForFeatureExtension(param: any): param is A_TYPES__FeatureExtendDecoratorTarget {
-        return A_TypeGuards.isComponentInstance(param);
+        return A_TypeGuards.isComponentInstance(param)
+            || A_TypeGuards.isContainerInstance(param)
+            || A_TypeGuards.isEntityInstance(param);
     }
 
     static isAllowedForAbstractionDefinition(param: any): param is A_TYPES__AbstractionAvailableComponents {