namirasoft-core 1.5.2 → 1.5.3

package/src/BaseLogger.ts

@@ -1,25 +1,25 @@
-import { ILogger } from "./ILogger";
-import { LogLevel } from "./LogLevel";
-
-export abstract class BaseLogger implements ILogger
-{
-    static main: BaseLogger | null = null;
-    constructor()
-    {
-        if (BaseLogger.main == null)
-            BaseLogger.main = this;
-    }
-    abstract log(level: LogLevel, ...messages: any[]): void;
-    abstract trace(...messages: any[]): void;
-    abstract verbose(...messages: any[]): void;
-    abstract debug(...messages: any[]): void;
-    abstract info(...messages: any[]): void;
-    abstract success(...messages: any[]): void;
-    abstract warning(...messages: any[]): void;
-    abstract error(...messages: any[]): void;
-    abstract critical(...messages: any[]): void;
-    abstract fatal(...messages: any[]): void;
-    abstract onCatchError(error: Error | unknown): void;
-    abstract onCatchCritical(error: Error | unknown): void;
-    abstract onCatchFatal(error: Error | unknown): void;
+import { ILogger } from "./ILogger";
+import { LogLevel } from "./LogLevel";
+
+export abstract class BaseLogger implements ILogger
+{
+    static main: BaseLogger | null = null;
+    constructor()
+    {
+        if (BaseLogger.main == null)
+            BaseLogger.main = this;
+    }
+    abstract log(level: LogLevel, ...messages: any[]): void;
+    abstract trace(...messages: any[]): void;
+    abstract verbose(...messages: any[]): void;
+    abstract debug(...messages: any[]): void;
+    abstract info(...messages: any[]): void;
+    abstract success(...messages: any[]): void;
+    abstract warning(...messages: any[]): void;
+    abstract error(...messages: any[]): void;
+    abstract critical(...messages: any[]): void;
+    abstract fatal(...messages: any[]): void;
+    abstract onCatchError(error: Error | unknown): void;
+    abstract onCatchCritical(error: Error | unknown): void;
+    abstract onCatchFatal(error: Error | unknown): void;
 }

package/src/BaseMetaColumn.ts

@@ -1,18 +1,18 @@
-import { BaseMetaTable } from "./BaseMetaTable";
-
-export class BaseMetaColumn
-{
-    table: BaseMetaTable;
-    name: string;
-    text: string;
-    type: string; // todo
-    required: boolean;
-    constructor(table: BaseMetaTable, name: string, text: string, type: string, required: boolean)
-    {
-        this.table = table;
-        this.name = name;
-        this.text = text;
-        this.type = type;
-        this.required = required;
-    }
+import { BaseMetaTable } from "./BaseMetaTable";
+
+export class BaseMetaColumn
+{
+    table: BaseMetaTable;
+    name: string;
+    text: string;
+    type: string; // todo
+    required: boolean;
+    constructor(table: BaseMetaTable, name: string, text: string, type: string, required: boolean)
+    {
+        this.table = table;
+        this.name = name;
+        this.text = text;
+        this.type = type;
+        this.required = required;
+    }
 }

package/src/BaseMetaDatabase.ts

@@ -1,31 +1,31 @@
-import { BaseMetaTable } from "./BaseMetaTable";
-
-export abstract class BaseMetaDatabase
-{
-    public tables: { [name: string]: BaseMetaTable } = {};
-    forEachTable<T, MT extends BaseMetaTable>(handler: (table: MT) => T | null): T | null
-    {
-        for (const key in this.tables)
-        {
-            const element = this.tables[key];
-            let ans = handler(element as MT);
-            if (ans != null)
-                return ans;
-        }
-        return null;
-    }
-    getTables<MT extends BaseMetaTable>(): MT[]
-    {
-        let ans: MT[] = [];
-        this.forEachTable((table) =>
-        {
-            ans.push(table as MT);
-            return null;
-        });
-        return ans;
-    }
-    hasTable(name: string): boolean
-    {
-        return this.tables[name] != null;
-    }
+import { BaseMetaTable } from "./BaseMetaTable";
+
+export abstract class BaseMetaDatabase
+{
+    public tables: { [name: string]: BaseMetaTable } = {};
+    forEachTable<T, MT extends BaseMetaTable>(handler: (table: MT) => T | null): T | null
+    {
+        for (const key in this.tables)
+        {
+            const element = this.tables[key];
+            let ans = handler(element as MT);
+            if (ans != null)
+                return ans;
+        }
+        return null;
+    }
+    getTables<MT extends BaseMetaTable>(): MT[]
+    {
+        let ans: MT[] = [];
+        this.forEachTable((table) =>
+        {
+            ans.push(table as MT);
+            return null;
+        });
+        return ans;
+    }
+    hasTable(name: string): boolean
+    {
+        return this.tables[name] != null;
+    }
 };

package/src/BaseMetaTable.ts

@@ -1,41 +1,41 @@
-import { BaseMetaColumn } from "./BaseMetaColumn";
-import { BaseMetaDatabase } from "./BaseMetaDatabase";
-
-export class BaseMetaTable
-{
-    database: BaseMetaDatabase | null;
-    name: string;
-    text: string;
-    public columns: { [name: string]: BaseMetaColumn } = {};
-    constructor(database: BaseMetaDatabase | null, name: string, text: string)
-    {
-        this.database = database;
-        this.name = name;
-        this.text = text;
-    }
-    forEachColumn<T, MC extends BaseMetaColumn>(handler: (column: MC) => T | null): T | null
-    {
-        for (const key in this.columns)
-        {
-            const element = this.columns[key];
-            let ans = handler(element as MC);
-            if (ans != null)
-                return ans;
-        }
-        return null;
-    }
-    getColumns<MC extends BaseMetaColumn>(): MC[]
-    {
-        let ans: MC[] = [];
-        this.forEachColumn((column) =>
-        {
-            ans.push(column as MC);
-            return null;
-        });
-        return ans;
-    }
-    hasColumn(name: string): boolean
-    {
-        return this.columns[name] != null;
-    }
+import { BaseMetaColumn } from "./BaseMetaColumn";
+import { BaseMetaDatabase } from "./BaseMetaDatabase";
+
+export class BaseMetaTable
+{
+    database: BaseMetaDatabase | null;
+    name: string;
+    text: string;
+    public columns: { [name: string]: BaseMetaColumn } = {};
+    constructor(database: BaseMetaDatabase | null, name: string, text: string)
+    {
+        this.database = database;
+        this.name = name;
+        this.text = text;
+    }
+    forEachColumn<T, MC extends BaseMetaColumn>(handler: (column: MC) => T | null): T | null
+    {
+        for (const key in this.columns)
+        {
+            const element = this.columns[key];
+            let ans = handler(element as MC);
+            if (ans != null)
+                return ans;
+        }
+        return null;
+    }
+    getColumns<MC extends BaseMetaColumn>(): MC[]
+    {
+        let ans: MC[] = [];
+        this.forEachColumn((column) =>
+        {
+            ans.push(column as MC);
+            return null;
+        });
+        return ans;
+    }
+    hasColumn(name: string): boolean
+    {
+        return this.columns[name] != null;
+    }
 }

package/src/BaseServer.ts

@@ -1,151 +1,151 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
-import { ConsoleOperation } from "./ConsoleOperation";
-import { EnvService } from "./EnvService";
-import { ErrorOperation } from "./ErrorOperation";
-import { HashOperation } from "./HashOperation";
-import { HTTPError } from "./HTTPError";
-import { ParsedNameValue } from "./ParsedNameValue";
-import { URLOperation } from "./URLOperation";
-
-export interface BaseServerConfig<ReqData> extends AxiosRequestConfig<ReqData>
-{
-    sign?: {
-        header: string;
-        key: string;
-    }
-    onBeforeRequest?: (url: string, config?: AxiosRequestConfig) => void;
-    onAfterRequest?: (url: string, res: AxiosResponse) => void;
-    onError?: (error: Error) => void;
-    error_suppress?: boolean;
-    error_verbose?: boolean;
-}
-export abstract class BaseServer
-{
-    public static isErrorCode(e: any, code: number): boolean
-    {
-        if (axios.isAxiosError(e))
-            if (e.response)
-                if (e.response?.status === code)
-                    return true;
-        if (e instanceof HTTPError)
-            if (e.code === code)
-                return true;
-        return false
-    }
-
-    protected base_url: string;
-    private onBeforeRequests: ((url: string, config?: AxiosRequestConfig) => void)[] = [];
-    private onAfterRequests: ((url: string, res: AxiosResponse) => void)[] = [];
-    protected abstract onError(error: Error): void;
-    public error_suppress?: boolean = false;
-    public error_verbose?: boolean = false;
-
-    constructor(base_url: string)
-    {
-        this.base_url = base_url;
-        this.error_verbose = new EnvService("BASESERVER_ERROR_VERBOSE", false).getBoolean(false);
-    }
-    public addOnBeforeRequest(onBeforeRequest: (url: string, config?: AxiosRequestConfig) => void)
-    {
-        this.onBeforeRequests.push(onBeforeRequest);
-    }
-    public addOnAfterRequest(onAfterRequest: (url: string, res: AxiosResponse) => void)
-    {
-        this.onAfterRequests.push(onAfterRequest);
-    }
-    private async _request<ResData = any, ReqData = any>(onRequest: (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) => Promise<AxiosResponse<ResData>>, sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        let url: string = URLOperation.getLink(this.base_url, sub, query);
-        if (!config)
-            config = {};
-        if (!config.headers)
-            config.headers = {};
-        if (config.withCredentials == null)
-            config.withCredentials = true;
-
-        if (config.sign)
-            if (config.sign?.header)
-                if (config.sign?.key)
-                    if (data)
-                        config.headers[config.sign.header] = HashOperation.SHA256Secret(config.sign.key, data);
-        try
-        {
-            config.onBeforeRequest?.(url, config);
-            this.onBeforeRequests.forEach(onBeforeRequest =>
-            {
-                onBeforeRequest(url, config);
-            });
-            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
-            this.onAfterRequests.forEach(onAfterRequest =>
-            {
-                onAfterRequest(url, response);
-            });
-            config.onAfterRequest?.(url, response);
-            return { response, data: response.data };
-        } catch (error)
-        {
-            let onError = config.onError ?? this.onError;
-            let error_verbose = config.error_verbose ?? this.error_verbose;
-            let error_suppress = config.error_suppress ?? this.error_suppress;
-            if (error instanceof Error)
-            {
-                if (error_verbose)
-                    error.message = `Error calling url '${url}' ` + error.message;
-                if (onError)
-                    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 (!error_suppress)
-                        {
-                            if (error_suppress)
-                                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 (!error_suppress)
-                throw error;
-        }
-        return {} as any;
-    }
-    public async _get<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request<ResData, ReqData>(async (url: string, _?: any, config?: BaseServerConfig<ReqData>) =>
-        {
-            return await axios.get(url, config);
-        }, sub, query, undefined, config);
-    }
-    public async _post<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
-        {
-            return await axios.post(url, data, config);
-        }, sub, query, data, config);
-    }
-    public async _put<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
-        {
-            return await axios.put(url, data, config);
-        }, sub, query, data, config);
-    }
-    public async _patch<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
-        {
-            return await axios.patch(url, data, config);
-        }, sub, query, data, config);
-    }
-    public async _delete<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
-    {
-        return await this._request<ResData, ReqData>(async (url: string, _?: any, config?: BaseServerConfig<ReqData>) =>
-        {
-            return await axios.delete(url, config);
-        }, sub, query, undefined, config);
-    }
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+import { ConsoleOperation } from "./ConsoleOperation";
+import { EnvService } from "./EnvService";
+import { ErrorOperation } from "./ErrorOperation";
+import { HashOperation } from "./HashOperation";
+import { HTTPError } from "./HTTPError";
+import { ParsedNameValue } from "./ParsedNameValue";
+import { URLOperation } from "./URLOperation";
+
+export interface BaseServerConfig<ReqData> extends AxiosRequestConfig<ReqData>
+{
+    sign?: {
+        header: string;
+        key: string;
+    }
+    onBeforeRequest?: (url: string, config?: AxiosRequestConfig) => void;
+    onAfterRequest?: (url: string, res: AxiosResponse) => void;
+    onError?: (error: Error) => void;
+    error_suppress?: boolean;
+    error_verbose?: boolean;
+}
+export abstract class BaseServer
+{
+    public static isErrorCode(e: any, code: number): boolean
+    {
+        if (axios.isAxiosError(e))
+            if (e.response)
+                if (e.response?.status === code)
+                    return true;
+        if (e instanceof HTTPError)
+            if (e.code === code)
+                return true;
+        return false
+    }
+
+    protected base_url: string;
+    private onBeforeRequests: ((url: string, config?: AxiosRequestConfig) => void)[] = [];
+    private onAfterRequests: ((url: string, res: AxiosResponse) => void)[] = [];
+    protected abstract onError(error: Error): void;
+    public error_suppress?: boolean = false;
+    public error_verbose?: boolean = false;
+
+    constructor(base_url: string)
+    {
+        this.base_url = base_url;
+        this.error_verbose = new EnvService("BASESERVER_ERROR_VERBOSE", false).getBoolean(false);
+    }
+    public addOnBeforeRequest(onBeforeRequest: (url: string, config?: AxiosRequestConfig) => void)
+    {
+        this.onBeforeRequests.push(onBeforeRequest);
+    }
+    public addOnAfterRequest(onAfterRequest: (url: string, res: AxiosResponse) => void)
+    {
+        this.onAfterRequests.push(onAfterRequest);
+    }
+    private async _request<ResData = any, ReqData = any>(onRequest: (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) => Promise<AxiosResponse<ResData>>, sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        let url: string = URLOperation.getLink(this.base_url, sub, query);
+        if (!config)
+            config = {};
+        if (!config.headers)
+            config.headers = {};
+        if (config.withCredentials == null)
+            config.withCredentials = true;
+
+        if (config.sign)
+            if (config.sign?.header)
+                if (config.sign?.key)
+                    if (data)
+                        config.headers[config.sign.header] = HashOperation.SHA256Secret(config.sign.key, data);
+        try
+        {
+            config.onBeforeRequest?.(url, config);
+            this.onBeforeRequests.forEach(onBeforeRequest =>
+            {
+                onBeforeRequest(url, config);
+            });
+            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
+            this.onAfterRequests.forEach(onAfterRequest =>
+            {
+                onAfterRequest(url, response);
+            });
+            config.onAfterRequest?.(url, response);
+            return { response, data: response.data };
+        } catch (error)
+        {
+            let onError = config.onError ?? this.onError;
+            let error_verbose = config.error_verbose ?? this.error_verbose;
+            let error_suppress = config.error_suppress ?? this.error_suppress;
+            if (error instanceof Error)
+            {
+                if (error_verbose)
+                    error.message = `Error calling url '${url}' ` + error.message;
+                if (onError)
+                    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 (!error_suppress)
+                        {
+                            if (error_suppress)
+                                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 (!error_suppress)
+                throw error;
+        }
+        return {} as any;
+    }
+    public async _get<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request<ResData, ReqData>(async (url: string, _?: any, config?: BaseServerConfig<ReqData>) =>
+        {
+            return await axios.get(url, config);
+        }, sub, query, undefined, config);
+    }
+    public async _post<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
+        {
+            return await axios.post(url, data, config);
+        }, sub, query, data, config);
+    }
+    public async _put<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
+        {
+            return await axios.put(url, data, config);
+        }, sub, query, data, config);
+    }
+    public async _patch<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, data?: ReqData, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request<ResData, ReqData>(async (url: string, data?: ReqData, config?: BaseServerConfig<ReqData>) =>
+        {
+            return await axios.patch(url, data, config);
+        }, sub, query, data, config);
+    }
+    public async _delete<ResData = any, ReqData = any>(sub: string, query?: { [name: string]: ParsedNameValue }, config?: BaseServerConfig<ReqData>): Promise<{ response: AxiosResponse<ResData>, data: ResData }>
+    {
+        return await this._request<ResData, ReqData>(async (url: string, _?: any, config?: BaseServerConfig<ReqData>) =>
+        {
+            return await axios.delete(url, config);
+        }, sub, query, undefined, config);
+    }
 }