namirasoft-core 1.4.27 → 1.4.29

package/src/BaseServer.ts

@@ -1,114 +1,114 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
-import { HashOperation } from "./HashOperation";
-import { URLOperation } from "./URLOperation";
-import { ErrorOperation } from "./ErrorOperation";
-import { ParsedNameValue } from "./ParsedNameValue";
-import { ConsoleOperation } from "./ConsoleOperation";
-import { EnvService } from "./EnvService";
-
-export abstract class BaseServer
-{
-    protected base_url: string;
-    public suppressErrors: boolean = false;
-    constructor(base_url: string)
-    {
-        this.base_url = base_url;
-    }
-    private onBeforeRequests: ((url: string, config?: AxiosRequestConfig) => void)[] = [];
-    private onAfterRequests: ((url: string, response: AxiosResponse) => void)[] = [];
-    protected abstract onBeforeRequest<ReqData = any>(url: string, config?: AxiosRequestConfig<ReqData>): void;
-    protected abstract onAfterRequest<ResData = any>(url: string, response: AxiosResponse<ResData>): void;
-    protected abstract onError(error: Error): void;
-    addOnBeforeRequest(onBeforeRequest: (url: string, config?: AxiosRequestConfig) => void)
-    {
-        this.onBeforeRequests.push(onBeforeRequest);
-    }
-    addOnAfterRequest(onAfterRequest: (url: string, response: AxiosResponse) => void)
-    {
-        this.onAfterRequests.push(onAfterRequest);
-    }
-    private async _request<ResData = any, ReqData = any>(onRequest: (url: string, data?: any, config?: AxiosRequestConfig<ReqData>) => Promise<AxiosResponse<ResData>>, sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        let url: string = URLOperation.getLink(this.base_url, sub, query);
-        if (!config)
-            config = { headers: {} };
-        if (sign_header)
-            if (sign_key)
-                if (data)
-                    if (config?.headers)
-                        config.headers[sign_header] = HashOperation.SHA256Secret(sign_key, data);
-        try
-        {
-            this.onBeforeRequest(url, config);
-            this.onBeforeRequests.forEach(onBeforeRequest =>
-            {
-                onBeforeRequest(url, config);
-            });
-            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
-            this.onAfterRequest(url, response);
-            this.onAfterRequests.forEach(onAfterRequest =>
-            {
-                onAfterRequest(url, response);
-            });
-            return { response, data: response.data };
-        } catch (error)
-        {
-            if (error instanceof Error)
-            {
-                let BASESERVER_ERROR_VERBOSE = new EnvService("BASESERVER_ERROR_VERBOSE", false).getBoolean(false);
-
-                if (this.onError)
-                {
-                    if (BASESERVER_ERROR_VERBOSE)
-                        error.message = `Error calling url '${url}' ` + error.message;
-                    this.onError(error);
-                }
-                else
-                {
-                    ConsoleOperation.warning("onError function has not been properly set.");
-                    ConsoleOperation.error(error?.message);
-                }
-                if (axios.isAxiosError(error))
-                    if (error?.response?.data)
-                        if (!this.suppressErrors)
-                        {
-                            if (BASESERVER_ERROR_VERBOSE)
-                                ErrorOperation.throwHTTP(error.response.status, `Error calling url '${url}' ` + JSON.stringify(error.response.data));
-                            else
-                                ErrorOperation.throwHTTP(error.response.status, JSON.stringify(error.response.data));
-                        }
-            }
-            if (!this.suppressErrors)
-                throw error;
-        }
-        return {} as any;
-    }
-    protected async _get<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: AxiosRequestConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request(async (url: string, _?: any, config?: AxiosRequestConfig<ReqData>) =>
-        {
-            return await axios.get(url, config);
-        }, sub, query, undefined, config);
-    }
-    protected async _post<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request(async (url: string, data: ReqData, config?: AxiosRequestConfig<ReqData>) =>
-        {
-            return await axios.post(url, data, config);
-        }, sub, query, data, config, sign_header, sign_key);
-    }
-    protected async _put<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request(async (url: string, data: ReqData, config?: AxiosRequestConfig<ReqData>) =>
-        {
-            return await axios.put(url, data, config);
-        }, sub, query, data, config, sign_header, sign_key);
-    }
-    protected async _delete<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request(async (url: string, _?: any, config?: AxiosRequestConfig<ReqData>) =>
-        {
-            return await axios.delete(url, config);
-        }, sub, query, undefined, config, sign_header, sign_key);
-    }
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+import { HashOperation } from "./HashOperation";
+import { URLOperation } from "./URLOperation";
+import { ErrorOperation } from "./ErrorOperation";
+import { ParsedNameValue } from "./ParsedNameValue";
+import { ConsoleOperation } from "./ConsoleOperation";
+import { EnvService } from "./EnvService";
+
+export abstract class BaseServer
+{
+    protected base_url: string;
+    public suppressErrors: boolean = false;
+    constructor(base_url: string)
+    {
+        this.base_url = base_url;
+    }
+    private onBeforeRequests: ((url: string, config?: AxiosRequestConfig) => void)[] = [];
+    private onAfterRequests: ((url: string, response: AxiosResponse) => void)[] = [];
+    protected abstract onBeforeRequest<ReqData = any>(url: string, config?: AxiosRequestConfig<ReqData>): void;
+    protected abstract onAfterRequest<ResData = any>(url: string, response: AxiosResponse<ResData>): void;
+    protected abstract onError(error: Error): void;
+    addOnBeforeRequest(onBeforeRequest: (url: string, config?: AxiosRequestConfig) => void)
+    {
+        this.onBeforeRequests.push(onBeforeRequest);
+    }
+    addOnAfterRequest(onAfterRequest: (url: string, response: AxiosResponse) => void)
+    {
+        this.onAfterRequests.push(onAfterRequest);
+    }
+    private async _request<ResData = any, ReqData = any>(onRequest: (url: string, data?: any, config?: AxiosRequestConfig<ReqData>) => Promise<AxiosResponse<ResData>>, sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        let url: string = URLOperation.getLink(this.base_url, sub, query);
+        if (!config)
+            config = { headers: {} };
+        if (sign_header)
+            if (sign_key)
+                if (data)
+                    if (config?.headers)
+                        config.headers[sign_header] = HashOperation.SHA256Secret(sign_key, data);
+        try
+        {
+            this.onBeforeRequest(url, config);
+            this.onBeforeRequests.forEach(onBeforeRequest =>
+            {
+                onBeforeRequest(url, config);
+            });
+            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
+            this.onAfterRequest(url, response);
+            this.onAfterRequests.forEach(onAfterRequest =>
+            {
+                onAfterRequest(url, response);
+            });
+            return { response, data: response.data };
+        } catch (error)
+        {
+            if (error instanceof Error)
+            {
+                let BASESERVER_ERROR_VERBOSE = new EnvService("BASESERVER_ERROR_VERBOSE", false).getBoolean(false);
+
+                if (this.onError)
+                {
+                    if (BASESERVER_ERROR_VERBOSE)
+                        error.message = `Error calling url '${url}' ` + error.message;
+                    this.onError(error);
+                }
+                else
+                {
+                    ConsoleOperation.warning("onError function has not been properly set.");
+                    ConsoleOperation.error(error?.message);
+                }
+                if (axios.isAxiosError(error))
+                    if (error?.response?.data)
+                        if (!this.suppressErrors)
+                        {
+                            if (BASESERVER_ERROR_VERBOSE)
+                                ErrorOperation.throwHTTP(error.response.status, `Error calling url '${url}' ` + JSON.stringify(error.response.data));
+                            else
+                                ErrorOperation.throwHTTP(error.response.status, JSON.stringify(error.response.data));
+                        }
+            }
+            if (!this.suppressErrors)
+                throw error;
+        }
+        return {} as any;
+    }
+    protected async _get<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: AxiosRequestConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request(async (url: string, _?: any, config?: AxiosRequestConfig<ReqData>) =>
+        {
+            return await axios.get(url, config);
+        }, sub, query, undefined, config);
+    }
+    protected async _post<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request(async (url: string, data: ReqData, config?: AxiosRequestConfig<ReqData>) =>
+        {
+            return await axios.post(url, data, config);
+        }, sub, query, data, config, sign_header, sign_key);
+    }
+    protected async _put<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request(async (url: string, data: ReqData, config?: AxiosRequestConfig<ReqData>) =>
+        {
+            return await axios.put(url, data, config);
+        }, sub, query, data, config, sign_header, sign_key);
+    }
+    protected async _delete<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: AxiosRequestConfig<ReqData>, sign_header?: string, sign_key?: string): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request(async (url: string, _?: any, config?: AxiosRequestConfig<ReqData>) =>
+        {
+            return await axios.delete(url, config);
+        }, sub, query, undefined, config, sign_header, sign_key);
+    }
 }

