ismx-nexo-node-app 0.3.24

package/dist/types/business/BusinessServer.d.ts

@@ -0,0 +1,15 @@
+import Service, { HttpRequest, HttpResponse } from "../api/Service";
+import Business from "./Business";
+export default class BusinessServer extends Business {
+    private app;
+    protected onStarted?: () => any;
+    protected onRequest?: (request: HttpRequest) => any;
+    protected onResponse?: (request: HttpRequest, response: HttpResponse) => HttpResponse<any> | undefined;
+    protected onError?: (request: HttpRequest, error: Error) => HttpResponse<any> | undefined | void;
+    protected onEnd?: (request: HttpRequest, response: HttpResponse) => any;
+    constructor();
+    start(port: number): void;
+    setServices(services: Service<any, any>[]): void;
+    private publish;
+    private run;
+}

package/dist/types/business/BusinessState.d.ts

@@ -0,0 +1,2 @@
+export default class BusinessState<Model> {
+}

package/dist/types/business/BusinessThread.d.ts

@@ -0,0 +1,8 @@
+import Business from "./Business";
+export default abstract class BusinessThread extends Business {
+    constructor();
+    abstract run(): void;
+    abstract interval(): number;
+    abstract delay(): number;
+    onError(): void;
+}

package/dist/types/business/utils/CryptoUtils.d.ts

@@ -0,0 +1,5 @@
+export default abstract class CryptoUtils {
+    static zeroPad(buf: Buffer, blocksize: number): Buffer;
+    static encrypt3DES(key: string, message: string): Buffer;
+    static sha256Sign(merchantKey: string, orderId: string, encodedOrder: string): string;
+}

package/dist/types/business/utils/NumberUtils.d.ts

@@ -0,0 +1,3 @@
+export default abstract class NumberUtils {
+    static random(lower: number, upper: number): number;
+}

package/dist/types/business/utils/StringUtils.d.ts

