@adaas/a-utils 0.0.2

package/src/helpers/A_Common.helper.ts

@@ -0,0 +1,229 @@
+import { A_TYPES__DeepPartial } from "../types/A_Common.types";
+
+export class A_CommonHelper {
+
+    static resolve() {
+        return new Promise<undefined>((resolve) => resolve(undefined));
+    }
+
+    static omitArrayProperties<T, S extends string>(array: Array<T>, fields: string[]): Omit<T, S>[] {
+
+        return array;
+    }
+
+    static sanitizeHTML(html: string): string {
+        // Define the regular expression pattern to match all tags except <span>
+        const regex = /<(?!\/?span(?=>|\s.*>))\/?.*?>/g;
+
+        // Replace all matched tags with an empty string
+        return html.replace(regex, '');
+    }
+
+
+    /**
+     *  Omit properties from an object or array with nested objects
+     * 
+     * @param input 
+     * @param paths 
+     * @returns 
+     */
+    static omitProperties<T, S extends string>(
+        input: T,
+        paths: string[]
+
+    ): Omit<T, S> {
+
+        // Deep clone the input object or array
+        const result = JSON.parse(JSON.stringify(input));
+
+        // Helper function to recursively remove properties
+        function removeProperties(target: Record<string, any> | any[], currPath: string[]) {
+            const currKey = currPath[0];
+            if (currPath.length === 1) {
+                // If current path has only one key, delete the property
+                delete target[currKey];
+            } else if (target[currKey] !== undefined && typeof target[currKey] === 'object') {
+                // If current key exists and is an object, recursively call removeProperties
+                removeProperties(target[currKey], currPath.slice(1));
+            }
+        }
+
+        // Iterate through each path and remove corresponding properties from the result
+        paths.forEach(path => {
+            const pathKeys = path.split('.');
+            removeProperties(result, pathKeys);
+        });
+
+        return result as Omit<T, S>;
+    }
+
+
+    /**
+     *  Format a number with leading zeros to a fixed length
+     * 
+     * @param number 
+     * @param maxZeros 
+     * @returns 
+     */
+    static formatWithLeadingZeros(number, maxZeros = 10) {
+        const formattedNumber = String(number).padStart(maxZeros + 1, '0');
+        return formattedNumber.slice(-maxZeros);
+    }
+
+    /**
+     * Remove leading zeros from a formatted number
+     */
+    static removeLeadingZeros(formattedNumber) {
+        return String(Number(formattedNumber)); // Convert to number and back to string to remove leading zeros
+    }
+
+
+
+    static toUpperSnakeCase(str: string): string {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1_$2')  // Handle lowercase followed by uppercase
+            .replace(/[-\s]([A-Z])/g, '_$1')      // Handle non-alphabetical followed by uppercase
+            .replace('-', '_')
+            .toUpperCase();
+    }
+
+    static toCamelCase(str: string): string {
+        return str.toLowerCase().replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+    }
+
+
+
+    static isObject(item: any): boolean {
+        return item !== null && typeof item === 'object' && !Array.isArray(item);
+    }
+
+    static deepMerge<T = any>(target: any, source: any, visited = new Map<any, any>()): T {
+        if (this.isObject(target) && this.isObject(source)) {
+            for (const key in source) {
+                if (this.isObject(source[key])) {
+                    if (!target[key]) {
+                        target[key] = {};
+                    }
+                    // Check if the source object has already been visited
+                    if (!visited.has(source[key])) {
+                        visited.set(source[key], {});
+                        this.deepMerge(target[key], source[key], visited);
+                    } else {
+                        target[key] = visited.get(source[key]);
+                    }
+                } else {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    }
+
+
+    static deepClone<T>(target: T): T {
+        // Check if the value is null or undefined
+        if (target === null || target === undefined) {
+            return target;
+        }
+
+        // Handle primitive types (string, number, boolean, etc.)
+        if (typeof target !== 'object') {
+            return target;
+        }
+
+        // Handle Date
+        if (target instanceof Date) {
+            return new Date(target.getTime()) as T;
+        }
+
+        // Handle Array
+        if (Array.isArray(target)) {
+            return target.map(item => this.deepClone(item)) as unknown as T;
+        }
+
+        // Handle Function
+        if (typeof target === 'function') {
+            return target;
+        }
+
+        // Handle Object
+        if (target instanceof Object) {
+            const clone = {} as T;
+            for (const key in target) {
+                if (target.hasOwnProperty(key)) {
+                    clone[key] = this.deepClone(target[key]);
+                }
+            }
+            return clone;
+        }
+
+        // For any other cases
+        throw new Error('Unable to clone the object. Unsupported type.');
+    }
+
+
+    static deepCloneAndMerge<T>(target: A_TYPES__DeepPartial<T>, source: T): T {
+        if (
+            (source === null || source === undefined) &&
+            (target === null || target === undefined))
+            return target;
+
+        // Check if the value is null or undefined
+        if ((target === null || target === undefined) &&
+            source
+        ) {
+            return this.deepClone(source);
+        }
+
+        // Handle primitive types (string, number, boolean, etc.)
+        if (typeof target !== 'object') {
+            return target
+        }
+
+
+        // Handle Date
+        if (target instanceof Date) {
+            return new Date(target.getTime()) as T;
+        }
+
+        // Handle Array
+        if (Array.isArray(target)) {
+            return target.map(item => this.deepCloneAndMerge(item, source)) as unknown as T;
+        }
+
+        // Handle Function
+        if (typeof target === 'function') {
+            return target;
+        }
+
+        // Handle Object
+        if (target instanceof Object) {
+            const clone = {} as T;
+            for (const key in target) {
+                if (
+                    source[key] !== null
+                    &&
+                    source[key] !== undefined
+                )
+                    clone[key] = this.deepCloneAndMerge(target[key as any], source[key]);
+                else
+                    clone[key as any] = this.deepClone(target[key]);
+            }
+
+            for (const key in source) {
+                if (
+                    target[key] !== undefined
+                    &&
+                    target[key] !== null
+                )
+                    clone[key] = this.deepCloneAndMerge(target[key], source[key]);
+                else
+                    clone[key] = this.deepClone(source[key]);
+            }
+            return clone;
+        }
+
+        // For any other cases
+        throw new Error('Unable to clone the object. Unsupported type.');
+    }
+}

package/src/helpers/A_Schedule.helper.ts

@@ -0,0 +1,25 @@
+import { A_ScheduleObject } from "../global/A_ScheduleObject.class";
+import { A_TYPES__ScheduleObjectConfig } from "../types/A_ScheduleObject.types";
+
+export class A_ScheduleHelper {
+
+    static delay<T = void>(ms = 1000, resolver?: Promise<T>) {
+        return new Promise<T>((resolve, reject) => setTimeout(() => {
+            if (resolver) {
+                resolver.then(resolve).catch(reject);
+            }
+            else {
+                resolve(0 as T);
+            }
+        }, ms))
+    }
+
+
+    static schedule<T = void>(
+        ms = 1000,
+        resolver: () => Promise<T>,
+        config?: A_TYPES__ScheduleObjectConfig
+    ): A_ScheduleObject<T> {
+        return new A_ScheduleObject<T>(ms, resolver, config);
+    }
+}

package/src/types/ASEID.types.ts

@@ -0,0 +1,86 @@
+export interface A_TYPES__ASEID_Constructor {
+
+    /**
+     * Namespace for the ASEID 
+     * Generally it is the application name or code, should correspond to the namespace of the application
+     * Could be ID or ASEID
+     */
+    namespace?: string,
+
+    /**
+     * Entity Scope the primary location of the resource 
+     * Organization, or organization Unit
+     * Could be ID or ASEID
+     * 
+     */
+    scope: number | string
+
+    /**
+     * Entity Type the type of the resource
+     */
+    entity: string
+
+    /**
+     * Entity ID the unique identifier of the resource
+     */
+    id: number | string
+
+
+    /**
+     * Version of the entity (optional)
+     */
+    version?: string
+
+    /**
+     * Shard of the entity (optional)
+     */
+    shard?: string
+};
+
+
+export interface A_TYPES__ASEID_ConstructorConfig {
+
+
+    /**
+     * If true, the entity ASEID will be distributed across multiple shards.
+     * In this case SHARD should be provided via Environment Variables (A_SHARD) or Configurations
+     * 
+     */
+    sharding?: boolean
+};
+
+
+
+
+export type A_TYPES__ASEID_JSON = {
+    /**
+     * Namespace for the ASEID
+     */
+    namespace: string,
+
+    /**
+     * Entity Scope the primary location of the resource
+     */
+    scope: string,
+
+    /**
+     * Entity Type the type of the resource
+     */
+    entity: string,
+
+    /**
+     * Entity ID the unique identifier of the resource
+     */
+    id: string,
+
+    /**
+     * Version of the entity (optional)
+     */
+    version?: string,
+
+    /**
+     * Shard of the entity (optional)
+     */
+    shard?: string
+}
+

package/src/types/A_Common.types.ts

@@ -0,0 +1,111 @@
+export type A_AUTH_RequestParam = {
+    id?: string,
+    /**
+     * The issuer of the parameter. Could be system, custom, proxy, credentials or SIC to data provider service(e.g. CSS)
+     */
+    issuer?: 'system' | 'custom' | 'proxy' | 'credentials' | string;
+    /**
+     * Common internal value, uses for proper mapping
+     */
+    key?: string,
+    /**
+     * Allows to define the type of the parameter to convert input during the execution
+     */
+    type: 'json' | 'array' | 'number' | 'string' | 'boolean' | 'base_64' | 'file' | 'file_url';
+    /**
+     * The name of the parameter
+     */
+    name: string,
+    /**
+     * The value of the parameter
+     */
+    value: string
+}
+
+
+
+
+
+// =======================================================
+// ==================== COMMON TYPES =====================
+// =======================================================
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type Decrement = [never, 0, 1, 2, 3, 4, 5];
+
+export type A_TYPES__DeepPartial<T, D extends number = 5> = {
+    [P in keyof Required<T>]?:
+    [D] extends [never] ? any :
+
+    Required<T>[P] extends Array<infer U>
+    ? Array<A_TYPES__DeepPartial<U, Decrement[D]>>
+
+    : Required<T>[P] extends Function
+    ? Required<T>[P]
+
+    : Required<T>[P] extends object
+    ? A_TYPES__DeepPartial<T[P], Decrement[D]>
+    : T[P]
+};
+
+
+// export type A_TYPES__DeepPartial<T> = {
+//     [P in keyof Required<T>]?: Required<T>[P] extends object ? A_TYPES__DeepPartial<T[P]> : T[P];
+// };
+
+export type A_TYPES__ObjectKeyEnum<T, E> = {
+    [P in keyof Required<T>]?: T[P] extends object ? A_TYPES__ObjectKeyEnum<T[P], E> : E;
+};
+
+
+export type A_TYPES__Dictionary<T> = {
+    [Key: string]: T;
+}
+
+
+export type A_TYPES__NonObjectPaths<T> = T extends object ? { [K in keyof T]:
+    `${Exclude<K, symbol>}${""}`
+}[keyof T] : never
+
+
+
+
+export type A_TYPES__Paths<T, D extends number = 5> = [D] extends [never] ? never : (
+    T extends object ? { [K in keyof T]:
+        `${Exclude<K, symbol>}${"" | `.${A_TYPES__Paths<T[K], Decrement[D]>}`}`
+    }[keyof T] : never
+);
+
+export type A_TYPES__UnionToIntersection<U> =
+    (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+
+export type A_TYPES__PathsToObject<_Obj, T extends readonly string[]> = A_TYPES__UnionToIntersection<
+    {
+        [K in keyof T]: T[K] extends `${infer Key}.${infer Rest}`
+        ? { [P in Key]: P extends keyof _Obj
+            ? A_TYPES__PathsToObject<Required<_Obj>[P], [Rest]>
+            : any
+
+        }
+        : { [P in T[K]]:
+            `${T[K]}` extends keyof Required<_Obj> ? Required<_Obj>[`${T[K]}`] : never
+        };
+    }[number]
+>;
+
+export type A_TYPES__Required<T, arr extends (A_TYPES__Paths<T>)[] = (A_TYPES__Paths<T>)[]> = A_TYPES__PathsToObject<T, arr> & T;
+
+
+export type A_TYPES__ExtractNested<T, P extends string> = P extends `${infer K}.${infer Rest}`
+    ? K extends keyof T
+    ? { [Key in K]: A_TYPES__ExtractNested<T[K], Rest> }
+    : never
+    : P extends keyof T
+    ? { [Key in P]: T[P] }
+    : never;
+
+
+export type A_TYPES__ExtractProperties<T, P extends A_TYPES__Paths<T>[]> = A_TYPES__UnionToIntersection<{
+    [K in keyof P]: P[K] extends string ? A_TYPES__ExtractNested<T, P[K]> : never
+}[number]>;

package/src/types/A_Entity.types.ts

@@ -0,0 +1,17 @@
+import { ASEID } from "../global/ASEID.class";
+
+export interface A_TYPES__IAEntity {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: ASEID
+};
+
+
+export type A_TYPES__AEntity_JSON = {
+    /**
+     * The ASEID of the entity
+     */
+    aseid: string
+};
+

package/src/types/A_Error.types.ts

@@ -0,0 +1,10 @@
+export type A_TYPES__Error = {
+    message: string;
+    code: string;
+    description: string
+
+    link?: string,
+    originalError?: Error | unknown
+}
+
+

package/src/types/A_ScheduleObject.types.ts

@@ -0,0 +1,9 @@
+export type A_TYPES__ScheduleObjectConfig = {
+    /**
+     * If the timeout is cleared, should the promise resolve or reject?
+     * BY Default it rejects
+     * 
+     * !!!NOTE: If the property is set to true, the promise will resolve with undefined
+     */
+    resolveOnClear: boolean;
+}

package/src/types/A_ServerError.types.ts

@@ -0,0 +1,7 @@
+import { A_TYPES__Error } from "./A_Error.types";
+
+export type A_TYPES__ServerError = {
+
+    serverCode: number,
+
+} & A_TYPES__Error

package/tests/default.test.ts

@@ -0,0 +1,160 @@
+import { A_CommonHelper } from '@adaas/a-utils/helpers/A_Common.helper';
+import { A_ScheduleHelper } from '@adaas/a-utils/helpers/A_Schedule.helper';
+import { A_TYPES__DeepPartial } from '@adaas/a-utils/types/A_Common.types';
+import { config } from 'dotenv';
+config();
+jest.retryTimes(0);
+
+describe('CommonHelper Tests', () => {
+
+    it('Schedule Should execute promise and await it ', async () => {
+
+        const start = Date.now();
+        let res = '';
+
+        try {
+            const scheduler = A_ScheduleHelper.schedule(3000, async () => {
+                return 'RESOLVED';
+            });
+
+
+            res = await scheduler.promise;
+
+        } catch (error) {
+            // Handle error if any
+        } finally {
+            const end = Date.now();
+            const duration = end - start;
+
+            expect(res).toBe('RESOLVED');
+            // Check if the duration exceeds 3 seconds
+            expect(duration).toBeGreaterThan(3000);
+        }
+
+    });
+
+    it('Schedule Should be canceled and rejected', async () => {
+
+        const start = Date.now();
+        let res = '';
+
+        try {
+            const scheduler = A_ScheduleHelper.schedule(3000, async () => {
+                return 'RESOLVED';
+            });
+
+
+            scheduler.clear();
+            res = await scheduler.promise;
+        } catch (error) {
+            // Handle error if any
+        } finally {
+            const end = Date.now();
+            const duration = end - start;
+
+            expect(res).toBe('');
+            // Check if the duration exceeds 3 seconds
+            expect(duration).toBeLessThan(3000);
+        }
+
+    });
+
+    it('Deep Clone and  Merge ', async () => {
+
+        type TestType = {
+            a: string,
+            b: string,
+            c: {
+                d: string
+            },
+            f: (name: string) => string
+            s: Date
+        }
+
+        const t: TestType = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd'
+            },
+            f: (name: string) => { return name },
+            s: new Date()
+        }
+
+        const t2: A_TYPES__DeepPartial<TestType> = {
+            a: 'aa',
+            c: {
+                d: 'dd'
+            },
+            f: (name: string) => { return name + '2' }
+        }
+
+        const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+
+        const name = merged.f('names');
+
+
+        expect(merged.a).toBe('aa');
+        expect(merged.b).toBe('b');
+        expect(merged.c.d).toBe('dd');
+        expect(name).toBe('names2');
+        expect(t).not.toEqual(merged);
+        expect(t2).not.toEqual(merged);
+    });
+
+    it('Deep Clone Different Types', async () => {
+
+        type TestType = {
+            a: string,
+            b: string,
+            c: {
+                d: string
+            },
+            bool:{
+                a: boolean
+            },
+            f: (name: string) => string
+            s: Date
+        }
+
+        const t: TestType = {
+            a: 'a',
+            b: 'b',
+            c: {
+                d: 'd'
+            },
+            bool:{
+                a: true
+            },
+            f: (name: string) => { return name },
+            s: new Date()
+        }
+
+        const t2: any = {
+            e: 'foo',
+            b: 'bb',
+            c:{
+                d: 'ddd'
+            },
+            bool:{
+                a: false
+            },
+            some: {
+                d: 'dd'
+            },
+        }
+
+        const merged = A_CommonHelper.deepCloneAndMerge(t2, t);
+
+        console.log('merged: ', merged)
+
+        expect(merged.a).toBe('a');
+        expect(merged.b).toBe('bb');
+        expect(merged.c.d).toBe('ddd');
+        expect(merged.bool.a).toBe(false);
+        expect((merged as any).e).toBe('foo');
+        expect((merged as any).some.d).toBe('dd');
+        expect(merged.f('names')).toBe('names');
+    });
+});

package/tests/polyfill.test.ts

@@ -0,0 +1,37 @@
+import { config } from 'dotenv';
+import { A_Polyfills } from '../src/global/A_Polyfills'
+config();
+jest.retryTimes(0);
+
+describe('Polyfill Tests', () => {
+
+    it('It Should return fs', async () => {
+
+        const fs = await A_Polyfills.fs();
+
+
+        console.log('fs: ', fs)
+
+
+    });
+    it('It Should return crypto', async () => {
+
+        const crypto = await A_Polyfills.crypto();
+
+        console.log('crypto: ', crypto)
+
+    });
+
+    it('Crypto should calculate Hash', async () => {
+
+        const crypto = await A_Polyfills.crypto();
+
+        const hash = await crypto.createFileHash('./index.ts', 'sha-256');
+
+        console.log('hash: ', hash)
+
+        
+    });
+
+
+});