@adaas/a-concept 0.0.3 → 0.0.5

package/src/{containers → base}/A-Config/components/ConfigReader.component.ts

@@ -1,12 +1,16 @@
-import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
-import { A_Config } from "../A-Config.namespace";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
 
 
 
 /**
  * Config Reader
  */
-export class ConfigReader extends A_Component<A_Config> {
+export class ConfigReader {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope
+    ) { }
 
 
     /**

package/src/{containers → base}/A-Config/components/ENVConfigReader.component.ts

@@ -10,7 +10,7 @@ export class ENVConfigReader extends ConfigReader {
      * @param property 
      */
     getConfigurationProperty_ENV_Alias(property: string): string {
-        return `${A_CommonHelper.toUpperSnakeCase(this.namespace.name)}_${A_CommonHelper.toUpperSnakeCase(property)}`;
+        return `${A_CommonHelper.toUpperSnakeCase(this.scope.name)}_${A_CommonHelper.toUpperSnakeCase(property)}`;
     }
 
 

package/src/{containers → base}/A-Config/components/FileConfigReader.component.ts

@@ -26,7 +26,7 @@ export class FileConfigReader extends ConfigReader {
     ): Promise<Record<T, any>> {
         const fs = await A_Polyfills.fs();
         try {
-            const data = fs.readFileSync(`${this.namespace.name}.conf.json`, 'utf8');
+            const data = fs.readFileSync(`${this.scope.name}.conf.json`, 'utf8');
 
             const config: Record<T, any> = JSON.parse(data);
 

package/src/base/A-Errors/A-Errors.component.ts

@@ -0,0 +1,102 @@
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Errors } from "./A-Errors.context";
+import { A_CONSTANTS__ERROR_CODES, A_Error, A_ServerError, ASEID } from "@adaas/a-utils";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+export class A_ErrorsManager {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Errors) protected errors: A_Errors
+    ) {
+
+    }
+
+
+
+
+    throw(
+        error: Error | unknown | any
+    ): never
+    throw(
+        code: A_CONSTANTS__ERROR_CODES | string
+    ): never
+    throw(
+        error: A_Error | A_ServerError
+    ): never
+    throw(
+        param: A_CONSTANTS__ERROR_CODES | string | A_Error | A_ServerError
+    ): never {
+        switch (true) {
+            // In case of error code
+            case typeof param === 'string':
+                const template = this.errors.get(param);
+                const namedCode = `${A_Context.root}@${this.scope.name}:error:${template.code}`
+
+                if ('serverCode' in template)
+                    throw new A_ServerError({
+                        ...template,
+                        code: namedCode
+                    });
+                else
+                    throw new A_Error({
+                        ...template,
+                        code: namedCode
+                    })
+
+            // In case of error object
+            case param instanceof A_Error:
+                throw param;
+
+            // Otherwise wrap the error
+            default:
+                throw this.wrap(param);
+        }
+    }
+
+
+    /**
+     *  This method wraps an error into the SDK error object.
+     * 
+     * @param error 
+     * @returns 
+     */
+    wrap(error: Error | A_Error | unknown | any): A_ServerError | A_Error {
+
+        switch (true) {
+            case error instanceof A_Error:
+                let newCode = `${A_Context.root}@${this.scope.name}:error:${error.code}`;
+
+                if (ASEID.isASEID(error.code)) {
+                    const aseid = new ASEID(error.code);
+
+                    if (aseid.scope !== this.scope.name)
+                        newCode = `${A_Context.root}@${this.scope.name}:error:${aseid.id}`;
+                }
+
+                if ('serverCode' in error)
+                    return new A_ServerError({
+                        originalError: error,
+                        code: newCode,
+                        serverCode: error.serverCode,
+                        name: error.name,
+                        message: error.message,
+                        link: error.link,
+                        description: error.description
+                    });
+                else
+                    return new A_Error({
+                        originalError: error,
+                        code: newCode,
+                        name: error.name,
+                        message: error.message,
+                        link: error.link,
+                        description: error.description
+                    });
+
+            default:
+                return new A_Error(error);
+        }
+    }
+}

package/src/{containers/A-Errors/A-Errors.namespace.ts → base/A-Errors/A-Errors.context.ts}

@@ -1,23 +1,26 @@
-import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
 import { A_CONSTANTS__ERROR_CODES, A_Error, A_ServerError, A_TYPES__Dictionary, A_TYPES__Error, A_TYPES__ServerError } from "@adaas/a-utils";
 import { A_TYPES__A_ErrorsConstructor } from "./A-Errors.types";
 import { A_CONSTANTS__DEFAULT_ERRORS } from "@adaas/a-utils/dist/src/constants/errors.constants";
