@adaas/a-utils 0.0.2

package/src/global/ASEID.class.ts

@@ -0,0 +1,208 @@
+import { A_CONSTANTS__DEFAULT_ERRORS } from "../constants/errors.constants";
+import { A_CommonHelper } from "../helpers/A_Common.helper";
+import { A_TYPES__ASEID_Constructor, A_TYPES__ASEID_JSON } from "../types/ASEID.types";
+import { A_Error } from "./A_Error.class";
+
+
+/**
+ *  A - ADAAS
+ *  S - System 
+ *  E - Entity
+ *  I - Identifier
+ *  D - iDentifier
+ * 
+ * 
+ *  adaas-sso@scope:usr:0000000001
+ * 
+ *  APP_NAMESPACE + @ + SCOPE + : ENTITY_NAME + : + ID + @ + VERSION 
+ */
+export class ASEID {
+
+    static regexp: RegExp = new RegExp(`^[a-z|A-Z|0-9]+@[a-z|A-Z|0-9|-]+:[a-z|A-Z]+:[a-z|A-Z|0-9|-]+(@v[0-9]+|@lts)?$`)
+
+
+    /**
+     * 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
+     */
+    private _namespace!: string;
+
+    /**
+     * Entity Scope the primary location of the resource 
+     * Organization, or organization Unit
+     * Could be ID or ASEID
+     * 
+     */
+    private _scope!: string
+
+    /**
+     * Entity Type the type of the resource
+     */
+    private _entity!: string
+
+    /**
+     * Entity ID the unique identifier of the resource
+     */
+    private _id!: string
+
+
+    /**
+     * Version of the entity (optional)
+     */
+    private _version?: string
+
+    /**
+     * Shard of the entity (optional)
+     */
+    private _shard?: string
+
+
+    constructor(
+        aseid: string
+    )
+    constructor(
+        props: A_TYPES__ASEID_Constructor
+    )
+    constructor(param1: string | A_TYPES__ASEID_Constructor) {
+
+        if (typeof param1 === 'string' && !ASEID.isASEID(param1)) {
+            throw new A_Error(A_CONSTANTS__DEFAULT_ERRORS.INVALID_ASEID)
+        }
+
+        const aseidString = typeof param1 === 'string' ? param1 : ASEID.generateASEID(param1);
+
+        const { namespace, scope, entity, id, version, shard } = ASEID.parseASEID(aseidString);
+
+        this._namespace = namespace;
+        this._scope = scope;
+        this._entity = entity;
+        this._id = id;
+        this._version = version;
+        this._shard = shard;
+    }
+
+
+    get namespace(): string {
+        return this._namespace;
+    }
+
+    get scope(): string {
+        return this._scope;
+    }
+
+    get entity(): string {
+        return this._entity;
+    }
+
+    get id(): string {
+        return this._id;
+    }
+
+    get version(): string | undefined {
+        return this._version;
+    }
+
+    get shard(): string | undefined {
+        return this._shard;
+    }
+
+
+    /**
+     * Tests if the identity string is an ASEID
+     * 
+     * @param identity 
+     * @returns 
+     */
+    static isASEID(identity: string): boolean {
+        return this.regexp.test(
+            identity
+        )
+    }
+
+    /**
+  * Generate an ASEID from a namespace, entity, and id
+  * 
+  * @param props 
+  * @returns 
+  */
+    static generateASEID(
+        props: A_TYPES__ASEID_Constructor
+    ): string {
+
+        const namespace = props.namespace
+            ? this.isASEID(props.namespace)
+                ? this.parseASEID(props.namespace).id
+                : props.namespace
+            : process.env.A_NAMESPACE;
+
+        const scope = typeof props.scope === 'number'
+            ? A_CommonHelper.formatWithLeadingZeros(props.scope) :
+            this.isASEID(props.scope)
+                ? this.parseASEID(props.scope).id
+                : props.scope;
+
+        const entity = props.entity;
+
+        const id = typeof props.id === 'number'
+            ? A_CommonHelper.formatWithLeadingZeros(props.id)
+            : props.id;
+
+        const version = props.version;
+
+        const shard = !props.shard ? undefined : props.shard;
+
+
+        return `${namespace}@${scope}:${entity}:${shard ? (shard + '--' + id) : id}${version ? ('@' + version) : ''}`
+    }
+
+
+    /**
+     * Parse ASEID into its components
+     * 
+     * 
+     * @param identity 
+     * @returns 
+     */
+    static parseASEID(identity: string): A_TYPES__ASEID_JSON {
+
+        const [namespace, body, version] = identity.split('@');
+        const [scope, entity, idCandidate] = body.split(':');
+
+        const shard = idCandidate.includes('--') ? idCandidate.split('--')[0] : undefined;
+        const id = idCandidate.includes('--') ? idCandidate.split('--')[1] : idCandidate;
+
+        return {
+            namespace,
+            scope: scope,
+            entity,
+            id: id,
+            version: version ? version : undefined,
+            shard
+        };
+    }
+
+
+    toString(): string {
+        return ASEID.generateASEID({
+            namespace: this._namespace,
+            scope: this._scope,
+            entity: this._entity,
+            id: this._id,
+            version: this._version,
+            shard: this._shard
+        })
+    }
+
+
+    toJSON(): A_TYPES__ASEID_JSON {
+        return {
+            namespace: this._namespace,
+            scope: this._scope,
+            entity: this._entity,
+            id: this._id,
+            version: this._version,
+            shard: this._shard
+        }
+    }
+}

