@adaas/a-concept 0.0.2

package/src/containers/A-Logger/components/Logger.component.ts

@@ -0,0 +1,169 @@
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
+import { A_Error } from "@adaas/a-utils";
+import { A_Config } from "src/containers/A-Config/A-Config.namespace";
+
+
+export class Logger extends A_Component {
+
+    constructor(
+        protected namespace: A_Namespace,
+        protected config: A_Config
+    ) {
+        super(namespace);
+    }
+
+    readonly colors = {
+        green: '32',
+        blue: '34',
+        red: '31',
+        yellow: '33',
+        gray: '90',
+        magenta: '35',
+        cyan: '36',
+        white: '37',
+        pink: '95',
+    } as const
+
+
+    get namespaceLength() {
+        return this.namespaceLength;
+    }
+
+
+    compile(
+        color: keyof typeof this.colors,
+        ...args: any[]
+    ): Array<string> {
+
+        return [
+            `\x1b[${this.colors[color]}m[${this.namespace}] |${this.getTime()}|`,
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.namespaceLength + 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.namespaceLength + 3)}| `);
+
+                        default:
+                            return String(
+                                ((i > 0 || args.length > 1) ? '\n' : '')
+                                + arg)
+                                .replace(/\n/g, '\n' + `${' '.repeat(this.namespaceLength + 3)}| `)
+                    }
+                })),
+            (
+                args.length > 1
+                    ? '\n' + `${' '.repeat(this.namespaceLength + 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.namespace}] |${time}| ERROR ${error.code}
+${' '.repeat(this.namespaceLength + 3)}| ${error.message}
+${' '.repeat(this.namespaceLength + 3)}| ${error.description} 
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+${' '.repeat(this.namespaceLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+\x1b[0m`
+            + (error.originalError ? `\x1b[31m${' '.repeat(this.namespaceLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+${' '.repeat(this.namespaceLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+\x1b[0m`: '')
+            + (error.link ? `\x1b[31m${' '.repeat(this.namespaceLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+\x1b[0m`: ''));
+
+    }
+
+    protected compile_A_Error(error: A_Error): string {
+        const time = this.getTime();
+
+        return '\n' +
+
+            `${' '.repeat(this.namespaceLength + 3)}|-------------------------------` +
+            '\n' +
+            `${' '.repeat(this.namespaceLength + 3)}|  Error:  | ${error.code}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+${' '.repeat(this.namespaceLength + 3)}|${' '.repeat(10)}| ${error.message}
+${' '.repeat(this.namespaceLength + 3)}|${' '.repeat(10)}| ${error.description} 
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+${' '.repeat(this.namespaceLength + 3)}| ${error.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------`
+            +
+            (error.originalError ? `${' '.repeat(this.namespaceLength + 3)}| Wrapped From  ${error.originalError.message}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------
+${' '.repeat(this.namespaceLength + 3)}| ${error.originalError.stack?.split('\n').map((line, index) => index === 0 ? line : `${' '.repeat(this.namespaceLength + 3)}| ${line}`).join('\n') || 'No stack trace'}
+${' '.repeat(this.namespaceLength + 3)}|-------------------------------` : '')
+            +
+            (error.link ? `${' '.repeat(this.namespaceLength + 3)}| Read in docs: ${error.link}
+${' '.repeat(this.namespaceLength + 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.namespaceLength + 3)}| ${line}`)
+                .join('\n')
+
+        }, null, 2)
+            .replace(/\n/g, '\n' + `${' '.repeat(this.namespaceLength + 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/decorators/A-ConceptLifecycle/A-ConceptLifecycle.decorator.types.ts

@@ -0,0 +1,46 @@
+
+
+export type A_TYPES__ConceptLifecycle_MethodDeclarationConfig = {
+    /**
+     * The name of the method. If not provided, the name of the function will be used. 
+     * The name is connected to the class name. 
+     * e.g. 'YourClass.yourMethod'
+     */
+    name: string,
+    
+    /**
+     * Allows to override the method with a new implementation.
+     * The methods listed will not be called.
+     * e.g. ['YourClass.yourMethod']
+     */
+    override: Array<string> | string | Function,
+
+    /**
+     * Defines a flexible dependency management mechanism to enable pipeline-like behavior.
+     * The target method will be called before the methods listed.
+     * e.g. ['YourClass.yourMethod']
+     */
+    before: Array<string> | string | Function,
+
+    /**
+     * Defines a flexible dependency management mechanism to enable pipeline-like behavior.
+     * The target method will be called after the methods listed.
+     * e.g. ['YourClass.yourMethod']
+     */
+    after: Array<string> | string | Function,
+
+
+    /**
+     * Allows to define a behavior of the method 
+     * Sync  - blocks other Concept Lifecycle methods until the method is ready
+     * Async - allows to initialize method after Concept Lifecycle initialization
+     */
+    behavior: 'sync' | 'async',
+    type: 'extension' | 'pipe'
+}
+
+
+
+
+export type A_TYPES__ConceptLifecycle_MethodDeclarationStorage = {
+}

package/src/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator.ts

@@ -0,0 +1,55 @@
+import { A_TYPES__A_LoadDecoratorConfig, A_TYPES__A_LoadDecoratorDescriptor, A_TYPES__A_LoadDecoratorStorageInstruction } from "./A-Load.decorator.types";
+import { A_CONCEPT_ModulesDeclarationStorage, A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootLoad } from "src/storage/A_Concept.storage";
+import { A_CommonHelper } from "@adaas/a-utils";
+import { A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG } from "@adaas/a-concept/constants/A_ConceptLifecycle.constants";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+
+
+
+
+/**
+ * A-Load decorator
+ * 
+ * This Decorator allows to an extended flow of Concept loading. 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Load(
+    config: Partial<A_TYPES__A_LoadDecoratorConfig> = {}
+) {
+
+    return function (
+        target: A_Container,
+        propertyKey: string,
+        descriptor: A_TYPES__A_LoadDecoratorDescriptor
+    ) {
+        const targetProperty: Symbol = A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootLoad;
+
+
+
+        const existedMeta = A_CONCEPT_ModulesDeclarationStorage.get(target.constructor) || new Map();
+        const inheritMeta = A_CONCEPT_ModulesDeclarationStorage.get(Object.getPrototypeOf(target.constructor)) || new Map();
+
+        const inheritedInstructions = inheritMeta.get(targetProperty) || [];
+        const instructions: Array<A_TYPES__A_LoadDecoratorStorageInstruction> = existedMeta.get(targetProperty) || [...inheritedInstructions];
+
+        /**
+         * That's is needed to remove the previous definition of the method from parent classes 
+         * and override it with the new one 
+         */
+        const targetInstructions = instructions
+            .filter(
+                (instr: A_TYPES__A_LoadDecoratorStorageInstruction) => instr.handler !== propertyKey
+            );
+
+        targetInstructions.push({
+            handler: propertyKey,
+            config: A_CommonHelper.deepCloneAndMerge(config, A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG)
+        });
+
+        existedMeta.set(targetProperty, targetInstructions);
+
+        A_CONCEPT_ModulesDeclarationStorage.set(target.constructor, existedMeta);
+    };
+}

package/src/decorators/A-ConceptLifecycle/A-Load/A-Load.decorator.types.ts

@@ -0,0 +1,20 @@
+import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../A-ConceptLifecycle.decorator.types"
+
+export type A_TYPES__A_LoadDecoratorDescriptor =
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => void>
+    |
+    TypedPropertyDescriptor<(
+        ...args: any[]
+    ) => Promise<void>>
+
+
+export type A_TYPES__A_LoadDecoratorConfig = {
+} & A_TYPES__ConceptLifecycle_MethodDeclarationConfig
+
+
+export type A_TYPES__A_LoadDecoratorStorageInstruction = {
+    handler: string,
+    config: A_TYPES__A_LoadDecoratorConfig
+}

package/src/decorators/A-ConceptLifecycle/A-Run/A-Run.decorator.ts

@@ -0,0 +1,62 @@
+import { A_TYPES__A_RunDecoratorConfig, A_TYPES__A_RunDecoratorDescriptor, A_TYPES__A_RunDecoratorStorageInstruction } from "./A-Run.decorator.types";
+import { A_CONCEPT_ModulesDeclarationStorage, A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootRun } from "src/storage/A_Concept.storage";
+import { A_CommonHelper } from "@adaas/a-utils";
+import { A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG } from "@adaas/a-concept/constants/A_ConceptLifecycle.constants";
+import { A_Container } from "@adaas/a-concept/global/A-Container/A-Container.class";
+
+
+
+
+
+/**
+ * A-Run decorator
+ * 
+ * This decorator is used to define a method that will be executed during the lifecycle of the module.
+ * Depending on the definition and configurations 
+ * it will be executed during the run command 
+ * modifying and adjusting the whole [root.run] pipeline.
+ * 
+ * This decorator can be used in case of the need to define a custom logic that will be executed during the run command.
+ * 
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Run(
+    config: Partial<A_TYPES__A_RunDecoratorConfig> = {}
+) {
+
+    return function (
+        target: A_Container,
+        propertyKey: string,
+        descriptor: A_TYPES__A_RunDecoratorDescriptor
+    ) {
+        const targetProperty: Symbol = A_CONCEPT_STORAGE__MODULE_DECLARATION_Lifecycle_RootRun;
+
+
+
+        const existedMeta = A_CONCEPT_ModulesDeclarationStorage.get(target.constructor) || new Map();
+        const inheritMeta = A_CONCEPT_ModulesDeclarationStorage.get(Object.getPrototypeOf(target.constructor)) || new Map();
+
+        const inheritedInstructions = inheritMeta.get(targetProperty) || [];
+        const instructions: Array<A_TYPES__A_RunDecoratorStorageInstruction> = existedMeta.get(targetProperty) || [...inheritedInstructions];
+
+        /**
+         * That's is needed to remove the previous definition of the method from parent classes 
+         * and override it with the new one 
+         */
+        const targetInstructions = instructions
+            .filter(
+                (instr: A_TYPES__A_RunDecoratorStorageInstruction) => instr.handler !== propertyKey
+            );
+
+        targetInstructions.push({
+            handler: propertyKey,
+            config: A_CommonHelper.deepCloneAndMerge(config, A_CONSTANTS__DEFAULT_CONCEPT_LIFECYCLE_METHOD_DECLARATION_CONFIG)
+        });
+
+        existedMeta.set(targetProperty, targetInstructions);
+
+        A_CONCEPT_ModulesDeclarationStorage.set(target.constructor, existedMeta);
+    };
+}

package/src/decorators/A-ConceptLifecycle/A-Run/A-Run.decorator.types.ts

@@ -0,0 +1,28 @@
+import { A_TYPES__A_CONCEPT_RootRunParams } from "@adaas/a-concept/global/A-Concept/A_Concept.types"
+import { A_TYPES__ConceptLifecycle_MethodDeclarationConfig } from "../A-ConceptLifecycle.decorator.types"
+
+export type A_TYPES__A_RunDecoratorDescriptor =
+    TypedPropertyDescriptor<(
+        params: A_TYPES__A_CONCEPT_RootRunParams
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+    ) => any>
+    |
+    TypedPropertyDescriptor<(
+        params: A_TYPES__A_CONCEPT_RootRunParams
+    ) => Promise<any>>
+    |
+    TypedPropertyDescriptor<(
+    ) => Promise<any>>
+
+
+export type A_TYPES__A_RunDecoratorConfig = {
+
+} & A_TYPES__ConceptLifecycle_MethodDeclarationConfig
+
+
+export type A_TYPES__A_RunDecoratorStorageInstruction = {
+    handler: string,
+    config: A_TYPES__A_RunDecoratorConfig
+}

package/src/decorators/A-ConceptLifecycle/index.ts

@@ -0,0 +1,9 @@
+import { A_Load } from "./A-Load/A-Load.decorator";
+import { A_Run } from "./A-Run/A-Run.decorator";
+
+
+export const A_Lifecycle = {
+    Load: A_Load,
+    Run: A_Run,
+    Build: A_Run
+}

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

@@ -0,0 +1,13 @@
+
+
+
+
+// export function A_Feature(
+//     params: any = {
+//         name: '',
+//         description: '',
+//         version: '',
+//     }
+// ) {
+//     return A_Pipeline('root.run');
+// }

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

@@ -0,0 +1,75 @@
+import { A_Namespace } from "@adaas/a-concept/global/A-Namespace/A_Namespace.class";
+import { A_Context } from "@adaas/a-concept/global/A-Context/A-Context.class";
+import { A_Component } from "@adaas/a-concept/global/A-Component/A-Component.class";
+
+/**
+ * A-Inject decorator
+ * 
+ * This Decorator allows to inject dependencies into the module like 
+ * - Namespaces 
+ * - Other Concepts 
+ * - or maybe Components
+ * 
+ * @param params 
+ * @returns 
+ */
+export function A_Inject<
+    T extends { new(...args: any[]): A_Component }
+>(
+    component: T
+)
+export function A_Inject<
+    T extends { new(...args: any[]): A_Namespace }
+>(
+    namespace: T
+)
+export function A_Inject<
+    E extends { new(...args: any[]): A_Namespace },
+    T extends Array<E>
+>(
+    namespaces: T
+)
+export function A_Inject<
+    E extends { new(...args: any[]): A_Namespace },
+    K extends { new(...args: any[]): A_Component },
+    T extends Array<E>
+>(
+    param1: T | E | K
+) {
+    switch (true) {
+        case param1 instanceof A_Component:
+            return function (
+                target: T,
+                propertyKey: string | symbol,
+                parameterIndex: number
+            ) {
+                //  It should be just register the parameter in method that will be resolved in the method
+            }
+        case param1 instanceof A_Namespace:
+            return function (
+                target: T,
+                propertyKey: string | symbol,
+                parameterIndex: number
+            ) {
+                //  It should be just register the parameter in method that will be resolved in the method
+            }
+    }
+
+    // const namespaces: Array<typeof A_Namespace> = [
+    //     ...(Array.isArray(param1) ? param1 : [param1])
+    // ];
+
+    // const resolvedNamespaces: Array<A_Namespace> = []
+
+    // for (const namespace of namespaces) {
+    //     resolvedNamespaces.push(A_Context.resolve(namespace));
+    // }
+
+    // return function (
+    //     target: T | E,
+    //     propertyKey: string | symbol,
+    //     parameterIndex: number
+    // ) {
+    //     //  It should be just register the parameter in method that will be resolved in the method
+    // }
+}

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

@@ -0,0 +1,10 @@
+export type A_TYPES__A_InjectDecoratorDescriptor = TypedPropertyDescriptor<(
+    ...args: any[]
+) => Promise<void>>
+
+
+
+export type A_TYPES__A_InjectDecoratorStorageInstruction = {
+    handler: string,
+    // config: A_TYPES__A_InjectDecoratorConfig
+}

package/src/decorators/A_Lazy.decorator.ts

@@ -0,0 +1,31 @@
+function RegisterLazyMethod(
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor
+) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = function (...args: any[]) {
+        console.log(`Intercepted call to method: ${propertyKey}`);
+        console.log(`Arguments: `, args);
+
+        // You can modify args or do something else here
+        const result = originalMethod.apply(this, args);
+
+        // You can also modify the return value
+        console.log(`Result: `, result);
+        return result;
+    };
+
+    return descriptor;
+}
+
+
+
+export function A_Lazy(
+    params: {
+        source: string;
+    }
+) {
+    return RegisterLazyMethod;
+}

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

@@ -0,0 +1,33 @@
+import { A_Namespace } from "../A-Namespace/A_Namespace.class";
+
+
+
+/**
+ * This element only contains the specific code
+ * 
+ */
+export class A_Component<T extends A_Namespace = A_Namespace> {
+
+    constructor(
+        /**
+         * Primary context that impacts the component behavior
+         */
+        protected namespace: A_Namespace
+    ) {
+
+    }
+
+
+
+
+    // constructor(
+    //     private auth: A_AUTH_Context,
+    //     private arc: A_ARC_Context,
+    //     private products: A_PRODUCTS_Context,
+    //     private express: A_EXPRESS_Context,
+    // ) { 
+
+    // }
+
+
+}