+import { A_Fragment } from "@adaas/a-concept/global/A-Fragment/A-Fragment.class";
 
 
-export class A_Errors extends A_Namespace<Partial<A_TYPES__A_ErrorsConstructor>> {
-
-
+export class A_Errors extends A_Fragment {
 
     protected registeredErrors: Map<string, A_TYPES__Error | A_TYPES__ServerError> = new Map();
 
     constructor(
         params: Partial<A_TYPES__A_ErrorsConstructor>
     ) {
-        super(params);
+
+        super({
+            ...params,
+            name: params.name || 'a-errors'
+        });
 
         if (params.errors) {
             this.addRegistry(params.errors);
         }
+
         this.addRegistry(A_CONSTANTS__DEFAULT_ERRORS);
     }
 
@@ -45,60 +48,42 @@ export class A_Errors extends A_Namespace<Partial<A_TYPES__A_ErrorsConstructor>>
      * @param error 
      */
     registerError(error: A_TYPES__Error): A_Errors {
-        this.registeredErrors.set(error.code, {
-            ...error,
-            code: `${this.name}@error:${error.code}`
-        });
+        this.registeredErrors.set(error.code, error);
 
         return this;
     }
 
+
     /**
      * This method returns an error object by its code.
      * 
      * @param code 
      * @returns 
      */
-    getError(code: A_CONSTANTS__ERROR_CODES | string): A_ServerError | A_Error | undefined {
+    get(code: A_CONSTANTS__ERROR_CODES | string): A_TYPES__Error | A_TYPES__ServerError {
         let template = this.registeredErrors.get(code);
 
         if (!template)
-            template = this.registeredErrors.get(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR);
+            template = this.registeredErrors.get(A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR)!;
 
-        if ((template as A_TYPES__ServerError).serverCode) {
-            return new A_ServerError(template as A_TYPES__ServerError);
-        } else {
-            return new A_Error(template);
-        }
+        return template;
     }
 
 
     /**
+     * Allows to throw an error by its code. 
+     * [!] BUT WITHOUT Connection to particular Scope
+     * 
      * This method throws an error by its code.
      * 
      * @param code 
      */
-    throw(code: A_CONSTANTS__ERROR_CODES | string): never {
-
-        const err = this.getError(code);
-
-        throw err;
-    }
-
-
-    /**
-     *  This method wraps an error into the SDK error object.
-     * 
-     * @param error 
-     * @returns 
-     */
-    wrap(error: Error | A_Error | unknown): A_ServerError | A_Error {
-        if (error instanceof A_Error) {
-            return new A_ServerError(error);
-        }
-
-        return new A_Error(error);
-    }
-
-
+    // throw(code: A_CONSTANTS__ERROR_CODES | string): never {
+    //     const template = this.get(code);
+
+    //     if ('serverCode' in template)
+    //         throw new A_ServerError(template);
+    //     else
+    //         throw new A_Error(template)
+    // }
 } 

package/src/{containers → base}/A-Errors/A-Errors.types.ts

@@ -1,6 +1,6 @@
-import { A_TYPES__NamespaceConstructor } from "@adaas/a-concept/global/A-Namespace/A_Namespace.types"
+import { A_TYPES__FragmentConstructor } from "@adaas/a-concept/global/A-Fragment/A-Fragment.types"
 import { A_TYPES__Dictionary, A_TYPES__Error } from "@adaas/a-utils"
 
 export type A_TYPES__A_ErrorsConstructor = {
     errors: A_TYPES__Dictionary<A_TYPES__Error> | A_TYPES__Error[]
-} & A_TYPES__NamespaceConstructor
+} & A_TYPES__FragmentConstructor

package/src/base/A-Logger/A-Logger.component.ts

@@ -0,0 +1,169 @@
+import { A_Inject } from "@adaas/a-concept/decorators/A-Inject/A-Inject.decorator";
+import { A_Error } from "@adaas/a-utils";
+import { A_Config } from "../A-Config/A-Config.context";
+import { A_Scope } from "@adaas/a-concept/global/A-Scope/A-Scope.class";
+
+
+
+export class A_Logger {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Config) protected config: A_Config
+    ) {
+    }
+
+    readonly colors = {
+        green: '32',
+        blue: '34',
+        red: '31',
+        yellow: '33',
+        gray: '90',
+        magenta: '35',
+        cyan: '36',
+        white: '37',
+        pink: '95',
+    } as const
+
+
+    get scopeLength() {
+        return this.scope.name.length;
+    }
+
+
+    compile(
+        color: keyof typeof this.colors,
+        ...args: any[]
+    ): Array<string> {
+
+        return [
+            `\x1b[${this.colors[color]}m[${this.scope.name}] |${this.getTime()}|`,
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.scopeLength + 3)}|-------------------------------`
+                    : ''
+
+            ),
+            ...(args
+                .map((arg, i) => {
+
+
+                    switch (true) {
+                        case arg instanceof A_Error:
+                            return this.compile_A_Error(arg);
+
+                        case arg instanceof Error:
+                            return this.compile_Error(arg);
+
+                        case typeof arg === 'object':
+                            return JSON.stringify(arg, null, 2)
+                                .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `);
+
+                        default:
+                            return String(
+                                ((i > 0 || args.length > 1) ? '\n' : '')
+                                + arg)
+                                .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `)
+                    }
+                })),
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.scopeLength + 3)}|-------------------------------\x1b[0m`
+                    : '\x1b[0m'
+            )
+        ]
+    }
+
+
+    log(...args) {
+        if (!this.config.get('CONFIG_VERBOSE'))
+            return;
+
+        console.log(...this.compile('blue', ...args));
+    }
+
+    warning(...args) {
+        if (!this.config.get('CONFIG_VERBOSE'))
+            return;
+
+        console.log(...this.compile('yellow', ...args));
+    }
+
+    error(...args) {
+        if (this.config.get('CONFIG_IGNORE_ERRORS'))
+            return;
+
+        return console.log(...this.compile('red', ...args));
+    }
+
+
+    protected log_A_Error(error: A_Error) {
+        const time = this.getTime();
+
+        console.log(`\x1b[31m[${this.scope.name}] |${time}| ERROR ${error.code}
+${' '.repeat(this.scopeLength + 3)}| ${error.message}
+${' '.repeat(this.scopeLength + 3)}| ${error.description} 
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`
+            + (error.originalError ? `\x1b[31m${' '.repeat(this.scopeLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`: '')
+            + (error.link ? `\x1b[31m${' '.repeat(this.scopeLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+\x1b[0m`: ''));
+
+    }
+
+    protected compile_A_Error(error: A_Error): string {
+        const time = this.getTime();
+
+        return '\n' +
+
+            `${' '.repeat(this.scopeLength + 3)}|-------------------------------` +
+            '\n' +
+            `${' '.repeat(this.scopeLength + 3)}|  Error:  | ${error.code}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}|${' '.repeat(10)}| ${error.message}
+${' '.repeat(this.scopeLength + 3)}|${' '.repeat(10)}| ${error.description} 
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------`
+            +
+            (error.originalError ? `${' '.repeat(this.scopeLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------
+${' '.repeat(this.scopeLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------` : '')
+            +
+            (error.link ? `${' '.repeat(this.scopeLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.scopeLength + 3)}|-------------------------------` : '');
+
+    }
+
+
+    protected compile_Error(error: Error): string {
+        return JSON.stringify({
+            name: error.name,
+            message: error.message,
+            stack: error.stack?.split('\n')
+                .map((line, index) => index === 0 ? line : `${' '.repeat(this.scopeLength + 3)}| ${line}`)
+                .join('\n')
+
+        }, null, 2)
+            .replace(/\n/g, '\n' + `${' '.repeat(this.scopeLength + 3)}| `)
+            .replace(/\\n/g, '\n')
+    }
+
+
+
+    protected getTime() {
+        const now = new Date();
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        const milliseconds = String(now.getMilliseconds()).padStart(4, '0');
+        return `${minutes}:${seconds}:${milliseconds}`;
+    }
+}