package/src/global/A_Deferred.class.ts

@@ -0,0 +1,20 @@
+export class A_Deferred<T> {
+    public promise: Promise<T>;
+    private resolveFn!: (value: T | PromiseLike<T>) => void;
+    private rejectFn!: (reason?: any) => void;
+
+    constructor() {
+        this.promise = new Promise<T>((resolve, reject) => {
+            this.resolveFn = resolve;
+            this.rejectFn = reject;
+        });
+    }
+
+    resolve(value: T | PromiseLike<T>): void {
+        this.resolveFn(value);
+    }
+
+    reject(reason?: any): void {
+        this.rejectFn(reason);
+    }
+}

package/src/global/A_Entity.class.ts

@@ -0,0 +1,134 @@
+import { A_CONSTANTS__DEFAULT_ERRORS } from "../constants/errors.constants";
+import {
+    A_TYPES__AEntity_JSON,
+    A_TYPES__IAEntity
+} from "../types/A_Entity.types";
+import { A_Error } from "./A_Error.class";
+import { ASEID } from "./ASEID.class";
+
+export class A_Entity<
+    _ConstructorType = any,
+    _SerializedType extends A_TYPES__AEntity_JSON = A_TYPES__AEntity_JSON,
+>
+    implements A_TYPES__IAEntity {
+
+    aseid!: ASEID;
+
+
+    constructor(
+        aseid: string
+    )
+    constructor(
+        aseid: ASEID
+    )
+    constructor(
+        serialized: _SerializedType
+    )
+    constructor(
+        newEntity: _ConstructorType
+    )
+    constructor(props: string | ASEID | _SerializedType | _ConstructorType) {
+
+        switch (true) {
+            case (typeof props === 'string' && ASEID.isASEID(props)):
+                this.aseid = new ASEID(props);
+                break;
+            case (props instanceof ASEID):
+                this.aseid = props;
+                break;
+            case (typeof props === 'object' && (props as any).aseid):
+                this.fromSerialized(props as _SerializedType);
+                break;
+
+            case (typeof props === 'object'):
+                this.fromNewEntity(props as _ConstructorType);
+                break
+
+            default:
+                throw new A_Error(A_CONSTANTS__DEFAULT_ERRORS.INCORRECT_A_ENTITY_CONSTRUCTOR);
+        }
+
+    }
+
+    // ====================================================================
+    // ================== DUPLICATED ASEID Getters ========================
+    // ====================================================================
+
+    /**
+     * Extracts the ID from the ASEID
+     * ID is the unique identifier of the entity
+     */
+    get id(): string | number {
+        return this.aseid.id;
+    }
+
+    /**
+     * Extracts the namespace from the ASEID
+     * namespace is an application specific identifier from where the entity is coming from
+     */
+    get namespace(): string {
+        return this.aseid.namespace
+    }
+
+    /**
+     * Extracts the scope from the ASEID
+     * scope is the scope of the entity from Application Namespace
+     */
+    get scope(): string {
+        return this.aseid.scope;
+    }
+
+    /**
+     * Extracts the entity from the ASEID
+     * entity is the name of the entity from Application Namespace
+     */
+    get entity(): string {
+        return this.aseid.entity;
+    }
+
+    /**
+     * Extracts the version from the ASEID
+     * version is the version of the entity
+     */
+
+    get version(): string | undefined {
+        return this.aseid.version;
+    }
+
+    /**
+     * Extracts the shard from the ASEID
+     * shard is the shard of the entity
+     */
+    get shard(): string | undefined {
+        return this.aseid.shard;
+    }
+
+
+    protected fromNewEntity(newEntity: _ConstructorType): void {
+        return;
+    }
+
+    protected fromSerialized(serialized: _SerializedType): void {
+        this.aseid = new ASEID((serialized).aseid);
+        return;
+    }
+
+
+    /**
+     * Converts the entity to a JSON object 
+     * 
+     * 
+     * @returns 
+     */
+    toJSON(): _SerializedType {
+        return {
+            aseid: this.aseid.toString()
+        } as _SerializedType;
+    }
+
+
+
+    toString(): string {
+        return this.aseid.toString();
+    }
+}

