@adaas/a-utils 0.0.9 → 0.1.1

package/src/lib/A-Config/components/ConfigReader.component.ts

@@ -0,0 +1,67 @@
+import { A_Component, A_Concept, A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_Config } from "../A-Config.context";
+import { A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY } from "../A-Config.constants";
+import { A_Polyfill } from "../../A-Polyfill/A-Polyfill.component";
+
+/**
+ * Config Reader
+ */
+export class ConfigReader extends A_Component {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Polyfill) protected polyfill: A_Polyfill,
+    ) {
+        super();
+    }
+
+
+    @A_Concept.Load()
+    async inject(
+        @A_Inject(A_Config) config: A_Config,
+    ) {
+
+        const data = await this.read([
+            ...config.CONFIG_PROPERTIES,
+            ...A_CONSTANTS__DEFAULT_ENV_VARIABLES_ARRAY,
+            ...A_CONSTANTS__CONFIG_ENV_VARIABLES_ARRAY
+        ]);
+
+        config.set(data);
+
+        const rootDir = await this.getProjectRoot();
+
+        config.set('A_CONCEPT_ROOT_FOLDER', rootDir);
+    }
+
+
+    /**
+     * Get the configuration property by Name
+     * @param property 
+     */
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return property as _ReturnType;
+    }
+
+    /**
+     * This method reads the configuration and sets the values to the context
+     * 
+     * @returns 
+     */
+    async read<T extends string>(
+        variables: Array<T> = []
+    ): Promise<Record<T, any>> {
+        return {} as Record<T, any>;
+    }
+
+
+    /**
+     * Finds the root directory of the project by locating the folder containing package.json
+     * 
+     * @param {string} startPath - The initial directory to start searching from (default is __dirname)
+     * @returns {string|null} - The path to the root directory or null if package.json is not found
+     */
+    protected async getProjectRoot(startPath = __dirname) {
+        return process.cwd();
+    }
+}

package/src/lib/A-Config/components/ENVConfigReader.component.ts

@@ -0,0 +1,31 @@
+import { A_FormatterHelper } from "@adaas/a-concept";
+import { ConfigReader } from "./ConfigReader.component";
+
+
+export class ENVConfigReader extends ConfigReader {
+
+
+    /**
+     * Get the configuration property Name 
+     * @param property 
+     */
+    getConfigurationProperty_ENV_Alias(property: string): string {
+        return A_FormatterHelper.toUpperSnakeCase(property);
+    }
+
+
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return process.env[this.getConfigurationProperty_ENV_Alias(property)] as _ReturnType;
+    }
+
+
+    async read<T extends string>(variables: Array<T> = []): Promise<Record<T, any>> {
+        const config: Record<T, any> = {} as Record<T, any>;
+
+        variables.forEach(variable => {
+            config[variable] = this.resolve(variable);
+        });
+
+        return config;
+    }
+} 

package/src/lib/A-Config/components/FileConfigReader.component.ts

