namirasoft-core 1.2.0 → 1.2.2

package/.gitlab-ci.yml

@@ -1,14 +1,14 @@
-stages:   
- - npm-publish
-
-publish:
-  stage: npm-publish
-  script:
-    - rm -rf node_modules
-    - rm -rf dist
-    - ncu -u
-    - npm i
-    - tsc
-    - npm publish
-  only:
+stages:   
+ - npm-publish
+
+publish:
+  stage: npm-publish
+  script:
+    - rm -rf node_modules
+    - rm -rf dist
+    - ncu -u
+    - npm i
+    - tsc
+    - npm publish
+  only:
     - master

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "namirasoft-core",
     "description": "Namira Software Corporation Core NPM Package",
-    "version": "1.2.0",
+    "version": "1.2.2",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "scripts": {},
@@ -9,10 +9,10 @@
     "license": "MIT",
     "dependencies": {
         "@types/md5": "^2.3.5",
-        "@types/node": "^20.10.0",
+        "@types/node": "^20.10.3",
         "axios": "^1.6.2",
         "md5": "^2.3.0",
         "moment": "^2.29.4",
         "phone": "^3.1.41"
     }
-}
+}

package/src/BaseDatabaseRow.ts

@@ -1,7 +1,7 @@
-export type BaseDatabaseRow<ID> =
-    {
-        id: ID;
-        createdAt: string;
-        updatedAt: string;
-        deletedAt: string;
+export type BaseDatabaseRow<ID> =
+    {
+        id: ID;
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
     }

package/src/BaseServer.ts

@@ -1,73 +1,73 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
-import { SignOperation } from "./SignOperation";
-import { URLOperation } from "./URLOperation";
-import { ErrorOperation } from "./ErrorOperation";
-import { ParsedNameValue } from "./ParsedNameValue";
-
-export abstract class BaseServer
-{
-    protected domain: string = "";
-    constructor(domain: string)
-    {
-        this.domain = domain;
-    }
-    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;
-    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.domain, sub, query);
-        if (!config)
-            config = { headers: {} };
-        if (sign_header)
-            if (sign_key)
-                if (data)
-                    if (config?.headers)
-                        config.headers[sign_header] = SignOperation.sign(sign_key, data);
-        try
-        {
-            this.onBeforeRequest(url, config);
-            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
-            this.onAfterRequest(url, response);
-            return { response, data: response.data };
-        } catch (error)
-        {
-            if (error instanceof Error)
-            {
-                this.onError(error);
-                if (axios.isAxiosError(error))
-                    if (error?.response?.data)
-                        ErrorOperation.throwHTTP(error.response.status, error.response.data);
-            }
-            throw error;
-        }
-    }
-    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 { SignOperation } from "./SignOperation";
+import { URLOperation } from "./URLOperation";
+import { ErrorOperation } from "./ErrorOperation";
+import { ParsedNameValue } from "./ParsedNameValue";
+
+export abstract class BaseServer
+{
+    protected domain: string = "";
+    constructor(domain: string)
+    {
+        this.domain = domain;
+    }
+    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;
+    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.domain, sub, query);
+        if (!config)
+            config = { headers: {} };
+        if (sign_header)
+            if (sign_key)
+                if (data)
+                    if (config?.headers)
+                        config.headers[sign_header] = SignOperation.sign(sign_key, data);
+        try
+        {
+            this.onBeforeRequest(url, config);
+            let response: AxiosResponse<ResData> = await onRequest(url, data, config);
+            this.onAfterRequest(url, response);
+            return { response, data: response.data };
+        } catch (error)
+        {
+            if (error instanceof Error)
+            {
+                this.onError(error);
+                if (axios.isAxiosError(error))
+                    if (error?.response?.data)
+                        ErrorOperation.throwHTTP(error.response.status, error.response.data);
+            }
+            throw error;
+        }
+    }
+    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/ConvertService.ts