package/src/global/A_Error.class.ts

@@ -0,0 +1,75 @@
+import { A_TYPES__ServerError } from '../types/A_ServerError.types';
+import { AxiosError } from 'axios';
+import { A_TYPES__Error } from '../types/A_Error.types';
+import { A_CONSTANTS__ERROR_CODES } from '../constants/errors.constants';
+
+
+export class A_Error extends Error {
+
+    code!: string;
+    description!: string;
+    originalError?: Error | any
+    link?: string;
+
+
+    constructor(
+        params: A_TYPES__Error | Error | AxiosError | any
+    ) {
+        super(params?.message || 'Oops... Something went wrong');
+        this.identifyErrorType(params);
+        
+    }
+
+
+    get id(): string | undefined {
+        return this.code.split('@')[1]
+    }
+
+
+    protected identifyErrorType(error: Error | AxiosError | A_TYPES__Error) {
+
+        if ((error as A_TYPES__ServerError).code &&
+            (error as A_TYPES__ServerError).description &&
+            (error as A_TYPES__ServerError).serverCode) {
+
+            const target = error as A_TYPES__ServerError;
+
+            this.message = target.message;
+            this.code = target.code;
+            this.description = target.description;
+            this.originalError = target.originalError;
+            this.link = target.link;
+        }
+        else if (error instanceof Error) {
+            this.message = error.message;
+            this.code = A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
+            this.description = 'If you see this error please let us know.';
+            this.originalError = error;
+            this.link = 'https://support.adaas.org/error/' + this.id;
+
+
+        } else if (error instanceof AxiosError) {
+            this.message = error.response?.data.message || error.message;
+            this.code = error.response?.data.code || A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
+            this.description = error.response?.data.description || 'If you see this error please let us know.';
+            this.originalError = error.response;
+            this.link = 'https://support.adaas.org/error/' + this.id;
+        }
+    }
+
+
+    get compilingData(): A_TYPES__Error {
+        return {
+            message: this.message,
+            code: this.code,
+            description: this.description,
+            originalError: this.originalError
+        }
+    }
+
+    toJSON(): A_TYPES__Error {
+        return this.compilingData;
+    }
+}
+
+

package/src/global/A_Polyfills.ts

@@ -0,0 +1,112 @@
+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 {
+
+    private _fs!: Ifspolyfill;
+    private _crypto!: ICryptoInterface;
+
+    // eslint-disable-next-line no-use-before-define
+    private fsName = 'fs'
+    private cryptoName = 'crypto'
+
+
+    async fs() {
+        if (!this._fs) {
+            await this.init();
+        }
+        return this._fs;
+    }
+
+    async crypto() {
+        if (!this._crypto) {
+            await this.init();
+        }
+        return this._crypto;
+    }
+
+
+    get env(): 'server' | 'browser' {
+        let testEnvironment: 'server' | 'browser' = 'browser';
+
+        try {
+            testEnvironment = window.location ? 'browser' : 'server';
+
+        } catch (error) {
+
+            testEnvironment = 'server';
+        }
+
+        return testEnvironment;
+    }
+
+
+    private async init() {
+        try {
+            if (this.env === 'server') {
+                // eslint-disable-next-line no-use-before-define
+                this._fs = await import('' + this.fsName) as Ifspolyfill;
+                // eslint-disable-next-line no-use-before-define
+                this._crypto = {
+                    createTextHash: () => Promise.resolve(''),
+                    createFileHash: (filePath: string, algorithm: string = 'sha384') => new Promise(async (resolve, reject) => {
+                        try {
+                            const crypto = await import('' + this.cryptoName);
+
+                            const hash = crypto.createHash(algorithm);
+                            const fileStream = this._fs.createReadStream(filePath);
+
+                            fileStream.on('data', (data) => hash.update(data));
+                            fileStream.on('end', () => resolve(`${algorithm}-${hash.digest('base64')}`));
+                            fileStream.on('error', (err) => reject(err));
+
+                        } catch (error) {
+                            return reject(error);
+                        }
+
+                    })
+                }
+            }
+            else {
+                throw new Error('Not Server Environment');
+            }
+        } catch (error) {
+
+            this._fs = {
+                readFileSync: (path: string, encoding: string) => '',
+                existsSync: (path: string) => false,
+                createReadStream: (path: string) => ''
+            };
+
+            this._crypto = {
+                createFileHash: () => Promise.resolve(''),
+                createTextHash: (text: string, algorithm: string = 'SHA-384') => new Promise<string>(async (resolve, reject) => {
+                    try {
+                        const encoder = new TextEncoder();
+                        const data = encoder.encode(text);
+                        const hashBuffer = await crypto.subtle.digest(algorithm, data);
+                        const hashArray = Array.from(new Uint8Array(hashBuffer));
+                        const hashBase64 = btoa(String.fromCharCode(...hashArray.map(byte => String.fromCharCode(byte) as any)));
+                        return resolve(`${algorithm}-${hashBase64}`);
+                    } catch (error) {
+                        return reject(error);
+                    }
+                })
+            };
+        }
+    }
+
+
+}
+
+
+export const A_Polyfills = new A_PolyfillsClass();