@@ -0,0 +1,42 @@
+import { A_Context, A_FormatterHelper } from "@adaas/a-concept";
+import { ConfigReader } from "./ConfigReader.component";
+
+export class FileConfigReader extends ConfigReader {
+
+    private FileData: Map<string, any> = new Map<string, any>();
+
+    /**
+     * Get the configuration property Name
+     * @param property 
+     */
+    getConfigurationProperty_File_Alias(property: string): string {
+        return A_FormatterHelper.toCamelCase(property);
+    }
+
+
+    resolve<_ReturnType = any>(property: string): _ReturnType {
+        return this.FileData.get(this.getConfigurationProperty_File_Alias(property)) as _ReturnType;
+    }
+
+
+    async read<T extends string>(
+        variables?: Array<T>
+    ): Promise<Record<T, any>> {
+
+        const fs = await this.polyfill.fs();
+
+        try {
+            const data = fs.readFileSync(`${A_Context.concept}.conf.json`, 'utf8');
+
+            const config: Record<T, any> = JSON.parse(data);
+
+            this.FileData = new Map(Object.entries(config));
+
+            return config;
+
+        } catch (error) {
+            // this.context.Logger.error(error);
+            return {} as Record<T, any>;
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+import { A_Component, A_Error, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_Config } from "../A-Config/A-Config.context";
+
+
+
+export class A_Logger extends A_Component {
+
+    constructor(
+        @A_Inject(A_Scope) protected scope: A_Scope,
+        @A_Inject(A_Config) protected config: A_Config
+    ) {
+        super();
+    }
+
+    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'
+            )
+        ]
+    }
+
+    protected get allowedToLog() {
+        return this.config.get('CONFIG_VERBOSE') !== undefined
+            && this.config.get('CONFIG_VERBOSE') !== 'false'
+            && this.config.get('CONFIG_VERBOSE') !== false
+    }
+
+
+    log(
+        color: keyof typeof this.colors,
+        ...args: any[]
+    )
+    log(
+        ...args: any[]
+    )
+    log(
+        param1: any,
+        ...args: any[]
+    ) {
+        if (!this.allowedToLog)
+            return;
+
+        if (typeof param1 === 'string' && this.colors[param1]) {
+            console.log(...this.compile(param1 as keyof typeof this.colors, ...args));
+            return;
+        }
+        else {
+            console.log(...this.compile('blue', param1, ...args));
+        }
+    }
+
+    warning(...args) {
+        if (!this.allowedToLog)
+            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/lib/A-Memory/A-Memory.context.ts

@@ -0,0 +1,115 @@
+import { A_Error, A_Fragment } from "@adaas/a-concept";
+
+
+export class A_Memory<
+    _MemoryType extends Record<string, any> = Record<string, any>,
+    _SerializedType extends Record<string, any> = Record<string, any>
+> extends A_Fragment {
+
+
+    /**
+     * Internal storage of all intermediate values
+     */
+    protected _memory: Map<keyof _MemoryType, _MemoryType[keyof _MemoryType]>;
+    /**
+     * Errors encountered during the execution
+     */
+    protected _errors: Set<A_Error>;
+
+
+
+    /**
+     * Memory object that allows to store intermediate values and errors
+     * 
+     * @param initialValues 
+     */
+    constructor(initialValues?: _MemoryType) {
+        super();
+        this._memory = new Map(Object.entries(initialValues || {}));
+        this._errors = new Set();
+    }
+
+
+    get Errors(): Set<A_Error> | undefined {
+        return this._errors.size > 0 ? this._errors : undefined;
+    }
+
+
+    /**
+     * Verifies that all required keys are present in the proxy values
+     * 
+     * @param requiredKeys 
+     * @returns 
+     */
+    async verifyPrerequisites(
+        requiredKeys: Array<keyof _MemoryType>
+    ): Promise<boolean> {
+        return requiredKeys.every(key => this._memory.has(key));
+    }
+
+    /**
+     * Adds an error to the context
+     * 
+     * @param error 
+     */
+    async error(error: A_Error): Promise<void> {
+        this._errors.add(error);
+    }
+
+    /**
+     * Saves a value in the context memory
+     * 
+     * @param key 
+     * @param value 
+     */
+    async set<K extends keyof _MemoryType>(
+        /**
+         * Key to save the value under
+         */
+        key: K,
+        /**
+         * Value to save
+         */
+        value: _MemoryType[K]
+    ): Promise<void> {
+        this._memory.set(key, value);
+    }
+
+
+    /**
+     * Removes a value from the context memory by key
+     * 
+     * @param key 
+     */
+    async drop(key: keyof _MemoryType): Promise<void> {
+        this._memory.delete(key);
+    }
+
+    /**
+     * Clears all stored values in the context memory
+     */
+    async clear(): Promise<void> {
+        this._memory.clear();
+    }
+
+
+    /**
+     * Converts all stored values to a plain object
+     * 
+     * [!] By default uses all saved in memory values 
+     * 
+     * @returns 
+     */
+    toJSON(): _SerializedType {
+        const obj: Record<string, any> = {};
+
+        this._memory.forEach((value, key) => {
+            obj[key as string] =
+                typeof value === 'object' && value !== null && 'toJSON' in value && typeof value.toJSON === 'function'
+                    ? value.toJSON()
+                    : value;
+        });
+
+        return obj as _SerializedType;
+    }
+}

package/src/lib/A-Polyfill/A-Polyfill.component.ts

@@ -0,0 +1,45 @@
+import { A_Component } from "@adaas/a-concept";
+import { A_PolyfillClass } from "./A-Polyfills.class";
+
+
+
+export class A_Polyfill extends A_Component {
+
+    protected _polyfill!: A_PolyfillClass;
+
+    async load() {
+        this._polyfill = new A_PolyfillClass();
+
+        await this._polyfill.fs();
+        await this._polyfill.crypto();
+    }
+
+
+    /**
+     * Allows to use the 'fs' polyfill methods regardless of the environment
+     * This method loads the 'fs' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async fs() {
+        if (!this._polyfill) {
+            await this.load();
+        }
+
+        return await this._polyfill.fs();
+    }
+
+    /**
+     * Allows to use the 'crypto' polyfill methods regardless of the environment
+     * This method loads the 'crypto' polyfill and returns its instance
+     * 
+     * @returns 
+     */
+    async crypto() {
+        if (!this._polyfill) {
+            await this.load();
+        }
+
+        return await this._polyfill.crypto();
+    }
+}

package/src/lib/A-Polyfill/A-Polyfill.types.ts

@@ -0,0 +1,10 @@
+interface Ifspolyfill {
+    readFileSync: (path: string, encoding: string) => string;
+    existsSync: (path: string) => boolean;
+    createReadStream: (path: string, options?: BufferEncoding) => any
+}
+
+interface IcryptoInterface {
+    createTextHash(text: string, algorithm: string): Promise<string>
+    createFileHash(filePath: string, algorithm: string): Promise<string>
+}

package/src/{global/A_Polyfills.ts → lib/A-Polyfill/A-Polyfills.class.ts}

@@ -1,19 +1,10 @@
-interface Ifspolyfill {
-    readFileSync: (path: string, encoding: string) => string;
-    existsSync: (path: string) => boolean;
-    createReadStream: (path: string, options?: BufferEncoding) => any
-}
 
-interface ICryptoInterface {
-    createTextHash(text: string, algorithm: string): Promise<string>
-    createFileHash(filePath: string, algorithm: string): Promise<string>
-}
 
 
-class A_PolyfillsClass {
+export class A_PolyfillClass {
 
     private _fs!: Ifspolyfill;
-    private _crypto!: ICryptoInterface;
+    private _crypto!: IcryptoInterface;
 
     // eslint-disable-next-line no-use-before-define
     private fsName = 'fs'
@@ -104,9 +95,4 @@ class A_PolyfillsClass {
             };
         }
     }
-
-
 }
-
-
-export const A_Polyfills = new A_PolyfillsClass();

package/src/{global/A_Deferred.class.ts → lib/A-Schedule/A-Deferred.class.ts}

@@ -3,6 +3,10 @@ export class A_Deferred<T> {
     private resolveFn!: (value: T | PromiseLike<T>) => void;
     private rejectFn!: (reason?: any) => void;
 
+    /**
+     * Creates a deferred promise
+     * @returns A promise that can be resolved or rejected later
+     */
     constructor() {
         this.promise = new Promise<T>((resolve, reject) => {
             this.resolveFn = resolve;

package/src/lib/A-Schedule/A-Schedule.component.ts

@@ -0,0 +1,89 @@
+import { A_Component, A_TypeGuards } from "@adaas/a-concept";
+import { A_ScheduleObject } from "./A-ScheduleObject.class";
+import { A_UTILS_TYPES__ScheduleObjectCallback, A_UTILS_TYPES__ScheduleObjectConfig } from "./A-Schedule.types";
+
+
+
+export class A_Schedule extends A_Component {
+
+    /**
+     * Allows to schedule a callback for particular time in the future
+     * 
+     * @param timestamp - Unix timestamp in milliseconds
+     * @param callback - The callback to execute
+     * @returns A promise that resolves to the schedule object
+     */
+    async schedule<T extends any = any>(
+        /**
+         * Unix timestamp in milliseconds
+         */
+        timestamp: number,
+        /**
+         * The callback to execute
+         */
+        callback: A_UTILS_TYPES__ScheduleObjectCallback<T>,
+        /**
+         * Configuration options for the schedule object
+         */
+        config?: A_UTILS_TYPES__ScheduleObjectConfig
+    ): Promise<A_ScheduleObject<T>>
+    async schedule<T extends any = any>(
+        /**
+         * ISO date string representing the date and time to schedule the callback for
+         */
+        date: string,
+        /**
+         * The callback to execute
+         */
+        callback: A_UTILS_TYPES__ScheduleObjectCallback<T>,
+        /**
+        * Configuration options for the schedule object
+        */
+        config?: A_UTILS_TYPES__ScheduleObjectConfig
+    ): Promise<A_ScheduleObject<T>>
+    async schedule<T extends any = any>(
+        date: string | number,
+        callback: A_UTILS_TYPES__ScheduleObjectCallback<T>,
+        config?: A_UTILS_TYPES__ScheduleObjectConfig
+    ): Promise<A_ScheduleObject<T>> {
+
+        const timestamp = A_TypeGuards.isString(date)
+            ? (new Date(date)).getTime()
+            : date;
+
+        return new A_ScheduleObject<T>(
+            timestamp - Date.now(),
+            callback,
+            config
+        );
+    }
+
+
+
+    /**
+     * Allows to execute callback after particular delay in milliseconds
+     * So the callback will be executed after the specified delay
+     * 
+     * @param ms 
+     */
+    async delay<T extends any = any>(
+        /**
+         * Delay in milliseconds
+         */
+        ms: number,
+        /**
+         * The callback to execute after the delay
+         */
+        callback: A_UTILS_TYPES__ScheduleObjectCallback<T>,
+        /**
+        * Configuration options for the schedule object
+        */
+        config?: A_UTILS_TYPES__ScheduleObjectConfig
+    ): Promise<A_ScheduleObject<T>> {
+        return new A_ScheduleObject<T>(
+            ms,
+            callback,
+            config
+        );
+    }
+}

package/src/{types/A_ScheduleObject.types.ts → lib/A-Schedule/A-Schedule.types.ts}

@@ -1,4 +1,6 @@
-export type A_TYPES__ScheduleObjectConfig = {
+
+
+export type A_UTILS_TYPES__ScheduleObjectConfig = {
     /**
      * If the timeout is cleared, should the promise resolve or reject?
      * BY Default it rejects
@@ -6,4 +8,7 @@ export type A_TYPES__ScheduleObjectConfig = {
      * !!!NOTE: If the property is set to true, the promise will resolve with undefined
      */
     resolveOnClear: boolean;
-}
+};
+
+
+export type A_UTILS_TYPES__ScheduleObjectCallback<T> = () => Promise<T>;