package/src/constants/A_ConceptLifecycle.constants.ts

@@ -1,12 +1,12 @@
-import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
+// import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types";
 
 
 
-export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
-    name: '',
-    behavior: 'sync',
-    type: 'extension',
-    after: [],
-    before: [],
-    override: []
-} 
+// export const A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG: A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
+//     name: '',
+//     behavior: 'sync',
+//     type: 'extension',
+//     after: [],
+//     before: [],
+//     override: []
+// } 

package/src/decorators/A-Feature/A-Feature-Define.decorator.ts

@@ -0,0 +1,57 @@
+import {
+    A_TYPES__A_FeatureDecoratorConfig,
+    A_TYPES__A_FeatureDecoratorDescriptor,
+} from "./A-Feature.decorator.types";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+import { A_TYPES__ContainerMetaKey } from "@adaas/a-concept/global/A-Container/A-Container.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+
+/**
+ * A-Feature decorator
+ * 
+ * This decorator allows to define a custom lifecycle stage for the Container.
+ * These stages are executed in a container-specific order and can be extended by components that are injected into the container.
+ * This approach allows to create a flexible and extendable architecture for the application.
+ * 
+ * The main difference between the A-Feature and A-Feature decorators is that A-Feature methods can be inherited and overridden by child classes.
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Feature_Define(
+    config: Partial<A_TYPES__A_FeatureDecoratorConfig> = {}
+) {
+    return function (
+        target: A_Container<any>,
+        propertyKey: string,
+        descriptor: A_TYPES__A_FeatureDecoratorDescriptor
+    ) {
+
+        // Get the existed metadata or create a new one
+        const existedMeta = A_Context
+            .meta(target)
+            .get(A_TYPES__ContainerMetaKey.FEATURES)
+            || new Map();
+
+
+
+        // Set the metadata of the method to define a custom Feature with name 
+        existedMeta.set(propertyKey, {
+            handler: propertyKey,
+            config: {
+                ...config,
+                name: `${target.constructor.name}.${propertyKey || config.name}`,
+            }
+        });
+
+        //  Update the metadata of the container with the new Feature definition
+        A_Context
+            .meta(target)
+            .set(
+                A_TYPES__ContainerMetaKey.FEATURES,
+                existedMeta
+            );
+    };
+}

package/src/decorators/A-Feature/A-Feature-Extend.decorator.ts

@@ -0,0 +1,57 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import {
+    A_TYPES__A_ExtendDecoratorConfig,
+    A_TYPES__A_ExtendDecoratorDescriptor,
+} from "./A-Feature.decorator.types";
+import { A_TYPES__ComponentMetaKey } from "@adaas/a-concept/global/A-Component/A-Component.types";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+
+
+
+
+/**
+ * A-Extend decorator
+ * 
+ * This decorator allows to define a custom Extend stage for the Container.
+ * These stages are executed in a container-specific order and can be extended by components that are injected into the container.
+ * This approach allows to create a flexible and extendable architecture for the application.
+ * 
+ * The main difference between the A-Extend and A-Extend decorators is that A-Extend methods can be inherited and overridden by child classes.
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Feature_Extend(
+    config: Partial<A_TYPES__A_ExtendDecoratorConfig> = {}
+) {
+    return function (
+        target: A_Component,
+        propertyKey: string,
+        descriptor: A_TYPES__A_ExtendDecoratorDescriptor
+    ) {
+
+        // Get the existed metadata or create a new one
+        const existedMeta = A_Context
+            .meta(target)
+            .get(A_TYPES__ComponentMetaKey.EXTENSIONS)
+            || new Map();
+
+        // Set the metadata of the method to define a custom Feature with name
+        existedMeta.set(propertyKey, {
+            name: config.name || propertyKey,
+            handler: propertyKey,
+            container: config.container
+                ? typeof config.container === 'string'
+                    ? config.container
+                    : config.container.name
+                : '*',
+        });
+
+        //  Update the metadata of the container with the new Feature definition
+        A_Context
+            .meta(target)
+            .set(A_TYPES__ComponentMetaKey.EXTENSIONS, existedMeta);
+
+    };
+}

package/src/decorators/A-Feature/A-Feature.decorator.types.ts

@@ -0,0 +1,56 @@
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class"
+
+
+export type A_TYPES__A_FeatureDecoratorDescriptor =
+
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
+
+
+export type A_TYPES__A_FeatureDecoratorConfig = {
+    name: string,
+}
+
+
+
+export type A_TYPES__A_ExtendDecoratorDescriptor =
+
+    TypedPropertyDescriptor<() => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<() => Promise<any>>
+
+
+export type A_TYPES__A_ExtendDecoratorConfig = {
+    /**
+     * Name of the container Lifecycle method to be extended.
+     * 
+     * [!] If not provided will be used the name of the method.
+     */
+    name: string,
+    /**
+     * Container class or container name uses to identify the proper container in case when the name is not unique.
+     * 
+     * [!] If not provided will be applied to all containers with the same name.
+     */
+    container: string | typeof A_Container<any>
+}
+
+
+