package/src/global/A_ScheduleObject.class.ts

@@ -0,0 +1,53 @@
+import { A_TYPES__ScheduleObjectConfig } from "../types/A_ScheduleObject.types";
+import { A_Deferred } from "./A_Deferred.class";
+import { A_Error } from "./A_Error.class";
+
+export class A_ScheduleObject<T> {
+
+    private timeout!: NodeJS.Timeout;
+    private deferred!: A_Deferred<T>;
+
+    private config: 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: false
+    };
+
+    constructor(
+        ms: number,
+        action: () => Promise<T>,
+        config?: A_TYPES__ScheduleObjectConfig
+    ) {
+        if (config)
+            this.config = { ...this.config, ...config };
+
+        this.deferred = new A_Deferred<T>();
+
+        this.timeout = setTimeout(
+            () => action()
+                .then((...args) => this.deferred.resolve(...args))
+                .catch((...args) => this.deferred.reject(...args)),
+            ms
+        );
+    }
+
+    get promise(): Promise<T> {
+        return this.deferred.promise;
+    }
+
+    clear(): void {
+        if (this.timeout) {
+            clearTimeout(this.timeout);
+
+            if (this.config.resolveOnClear)
+                this.deferred.resolve(undefined as T);
+            else
+                this.deferred.reject(new A_Error("Timeout Cleared"));
+        }
+    }
+}
+

package/src/global/A_ServerError.class.ts

@@ -0,0 +1,70 @@
+import { A_TYPES__ServerError } from '../types/A_ServerError.types';
+import { AxiosError } from 'axios';
+import { A_Error } from './A_Error.class';
+import { A_CONSTANTS__ERROR_CODES } from '../constants/errors.constants';
+
+
+export class A_ServerError extends A_Error {
+
+    code!: string;
+    description!: string;
+    serverCode: number = 500;
+    originalError: Error | any
+
+
+    constructor(params: A_TYPES__ServerError | Error | AxiosError | any) {
+        super(params);
+        this.identifyErrorType(params);
+    }
+
+
+    protected identifyErrorType(error: Error | AxiosError | A_TYPES__ServerError) {
+
+        if ((error as A_TYPES__ServerError).code &&
+            (error as A_TYPES__ServerError).description &&
+            (error as A_TYPES__ServerError).serverCode) {
+
+            const target = error as A_TYPES__ServerError;
+
+            this.message = target.message;
+            this.code = target.code;
+            this.description = target.description;
+            this.serverCode = target.serverCode;
+            this.originalError = target.originalError;
+            this.link = target.link;
+        }
+        else if (error instanceof Error) {
+            this.message = error.message;
+            this.code = A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
+            this.description = 'If you see this error please let us know.';
+            this.serverCode = 500;
+            this.originalError = error;
+            this.link = 'https://support.adaas.org/error/' + this.id;
+
+        } else if (error instanceof AxiosError) {
+            this.message = error.response?.data.message || error.message;
+            this.code = error.response?.data.code || A_CONSTANTS__ERROR_CODES.UNEXPECTED_ERROR;
+            this.description = error.response?.data.description || 'If you see this error please let us know.';
+            this.serverCode = error.response?.status || 500;
+            this.originalError = error.response;
+            this.link = 'https://support.adaas.org/error/' + this.id;
+        }
+    }
+
+
+    get compilingData(): A_TYPES__ServerError {
+        return {
+            message: this.message,
+            code: this.code,
+            description: this.description,
+            serverCode: this.serverCode,
+            originalError: this.originalError
+        }
+    }
+
+    toJSON(): A_TYPES__ServerError {
+        return this.compilingData;
+    }
+}
+
+