@@ -0,0 +1,5 @@
+export default abstract class StringUtils {
+    static base64Decode(base64: string): Buffer;
+    static base64Encode(buffer: Buffer): string;
+    static base64UrlDecode(base64: string): Buffer;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,35 @@
+import BaseService, { HttpRequest as BaseHttpRequest, HttpResponse as BaseHttpResponse } from "./api/Service";
+export declare const Service: typeof BaseService;
+export interface HttpRequest extends BaseHttpRequest {
+}
+export declare const HttpResponse: typeof BaseHttpResponse;
+import BaseServiceRest from "./api/ServiceRest";
+export declare const ServiceRest: typeof BaseServiceRest;
+import BaseServiceRestFormal, { Wrapper as BaseWrapper } from "./api/ServiceRestFormal";
+export declare const ServiceRestFormal: typeof BaseServiceRestFormal;
+export interface Wrapper<T> extends BaseWrapper<T> {
+}
+import BaseServiceRestFormalTemplate from "./api/ServiceRestFormalTemplate";
+export declare const ServiceRestFormalTemplate: typeof BaseServiceRestFormalTemplate;
+import BaseBusiness from "./business/Business";
+export declare const Business: typeof BaseBusiness;
+import BaseBusinessState from "./business/BusinessState";
+export declare const BusinessState: typeof BaseBusinessState;
+import BaseBusinessProxy, { Module as BaseModule } from "./business/BusinessProxy";
+export declare const BusinessProxy: typeof BaseBusinessProxy;
+export interface Module extends BaseModule {
+}
+import BaseBusinessServer from "./business/BusinessServer";
+export declare const BusinessServer: typeof BaseBusinessServer;
+import BaseBusinessThread from "./business/BusinessThread";
+export declare const BusinessThread: typeof BaseBusinessThread;
+import BaseBusinessErrors, { FormalError as BaseFormalError } from "./business/BusinessErrors";
+export declare const BusinessErrors: typeof BaseBusinessErrors;
+export interface FormalError extends BaseFormalError {
+}
+import BaseBusinessLogger from "./business/BusinessLogger";
+export declare const BusinessLogger: typeof BaseBusinessLogger;
+import BaseRepository from "./repository/Repository";
+export declare const Repository: typeof BaseRepository;
+import BaseRepositoryPostgres from "./repository/RepositoryPostgres";
+export declare const RepositoryPostgres: typeof BaseRepositoryPostgres;

package/dist/types/repository/Repository.d.ts

@@ -0,0 +1,2 @@
+export default class Repository {
+}

package/dist/types/repository/RepositoryPostgres.d.ts

@@ -0,0 +1,75 @@
+import pg, { ClientConfig, QueryResult } from "pg";
+export interface QueryOptions {
+    schema?: string;
+    filters?: string;
+}
+export interface Chain extends ClientConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    schema: string;
+}
+export interface Column {
+    name: string;
+    default?: string;
+}
+export interface Pagination<T> {
+    total: number;
+    elements: T[];
+}
+export type Primitive = string | number | Date | null | undefined;
+export default abstract class RepositoryPostgres {
+    protected chain: Chain;
+    protected client: pg.Client;
+    private connected;
+    private tables;
+    private onConnectListeners;
+    private onQueryWillExecuteListeners;
+    private onQueryDidExecuteListeners;
+    private onIntrospectedListener;
+    private introspectIntervalTime;
+    private schema;
+    constructor();
+    init(chain: Chain): void;
+    isConnected(): boolean;
+    addOnConnect(listener: () => void): void;
+    addOnQueryWillExecuteListener(listener: (query: string) => void): void;
+    setIntrospectInterval(time: number): void;
+    addOnIntrospected(listener: (tables: {
+        [p: string]: Column[];
+    }) => void): void;
+    connect(connection: Chain): void;
+    native(query: string, values?: any[], options?: QueryOptions): Promise<QueryResult>;
+    query<E>(query: string, values?: any[], options?: QueryOptions): Promise<E[]>;
+    one<E>(tableName: string, id: string): Promise<E>;
+    any<E>(tableName: string, filters: {
+        [key: string]: Primitive | Array<any>;
+    }): Promise<E>;
+    find<T>(tableName: string, filters: {
+        [key: string]: Primitive | Array<any>;
+    }): Promise<T[]>;
+    all_depr<E>(tableName: string, options?: QueryOptions): Promise<E[]>;
+    add<E>(tableName: string, object: {
+        [key: string]: Primitive;
+    } | any, id?: string): Promise<E>;
+    addAll<T>(tableName: string, objects: {
+        [key: string]: Primitive;
+    }[]): Promise<T[]>;
+    update(tableName: string, id: string, object: {
+        [key: string]: Primitive;
+    }): Promise<unknown[]>;
+    page<T>(tableName: string, sortKey: string, maxResults?: number, pageNumber?: number, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<Pagination<T>>;
+    count(tableName: string, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<number>;
+    select(tableName: string, select: string, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<string[]>;
+    del(tableName: string, id: string): Promise<void>;
+    private toQuery;
+    private introspect;
+}

package/dist/types/repository/RepositoryRest.d.ts

@@ -0,0 +1,17 @@
+import Repository from './Repository';
+import { HttpRequest } from "../api/Service";
+export interface RestResponse<E = any> extends Response {
+    timestamp?: Date;
+    duration?: number;
+}
+export interface RestOptions {
+    interceptor: (response: RestResponse) => void;
+}
+export default class RepositoryRest<S = any> extends Repository {
+    private readonly baseUrl;
+    private readonly interceptor?;
+    private onRequestListener?;
+    constructor(baseUrl: string, options?: RestOptions);
+    setOnRequestListener(listener: (method: string, endpoint: string, request: HttpRequest) => void): void;
+    call<E = S>(method?: string, endpoint?: string, request?: HttpRequest): Promise<RestResponse<E>>;
+}

package/dist/types/repository/RepositoryRestFormal.d.ts

@@ -0,0 +1,7 @@
+import RepositoryRest from "./RepositoryRest";
+import { Wrapper } from "../api/ServiceRestFormal";
+import { HttpRequest } from "../api/Service";
+export default class RepositoryRestFormal<S = any> extends RepositoryRest<Wrapper<S>> {
+    constructor(baseUrl: string, ...methods: RepositoryRest[]);
+    call<E = S>(method?: string, endpoint?: string, request?: HttpRequest): Promise<E>;
+}

package/dist/types/repository/utils/PostgresUtils.d.ts

@@ -0,0 +1,17 @@
+import { Column, Primitive } from "../RepositoryPostgres";
+export default abstract class PostgresUtils {
+    static stringToCamel(column: string): string;
+    static camelToSnake(column: string): string;
+    static snakeToCamel(obj: any): any;
+    static columns(table: Column[]): string[];
+    static bindOrDefault(table: Column[], object: {
+        [p: string]: Primitive;
+    }, startIndex: any): {
+        bindings: string[];
+        values: any[];
+    };
+    static valueOrDefault(columns: [string], object: any): string[];
+    static fromEntries(iterable: [string, any][]): {
+        [key: string]: any;
+    };
+}

package/dist/types/repository/utils/QueryUtils.d.ts

@@ -0,0 +1,5 @@
+export default class QueryUtils {
+    static map(query?: {
+        [key: string]: string;
+    }): string;
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "ismx-nexo-node-app",
+  "version": "0.3.24",
+  "description": "",
+  "scripts": {
+    "build": "rm -rf ./dist && npx tsc",
+    "publish-patch": "rm -rf ./dist && npx tsc && git add -A && git commit -m \"patch\" && npm version patch && npm publish && git push",
+    "publish-minor": "rm -rf ./dist && npx tsc && git add -A && git commit -m \"minor\" && npm version minor && npm publish && git push",
+    "publish-major": "rm -rf ./dist && npx tsc && git add -A && git commit -m \"major\" && npm version major && npm publish && git push"
+  },
+  "main": "dist/js/index.js",
+  "types": "dist/types/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "esbuild": "^0.23.1",
+    "express": "^4.21.0",
+    "node-fetch": "^2.6.11",
+    "pg": "^8.11.0",
+    "ts-node": "8.10.1"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/node": "^14.0.5",
+    "@types/node-fetch": "^2.6.11",
+    "@types/pg": "^8.11.10",
+    "rollup": "^4.24.4",
+    "rollup-plugin-dts": "^6.1.1",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.3"
+  }
+}

package/src/main/node/api/Service.ts

@@ -0,0 +1,55 @@
+import BusinessServer from "../business/BusinessServer";
+
+export interface HttpRequest<T = any> {
+	id?: string,
+	url?: string,
+	method?: string,
+	endpoint?: string;
+	timestamp?: Date,
+	params?: { [key: string]: string },
+	query?: { [key: string]: string },
+	body?: T,
+	headers?: { [key: string]: string },
+}
+
+export class HttpResponse<T = any> {
+	content?: T;
+	httpCode?: number;
+	headers?: { [key: string]: string };
+
+	static ok<T=any>(content: T) {
+		let response = new HttpResponse();
+		response.content = content;
+		response.httpCode = 200;
+		return response
+	}
+	static ko<T=any>(httpCode: number, content: T | undefined) {
+		let response = new HttpResponse();
+		response.content = content;
+		response.httpCode = httpCode;
+		return response
+	}
+}
+
+export default abstract class Service<Req, Res>
+{
+	public static readonly services: Service<any, any>[] = []
+
+	readonly method: string;
+
+	readonly endpoint: string;
+
+	protected constructor(method: string, endpoint: string = "/") {
+		this.method = method;
+		this.endpoint = endpoint;
+		Service.services.push(this);
+	}
+
+	async serve(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		return HttpResponse.ok({});
+	}
+
+	static clone<R, S>(request: HttpRequest<R>, clone: { params?: { [key: string]: string }, query?: { [key: string]: string }, body?: S, headers?: { [key: string]: string } }): HttpRequest<S> {
+		return { id: request.id, url: request.url, method: request.method, timestamp: request.timestamp, params: clone.params ?? {}, query: clone.query ?? {}, body: clone.body, headers: clone.headers ?? {} };
+	}
+}

package/src/main/node/api/ServiceRest.ts

@@ -0,0 +1,19 @@
+import Service, {HttpRequest, HttpResponse} from "./Service";
+
+export default class ServiceRest<Req, Res> extends Service<Req, Res>
+{
+	constructor(method: string, endpoint: string = "/") {
+		super(method, endpoint);
+	}
+
+	async serve(request: HttpRequest<Req>): Promise<HttpResponse<Res>>
+	{
+		let response = await this.serveRest(request)
+		response.headers = { "Content-Type": "application/json" };
+		return response;
+	}
+
+	async serveRest(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		return {};
+	}
+}

package/src/main/node/api/ServiceRestFormal.ts

@@ -0,0 +1,58 @@
+import Service, {HttpRequest, HttpResponse} from "./Service";
+import ServiceRest from "./ServiceRest";
+
+export interface Wrapper<T> {
+	code: string,
+	description: string,
+	data?: T
+	debug?: Error
+}
+
+export default class ServiceRestFormal<Req=any, Res=any> extends ServiceRest<Req, Wrapper<Res>>
+{
+	constructor(method: string, endpoint: string = "/") {
+		super(method, endpoint);
+	}
+
+	async serveRest(request: HttpRequest<Req>): Promise<HttpResponse<Wrapper<Res>>>
+	{
+		try {
+			let response = await this.serveRestFormal(request);
+			let content: Wrapper<Res> = ({ code: "0", description: "Service execution OK",  data: response.content })
+			return Object.assign({} as HttpResponse<Wrapper<Res>>, response, {content});
+		} catch (error: any) {
+			let content: Wrapper<any> = ({ code: "-1", description: "Internal server error", debug: error.message })
+			throw error;
+		}
+	}
+
+	async serveRestFormal(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		return HttpResponse.ok(null);
+	}
+
+	async unwrap<Res>(request: Promise<HttpResponse<Wrapper<Res>>>): Promise<Res | undefined> {
+		return ServiceRestFormal.unwrap(request);
+	}
+
+	async fullSelect<Req, Res>(request: HttpRequest<Req>, api: { select: ServiceRestFormal<Req, string[]>, full: ServiceRestFormal<Req, Res> }) {
+		return ServiceRestFormal.fullSelect(request, api);
+	}
+
+	static async unwrap<Res>(request: Promise<HttpResponse<Wrapper<Res>>>): Promise<Res | undefined> {
+		let response = await request;
+		if (response.httpCode !== 200) throw response.content;
+		else return response.content?.data;
+	}
+
+	static async fullSelect<Req, Res>(request: HttpRequest<Req>, api: { select: ServiceRestFormal<Req, string[]>, full: ServiceRestFormal<Req, Res> })
+	{
+		return api.select.serve(request).then((result) => {
+			let select = result.content?.data;
+			let requests = select?.map(async (selectId) => {
+				let result = await api.full.serve(Service.clone(request, {query: {id: selectId}}));
+				return result.content?.data;
+			});
+			return Promise.all(requests ?? []);
+		});
+	}
+}

package/src/main/node/api/ServiceRestFormalTemplate.ts

@@ -0,0 +1,133 @@
+import Service, {HttpRequest, HttpResponse} from "./Service";
+import ServiceRestFormal, {Wrapper} from "./ServiceRestFormal";
+import RepositoryPostgres, {Pagination} from "../repository/RepositoryPostgres";
+import BusinessErrors from "../business/BusinessErrors";
+
+export default class ServiceRestFormalTemplate<Req=any, Res=any>
+{
+	readonly resource: string;
+	readonly tableName: string;
+	readonly database!: RepositoryPostgres;
+	readonly errors!: BusinessErrors;
+
+	readonly get!: ServiceRestFormal<Req, Res>;
+	readonly post!: ServiceRestFormal<Req, Res>;
+	readonly put!: ServiceRestFormal<Req, Res>;
+	readonly del!: ServiceRestFormal<Req, Res>;
+	readonly select!: ServiceRestFormal<Req, string[]>;
+	readonly exist!: ServiceRestFormal<Req, Boolean>;
+
+	readonly count!: ServiceRestFormal<Req, Number>;
+	readonly getList!: ServiceRestFormal<Req, Res[]>;
+
+	readonly postList!: ServiceRestFormal<Req, Res[]>;
+	readonly page!: ServiceRestFormal<Req, Pagination<Res>>;
+	readonly map!: ServiceRestFormal<Req, { [key:string]: Res }>;
+
+	constructor(resource: string, tableName: string) {
+		this.resource = resource;
+		this.tableName = tableName;
+
+		this.get = new ServiceRestFormal("GET", `${resource}`);
+		this.get.serveRestFormal = this.serveGet.bind(this);
+
+		this.getList = new ServiceRestFormal("GET", `${resource}/list`);
+		this.getList.serveRestFormal = this.serveGetList.bind(this);
+
+		this.postList = new ServiceRestFormal("POST", `${resource}/list`);
+		this.postList.serveRestFormal = this.servePostList.bind(this);
+
+		this.page = new ServiceRestFormal("GET", `${resource}/page`);
+		this.page.serveRestFormal = this.servePage.bind(this);
+
+		this.map = new ServiceRestFormal("GET", `${resource}/map`);
+		this.map.serveRestFormal = this.serveMap.bind(this);
+
+		this.select = new ServiceRestFormal("GET", `${resource}/select`);
+		this.select.serveRestFormal = this.serveSelect.bind(this);
+
+		this.exist = new ServiceRestFormal("GET", `${resource}/exist`);
+		this.exist.serveRestFormal = this.serveExist.bind(this);
+
+		this.count = new ServiceRestFormal("GET", `${resource}/count`);
+		this.count.serveRestFormal = this.serveCount.bind(this);
+
+		this.post = new ServiceRestFormal("POST", `${resource}`);
+		this.post.serveRestFormal = this.servePost.bind(this);
+
+		this.put = new ServiceRestFormal("PUT", `${resource}`);
+		this.put.serveRestFormal = this.servePut.bind(this);
+
+		this.del = new ServiceRestFormal("DELETE", `${resource}`);
+		this.del.serveRestFormal = this.serveDel.bind(this);
+	}
+
+	protected async serveGet(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		let id = this.errors.getQuery("id", request.query)
+		let result = await this.database.one<Res>(this.tableName, id);
+		return HttpResponse.ok(result);
+	}
+
+	protected async serveGetList(request: HttpRequest<Req>): Promise<HttpResponse<Res[]>> {
+		return HttpResponse.ok(await this.database.find<Res>(this.tableName, { ...request.query }));
+	}
+
+	protected async servePostList(request: HttpRequest<Req>): Promise<HttpResponse<Res[]>> {
+		let list = request.body
+		if (!(list instanceof Array)) throw new Error("body must be a list");
+		return HttpResponse.ok(this.database.addAll(this.tableName, list));
+	}
+
+	protected async servePage(request: HttpRequest<Req>): Promise<HttpResponse<Pagination<Res>>> {
+		let maxResults = this.errors.getQuery("maxResults", request.query);
+		let maxResultsNum = this.errors.isType("maxResults", maxResults, "number", Number.parseInt);
+
+		let pageNumber = this.errors.getQuery("pageNumber", request.query)
+		let pageNumberNum = this.errors.isType("pageNumber", pageNumber, "number", Number.parseInt)
+
+		let results = await this.database.page(this.tableName, "timestamp", maxResultsNum, pageNumberNum);
+		return HttpResponse.ok(results);
+	}
+
+	protected async serveMap(request: HttpRequest<Req>): Promise<HttpResponse<{[key: string]: Res}>> {
+		let results = await this.database.find<Res>(this.tableName, { ...request.query });
+		let response: {[key: string]: Res} = {}; for (let result of results) {
+			let key = (result as any)[this.indexer];
+			if (!key) return HttpResponse.ok({});
+			else response[key] = result;
+		}
+		return HttpResponse.ok(response);
+	}
+
+	protected indexer = "id"
+	protected async serveSelect(request: HttpRequest<Req>): Promise<HttpResponse<string[]>> {
+		let selection = request.query?.["selection"] ?? this.indexer;
+		delete request.query?.["selection"];
+		let select = await this.database.select(this.tableName, selection, { ...request.query });
+		return HttpResponse.ok(select);
+	}
+
+	protected async serveExist(request: HttpRequest<Req>): Promise<HttpResponse<Boolean>> {
+		return HttpResponse.ok((await this.database.count(this.tableName, { ...request.query })) > 0);
+	}
+
+	protected async serveCount(request: HttpRequest<Req>): Promise<HttpResponse<Number>> {
+		return HttpResponse.ok((await this.database.count(this.tableName, { ...request.query })));
+	}
+
+	protected async servePost(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		let entity = this.database.add(this.tableName, request.body);
+		return HttpResponse.ok(entity);
+	}
+
+	protected async servePut(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		return HttpResponse.ok("not implemented yet");
+	}
+
+	protected async serveDel(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+		return HttpResponse.ok("not implemented yet");
+	}
+
+	protected readonly unwrap = ServiceRestFormal.unwrap
+	protected readonly fullSelect = ServiceRestFormal.fullSelect
+}

package/src/main/node/business/Business.ts

@@ -0,0 +1,3 @@
+export default class Business {
+
+}

package/src/main/node/business/BusinessErrors.ts

@@ -0,0 +1,94 @@
+export interface FormalError {
+    id: string;
+    code: string;
+    description: string;
+    httpCode?: number;
+    group?: string;
+}
+
+export default class BusinessErrors {
+
+    private errors: { [key: string]: FormalError } = {};
+
+    async init() { }
+
+    setErrors(errors: { [key: string]: FormalError }) {
+        this.errors = errors;
+    }
+
+    get(code: string, ...params: string[]) {
+        let error = this.errors[code] ?? this.getFallback();
+        let result = Object.assign({} as FormalError, error);
+        for (const p in params) result.description = result.description?.replace(`\${${p}}`, params[p])
+        return result;
+    }
+
+    except(code: string, ...params: string[]) {
+        let error = this.get(code, ...params)
+        //this.onExcept?.(error)
+        throw error;
+    }
+
+    notFound(endpoint: string) {
+        this.except("0004", endpoint)
+    }
+
+    getQuery(key: string, query: {[key: string]: string}|undefined): string {
+        if (!query || !query[key]) this.except("0011", key)
+        return query![key];
+    }
+
+    eitherQuery(keys: string[], query: { [p: string]: string }): { key: string, value: string, index: number } {
+        let result = undefined;
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            if (query[key] !== undefined) {
+                if (!result) result = {key: key, value: query[key], index: i}
+                else this.except("0017", keys.join(" or "));
+            }
+        }
+        if (!result) this.except("0016", keys.join(" or "));
+        return result!;
+    }
+
+    getPath(key: string, path: {[key: string]: string}): string {
+        if (!path[key]) this.except("0012", key)
+        return path[key];
+    }
+
+    getBody<T>(body?: T): T {
+        if (!body) this.except("0013")
+        return body!;
+    }
+
+    getHeaders(key: string, headers: {[key: string]: string}): string {
+        if (!headers[key]) this.except("0015", key)
+        return headers[key];
+    }
+
+    isType<T>(key: string, value: string, type:string, assertion: (value:string)=>T): T {
+        try { if (!assertion(value)) throw new Error(); }
+        catch { this.except("0021", key, type) }
+        return assertion(value);
+    }
+
+    exists<T>(type: string, key: string, value: string, object?:T): T  {
+        if (!object) this.except("0030", type, key, value);
+        return object!;
+    }
+
+    isRegex(key: string, value: string, regex: string):string {
+        if (!new RegExp(regex).test(value))
+            this.except("0022", key)
+        return value;
+    }
+
+    isDate(key:string, value:string, format: string): Date {
+        this.except("0023", key, format);
+        return new Date(value);
+    }
+
+    getFallback(): FormalError {
+        return { id: "-1", description: "Internal Server error", code: "-1", httpCode: 500 };
+    }
+}

package/src/main/node/business/BusinessLogger.ts

@@ -0,0 +1,6 @@
+export default class BusinessLogger
+{
+    i(message: string) {
+        console.log(`${"I"}: ${new Date().toISOString()}\t${message}`)
+    };
+}