package/src/BaseUUID.ts

@@ -1,56 +1,56 @@
-import { v4 } from "uuid";
-
-export class BaseUUID
-{
-    private static SIZE = 20;
-    static isValid(id: any)
-    {
-        let value = id + "";
-        if (value.length != BaseUUID.SIZE)
-            return false;
-        let parts = id.split("@")[0].split("-");
-        if (parts.length < 2)
-            return false;
-        return /^[a-z][a-z][a-z]$/.test(parts[0]);
-    }
-    static getShort(id: string)
-    {
-        let parts = id.split("@")[0].split("-");
-        let ans = [];
-        for (let index = 0; index < parts.length - 1; index++)
-        {
-            const part = parts[index];
-            if (/^[a-z][a-z][a-z]$/.test(part))
-                ans.push(part);
-            else
-                break;
-        }
-        return ans.join("-");
-    }
-    short: string;
-    constructor(short: string)
-    {
-        this.short = short;
-    }
-    static uuid(lenght: number = 16): string
-    {
-        return v4().replace(/-/g, '').substring(0, lenght);
-    }
-    static isChild(id: string): boolean
-    {
-        let index = id.indexOf("@")
-        return index != -1;
-    }
-    static changeToChild(owner_id: string, name: string): string
-    {
-        let index = owner_id.indexOf("@")
-        if (index != -1)
-            return owner_id.substring(0, index + 1) + name.substring(0, BaseUUID.SIZE - index - 1).padStart(BaseUUID.SIZE - index - 1, '-');
-        return "";
-    }
-    new()
-    {
-        let ans = this.short + "-" + BaseUUID.uuid();
-        return ans.substring(0, BaseUUID.SIZE);
-    }
+import { v4 } from "uuid";
+
+export class BaseUUID
+{
+    private static SIZE = 20;
+    static isValid(id: any)
+    {
+        let value = id + "";
+        if (value.length != BaseUUID.SIZE)
+            return false;
+        let parts = id.split("@")[0].split("-");
+        if (parts.length < 2)
+            return false;
+        return /^[a-z][a-z][a-z]$/.test(parts[0]);
+    }
+    static getShort(id: string)
+    {
+        let parts = id.split("@")[0].split("-");
+        let ans = [];
+        for (let index = 0; index < parts.length - 1; index++)
+        {
+            const part = parts[index];
+            if (/^[a-z][a-z][a-z]$/.test(part))
+                ans.push(part);
+            else
+                break;
+        }
+        return ans.join("-");
+    }
+    short: string;
+    constructor(short: string)
+    {
+        this.short = short;
+    }
+    static uuid(lenght: number = 16): string
+    {
+        return v4().replace(/-/g, '').substring(0, lenght);
+    }
+    static isChild(id: string): boolean
+    {
+        let index = id.indexOf("@")
+        return index != -1;
+    }
+    static changeToChild(owner_id: string, name: string): string
+    {
+        let index = owner_id.indexOf("@")
+        if (index != -1)
+            return owner_id.substring(0, index + 1) + name.substring(0, BaseUUID.SIZE - index - 1).padStart(BaseUUID.SIZE - index - 1, '-');
+        return "";
+    }
+    new()
+    {
+        let ans = this.short + "-" + BaseUUID.uuid();
+        return ans.substring(0, BaseUUID.SIZE);
+    }
 };

package/src/CacheService.ts

@@ -1,58 +1,58 @@
-import { IStorage } from "./IStorage";
-
-interface NSCachStorage<DataType>
-{
-    expires_at: Date;
-    data: DataType;
-}
-
-export class CacheService<DataType>
-{
-    private name: string;
-    private duration_minutes: number;
-    private storage: IStorage;
-    private getFromSource: () => Promise<DataType>;
-    private onExpired: () => void;
-    constructor(name: string, duration_minutes: number, storage: IStorage, getFromSource: () => Promise<DataType>, onExpired: () => void)
-    {
-        this.name = name;
-        this.duration_minutes = duration_minutes;
-        this.storage = storage;
-        this.getFromSource = getFromSource;
-        this.onExpired = onExpired;
-    }
-    async get(): Promise<DataType>
-    {
-        let ans: DataType;
-        let value = this.storage.get(this.name, "");
-        if (value)
-        {
-            let cache = JSON.parse(value) as NSCachStorage<DataType>;
-            if (new Date(cache.expires_at) > new Date())
-                return cache.data;
-        }
-        ans = await this.getFromSource();
-        this.set(ans);
-        return ans;
-    }
-    set(data: DataType)
-    {
-        let expires_at = new Date();
-        expires_at.setMinutes(expires_at.getMinutes() + this.duration_minutes);
-        let value = JSON.stringify({ data, expires_at });
-        this.storage.set(this.name, value);
-        //
-        let sleep = expires_at.getTime() - new Date().getTime();
-        if (sleep <= 0)
-            sleep = 5 * 1000;
-        setTimeout(() =>
-        {
-            if (this.onExpired)
-                this.onExpired();
-        }, sleep);
-    }
-    del()
-    {
-        this.storage.del(this.name);
-    }
+import { IStorage } from "./IStorage";
+
+interface NSCachStorage<DataType>
+{
+    expires_at: Date;
+    data: DataType;
+}
+
+export class CacheService<DataType>
+{
+    private name: string;
+    private duration_minutes: number;
+    private storage: IStorage;
+    private getFromSource: () => Promise<DataType>;
+    private onExpired: () => void;
+    constructor(name: string, duration_minutes: number, storage: IStorage, getFromSource: () => Promise<DataType>, onExpired: () => void)
+    {
+        this.name = name;
+        this.duration_minutes = duration_minutes;
+        this.storage = storage;
+        this.getFromSource = getFromSource;
+        this.onExpired = onExpired;
+    }
+    async get(): Promise<DataType>
+    {
+        let ans: DataType;
+        let value = this.storage.get(this.name, "");
+        if (value)
+        {
+            let cache = JSON.parse(value) as NSCachStorage<DataType>;
+            if (new Date(cache.expires_at) > new Date())
+                return cache.data;
+        }
+        ans = await this.getFromSource();
+        this.set(ans);
+        return ans;
+    }
+    set(data: DataType)
+    {
+        let expires_at = new Date();
+        expires_at.setMinutes(expires_at.getMinutes() + this.duration_minutes);
+        let value = JSON.stringify({ data, expires_at });
+        this.storage.set(this.name, value);
+        //
+        let sleep = expires_at.getTime() - new Date().getTime();
+        if (sleep <= 0)
+            sleep = 5 * 1000;
+        setTimeout(() =>
+        {
+            if (this.onExpired)
+                this.onExpired();
+        }, sleep);
+    }
+    del()
+    {
+        this.storage.del(this.name);
+    }
 }

package/src/ConsoleOperation.ts

@@ -1,69 +1,69 @@
-export class ConsoleOperation
-{
-    public static colors = {
-        reset: '\x1b[0m',
-        red: '\x1b[31m',
-        green: '\x1b[32m',
-        yellow: '\x1b[33m',
-        blue: '\x1b[34m',
-        magenta: '\x1b[35m',
-        cyan: '\x1b[36m',
-        white: '\x1b[37m',
-    };
-    static formatLogColor(message: string)
-    {
-        return (ConsoleOperation.colors.white + message + ConsoleOperation.colors.reset);
-    }
-    static formatInfoColor(message: string)
-    {
-        return (ConsoleOperation.colors.cyan + message + ConsoleOperation.colors.reset);
-    }
-    static formatTraceColor(message: string)
-    {
-        return (ConsoleOperation.colors.blue + message + ConsoleOperation.colors.reset);
-    }
-    static formatDebugColor(message: string)
-    {
-        return (ConsoleOperation.colors.magenta + message + ConsoleOperation.colors.reset);
-    }
-    static formatSuccessColor(message: string)
-    {
-        return (ConsoleOperation.colors.green + message + ConsoleOperation.colors.reset);
-    }
-    static formatWarningColor(message: string)
-    {
-        return (ConsoleOperation.colors.yellow + message + ConsoleOperation.colors.reset);
-    }
-    static formatErrorColor(message: string)
-    {
-        return (ConsoleOperation.colors.red + message + ConsoleOperation.colors.reset);
-    }
-    static log(message: string)
-    {
-        console.log(ConsoleOperation.formatLogColor(message));
-    }
-    static info(message: string)
-    {
-        console.info(ConsoleOperation.formatInfoColor(message));
-    }
-    static trace(message: string)
-    {
-        console.trace(ConsoleOperation.formatTraceColor(message));
-    }
-    static debug(message: string)
-    {
-        console.debug(ConsoleOperation.formatDebugColor(message));
-    }
-    static success(message: string)
-    {
-        console.info(ConsoleOperation.formatSuccessColor(message));
-    }
-    static warning(message: string)
-    {
-        console.warn(ConsoleOperation.formatWarningColor(message));
-    }
-    static error(message: string)
-    {
-        console.error(ConsoleOperation.formatErrorColor(message));
-    }
+export class ConsoleOperation
+{
+    public static colors = {
+        reset: '\x1b[0m',
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m',
+    };
+    static formatLogColor(message: string)
+    {
+        return (ConsoleOperation.colors.white + message + ConsoleOperation.colors.reset);
+    }
+    static formatInfoColor(message: string)
+    {
+        return (ConsoleOperation.colors.cyan + message + ConsoleOperation.colors.reset);
+    }
+    static formatTraceColor(message: string)
+    {
+        return (ConsoleOperation.colors.blue + message + ConsoleOperation.colors.reset);
+    }
+    static formatDebugColor(message: string)
+    {
+        return (ConsoleOperation.colors.magenta + message + ConsoleOperation.colors.reset);
+    }
+    static formatSuccessColor(message: string)
+    {
+        return (ConsoleOperation.colors.green + message + ConsoleOperation.colors.reset);
+    }
+    static formatWarningColor(message: string)
+    {
+        return (ConsoleOperation.colors.yellow + message + ConsoleOperation.colors.reset);
+    }
+    static formatErrorColor(message: string)
+    {
+        return (ConsoleOperation.colors.red + message + ConsoleOperation.colors.reset);
+    }
+    static log(message: string)
+    {
+        console.log(ConsoleOperation.formatLogColor(message));
+    }
+    static info(message: string)
+    {
+        console.info(ConsoleOperation.formatInfoColor(message));
+    }
+    static trace(message: string)
+    {
+        console.trace(ConsoleOperation.formatTraceColor(message));
+    }
+    static debug(message: string)
+    {
+        console.debug(ConsoleOperation.formatDebugColor(message));
+    }
+    static success(message: string)
+    {
+        console.info(ConsoleOperation.formatSuccessColor(message));
+    }
+    static warning(message: string)
+    {
+        console.warn(ConsoleOperation.formatWarningColor(message));
+    }
+    static error(message: string)
+    {
+        console.error(ConsoleOperation.formatErrorColor(message));
+    }
 }