@@ -1,85 +1,85 @@
-import { ErrorOperation } from "./ErrorOperation";
-
-export abstract class ConvertService
-{
-    private mandatory: boolean;
-    constructor(mandatory: boolean = false)
-    {
-        this.mandatory = mandatory;
-    }
-    abstract getNullString(): string | null;
-    private checkMandatory<D>(value: D): D
-    {
-        if (this.mandatory)
-            if (value == null || value == undefined)
-                this.onMandatoryError();
-        return value;
-    }
-    protected onMandatoryError(): void
-    {
-        ErrorOperation.throwHTTP(500, "Object value can not be converted.");
-    }
-    getString(_default: string = ""): string
-    {
-        return this.checkMandatory(this.getNullString()) ?? _default;
-    }
-    getNullInt(): number | null
-    {
-        let str = this.getString();
-        if (str == null)
-            return null;
-        let ans = parseInt(str);
-        if (isNaN(ans))
-            return null;
-        return ans;
-    }
-    getInt(_default: number = 0): number
-    {
-        return this.checkMandatory(this.getNullInt()) ?? _default;
-    }
-    getNullFloat(): number | null
-    {
-        let str = this.getString();
-        if (str == null)
-            return null;
-        let ans = parseFloat(str);
-        if (isNaN(ans))
-            return null;
-        return ans;
-    }
-    getFloat(_default: number = 0): number
-    {
-        return this.checkMandatory(this.getNullFloat()) ?? _default;
-    }
-    getNullBoolean(): boolean | null
-    {
-        let str = this.getString();
-        if (str == null)
-            return null;
-        let ans = str.toLowerCase();
-        if (ans == "true")
-            return true;
-        if (ans == "false")
-            return false;
-        return null;
-    }
-    getBoolean(_default: boolean = false): boolean
-    {
-        return this.checkMandatory(this.getNullBoolean()) ?? _default;
-    }
-    getStringArray(delimiter: string = ","): string[]
-    {
-        let ans: string[] = this.getString("").split(delimiter);
-        ans = ans.map(v => `${v}`);
-        ans = ans.filter(x => x);
-        return ans;
-    }
-    getIntArray(delimiter: string = ","): number[]
-    {
-        return this.getStringArray(delimiter).map(x => parseInt(x)).filter(x => !isNaN(x));
-    }
-    getFloatArray(delimiter: string = ","): number[]
-    {
-        return this.getStringArray(delimiter).map(x => parseFloat(x)).filter(x => !isNaN(x));
-    }
+import { ErrorOperation } from "./ErrorOperation";
+
+export abstract class ConvertService
+{
+    private mandatory: boolean;
+    constructor(mandatory: boolean = false)
+    {
+        this.mandatory = mandatory;
+    }
+    abstract getNullString(): string | null;
+    private checkMandatory<D>(value: D): D
+    {
+        if (this.mandatory)
+            if (value == null || value == undefined)
+                this.onMandatoryError();
+        return value;
+    }
+    protected onMandatoryError(): void
+    {
+        ErrorOperation.throwHTTP(500, "Object value can not be converted.");
+    }
+    getString(_default: string = ""): string
+    {
+        return this.checkMandatory(this.getNullString()) ?? _default;
+    }
+    getNullInt(): number | null
+    {
+        let str = this.getString();
+        if (str == null)
+            return null;
+        let ans = parseInt(str);
+        if (isNaN(ans))
+            return null;
+        return ans;
+    }
+    getInt(_default: number = 0): number
+    {
+        return this.checkMandatory(this.getNullInt()) ?? _default;
+    }
+    getNullFloat(): number | null
+    {
+        let str = this.getString();
+        if (str == null)
+            return null;
+        let ans = parseFloat(str);
+        if (isNaN(ans))
+            return null;
+        return ans;
+    }
+    getFloat(_default: number = 0): number
+    {
+        return this.checkMandatory(this.getNullFloat()) ?? _default;
+    }
+    getNullBoolean(): boolean | null
+    {
+        let str = this.getString();
+        if (str == null)
+            return null;
+        let ans = str.toLowerCase();
+        if (ans == "true")
+            return true;
+        if (ans == "false")
+            return false;
+        return null;
+    }
+    getBoolean(_default: boolean = false): boolean
+    {
+        return this.checkMandatory(this.getNullBoolean()) ?? _default;
+    }
+    getStringArray(delimiter: string = ","): string[]
+    {
+        let ans: string[] = this.getString("").split(delimiter);
+        ans = ans.map(v => `${v}`);
+        ans = ans.filter(x => x);
+        return ans;
+    }
+    getIntArray(delimiter: string = ","): number[]
+    {
+        return this.getStringArray(delimiter).map(x => parseInt(x)).filter(x => !isNaN(x));
+    }
+    getFloatArray(delimiter: string = ","): number[]
+    {
+        return this.getStringArray(delimiter).map(x => parseFloat(x)).filter(x => !isNaN(x));
+    }
 }