ismx-nexo-node-app 0.3.27 → 0.3.29

package/dist/js/api/ServiceRestFormalTemplate.js

@@ -15,11 +15,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Service_1 = require("./Service");
 const ServiceRestFormal_1 = __importDefault(require("./ServiceRestFormal"));
 class ServiceRestFormalTemplate {
-    constructor(resource, tableName) {
+    constructor(resource, database, tableName) {
         this.indexer = "id";
         this.unwrap = ServiceRestFormal_1.default.unwrap;
         this.fullSelect = ServiceRestFormal_1.default.fullSelect;
         this.resource = resource;
+        this.database = database;
         this.tableName = tableName;
         this.get = new ServiceRestFormal_1.default("GET", `${resource}`);
         this.get.serveRestFormal = this.serveGet.bind(this);
@@ -44,9 +45,29 @@ class ServiceRestFormalTemplate {
         this.del = new ServiceRestFormal_1.default("DELETE", `${resource}`);
         this.del.serveRestFormal = this.serveDel.bind(this);
     }
+    getFormalId(request) {
+        var _a;
+        let id = (_a = request.query) === null || _a === void 0 ? void 0 : _a[this.indexer];
+        if (id === undefined)
+            throw new Error();
+        else
+            return id;
+    }
+    getFormalPage(request) {
+        var _a, _b;
+        let maxResultsStr = (_a = request.query) === null || _a === void 0 ? void 0 : _a["maxResults"];
+        if (!maxResultsStr)
+            throw new Error();
+        let maxResults = Number.parseInt(maxResultsStr);
+        let pageNumberStr = (_b = request.query) === null || _b === void 0 ? void 0 : _b["pageNumber"];
+        if (!pageNumberStr)
+            throw new Error();
+        let pageNumber = Number.parseInt(pageNumberStr);
+        return { maxResults, pageNumber };
+    }
     serveGet(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            let id = this.errors.getQuery("id", request.query);
+            let id = this.getFormalId(request);
             let result = yield this.database.one(this.tableName, id);
             return Service_1.HttpResponse.ok(result);
         });
@@ -66,11 +87,8 @@ class ServiceRestFormalTemplate {
     }
     servePage(request) {
         return __awaiter(this, void 0, void 0, function* () {
-            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 = yield this.database.page(this.tableName, "timestamp", maxResultsNum, pageNumberNum);
+            let { maxResults, pageNumber } = this.getFormalPage(request);
+            let results = yield this.database.page(this.tableName, "timestamp", maxResults, pageNumber);
             return Service_1.HttpResponse.ok(results);
         });
     }

package/dist/js/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryUtils = exports.RepositoryPostgres = exports.Repository = exports.StringUtils = exports.NumberUtils = exports.CryptoUtils = exports.BusinessLogger = exports.BusinessErrors = exports.BusinessThread = exports.BusinessServer = exports.BusinessProxy = exports.BusinessState = exports.Business = exports.ServiceRestFormalTemplate = exports.ServiceRestFormal = exports.ServiceRest = exports.HttpResponse = exports.Service = void 0;
+exports.QueryUtils = exports.RepositoryDatabasePostgres = exports.RepositoryPostgres = exports.Repository = exports.StringUtils = exports.NumberUtils = exports.CryptoUtils = exports.BusinessLogger = exports.BusinessErrors = exports.BusinessThread = exports.BusinessServer = exports.BusinessProxy = exports.BusinessState = exports.Business = exports.ServiceRestFormalTemplate = exports.ServiceRestFormal = exports.ServiceRest = exports.HttpResponse = exports.Service = void 0;
 const Service_1 = __importStar(require("./api/Service"));
 exports.Service = Service_1.default;
 exports.HttpResponse = Service_1.HttpResponse;
@@ -60,7 +60,9 @@ exports.StringUtils = StringUtils_1.default;
 /**************************************************************/
 const Repository_1 = __importDefault(require("./repository/Repository"));
 exports.Repository = Repository_1.default;
-const RepositoryPostgres_1 = __importDefault(require("./repository/RepositoryPostgres"));
-exports.RepositoryPostgres = RepositoryPostgres_1.default;
+const RepositoryDatabase_1 = __importDefault(require("./repository/RepositoryDatabase"));
+exports.RepositoryPostgres = RepositoryDatabase_1.default;
+const RepositoryDatabasePostgres_1 = __importDefault(require("./repository/RepositoryDatabasePostgres"));
+exports.RepositoryDatabasePostgres = RepositoryDatabasePostgres_1.default;
 const QueryUtils_1 = __importDefault(require("./repository/utils/QueryUtils"));
 exports.QueryUtils = QueryUtils_1.default;

package/dist/js/repository/RepositoryDatabase.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Repository_1 = __importDefault(require("./Repository"));
+class RepositoryDatabase extends Repository_1.default {
+    constructor() {
+        super(...arguments);
+        this.connected = false;
+        this.onConnectListeners = [];
+        this.onQueryWillExecuteListeners = [];
+        this.onQueryDidExecuteListeners = [];
+    }
+    init(chain) {
+        this.chain = chain;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    addOnConnect(listener) {
+        this.onConnectListeners.push(listener);
+    }
+    addOnQueryWillExecuteListener(listener) {
+        this.onQueryWillExecuteListeners.push(listener);
+    }
+    addOnQueryDidExecuteListener(listener) {
+        this.onQueryDidExecuteListeners.push(listener);
+    }
+}
+exports.default = RepositoryDatabase;

package/dist/js/repository/{RepositoryPostgres.js → RepositoryDatabasePostgres.js}

@@ -14,43 +14,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const pg_1 = __importDefault(require("pg"));
 const PostgresUtils_1 = __importDefault(require("./utils/PostgresUtils"));
-class RepositoryPostgres {
+const RepositoryDatabase_1 = __importDefault(require("./RepositoryDatabase"));
+class RepositoryDatabasePostgres extends RepositoryDatabase_1.default {
     constructor() {
-        this.connected = false;
+        super();
+        this.introspectIntervalTime = 60 * 60 * 1000;
         this.tables = {};
-        this.onConnectListeners = [];
-        this.onQueryWillExecuteListeners = [];
-        this.onQueryDidExecuteListeners = [];
-        this.onIntrospectedListener = [];
-        this.introspectIntervalTime = 5 * 60 * 1000;
         this.schema = "public";
-        this.query = this.query.bind(this);
-        this.one = this.one.bind(this);
-        this.add = this.add.bind(this);
-        this.update = this.update.bind(this);
-        this.del = this.del.bind(this);
-        this.introspect = this.introspect.bind(this);
+        this.onIntrospectedListeners = [];
+        this.native = this.native.bind(this);
     }
     init(chain) {
-        this.chain = chain;
+        super.init(chain);
         this.schema = chain.schema || "public";
         this.connect(chain);
     }
-    isConnected() {
-        return this.connected;
+    addOnIntrospectedListener(listener) {
+        this.onIntrospectedListeners.push(listener);
     }
-    addOnConnect(listener) { this.onConnectListeners.push(listener); }
-    addOnQueryWillExecuteListener(listener) { this.onQueryWillExecuteListeners.push(listener); }
-    setIntrospectInterval(time) { this.introspectIntervalTime = time; }
-    addOnIntrospected(listener) { this.onIntrospectedListener.push(listener); }
     connect(connection) {
-        this.client = new pg_1.default.Client(connection);
-        this.client.connect().then(() => __awaiter(this, void 0, void 0, function* () {
-            yield this.introspect();
-            setInterval(this.introspect, this.introspectIntervalTime);
-            this.connected = true;
-            this.onConnectListeners.map(l => l());
-        }));
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client = new pg_1.default.Client(connection);
+            return this.client.connect().then(() => __awaiter(this, void 0, void 0, function* () {
+                yield this.introspect();
+                setInterval(this.introspect, this.introspectIntervalTime);
+                this.connected = true;
+                this.onConnectListeners.map(l => l());
+            }));
+        });
     }
     native(query_1) {
         return __awaiter(this, arguments, void 0, function* (query, values = [], options = {}) {
@@ -136,7 +127,7 @@ class RepositoryPostgres {
             let values = [id, ...columns.map((column) => object[PostgresUtils_1.default.stringToCamel(column)])];
             let query = `UPDATE ${this.schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `;
             query += `RETURNING *`;
-            return this.query(query, values);
+            return this.query(query, values).then((result) => result[0]);
         });
     }
     page(tableName_1, sortKey_1) {
@@ -208,8 +199,8 @@ class RepositoryPostgres {
         `, [this.schema]);
             for (let table of result.rows)
                 this.tables[table["name"]] = table["columns"];
-            this.onIntrospectedListener.forEach((l) => l(this.tables));
+            this.onIntrospectedListeners.forEach((l) => l(this.tables));
         });
     }
 }
-exports.default = RepositoryPostgres;
+exports.default = RepositoryDatabasePostgres;

package/dist/types/api/ServiceRestFormalTemplate.d.ts

@@ -1,40 +1,44 @@
 import { HttpRequest, HttpResponse } from "./Service";
 import ServiceRestFormal from "./ServiceRestFormal";
-import RepositoryPostgres, { Pagination } from "../repository/RepositoryPostgres";
-import BusinessErrors from "../business/BusinessErrors";
-export default class ServiceRestFormalTemplate<Req = any, Res = any> {
+import { Pagination } from "../repository/RepositoryDatabase";
+import RepositoryDatabase from "../repository/RepositoryDatabase";
+export default class ServiceRestFormalTemplate<Model = 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;
+    readonly database: RepositoryDatabase;
+    readonly get: ServiceRestFormal<any, Model>;
+    readonly getList: ServiceRestFormal<any, Model[]>;
+    readonly post: ServiceRestFormal<Model, Model>;
+    readonly postList: ServiceRestFormal<Model[], Model[]>;
+    readonly put: ServiceRestFormal<Model, Model>;
+    readonly del: ServiceRestFormal<any, Model>;
+    readonly select: ServiceRestFormal<any, string[]>;
+    readonly exist: ServiceRestFormal<any, Boolean>;
+    readonly count: ServiceRestFormal<any, Number>;
+    readonly page: ServiceRestFormal<any, Pagination<Model>>;
+    readonly map: ServiceRestFormal<any, {
+        [key: string]: Model;
     }>;
-    constructor(resource: string, tableName: string);
-    protected serveGet(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
-    protected serveGetList(request: HttpRequest<Req>): Promise<HttpResponse<Res[]>>;
-    protected servePostList(request: HttpRequest<Req>): Promise<HttpResponse<Res[]>>;
-    protected servePage(request: HttpRequest<Req>): Promise<HttpResponse<Pagination<Res>>>;
-    protected serveMap(request: HttpRequest<Req>): Promise<HttpResponse<{
-        [key: string]: Res;
-    }>>;
+    constructor(resource: string, database: RepositoryDatabase, tableName: string);
     protected indexer: string;
-    protected serveSelect(request: HttpRequest<Req>): Promise<HttpResponse<string[]>>;
-    protected serveExist(request: HttpRequest<Req>): Promise<HttpResponse<Boolean>>;
-    protected serveCount(request: HttpRequest<Req>): Promise<HttpResponse<Number>>;
-    protected servePost(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
-    protected servePut(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
-    protected serveDel(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
+    getFormalId(request: HttpRequest): string;
+    getFormalPage(request: HttpRequest): {
+        maxResults: number;
+        pageNumber: number;
+    };
+    protected serveGet(request: HttpRequest): Promise<HttpResponse<Model>>;
+    protected serveGetList(request: HttpRequest): Promise<HttpResponse<Model[]>>;
+    protected servePostList(request: HttpRequest<Model[]>): Promise<HttpResponse<Model[]>>;
+    protected servePage(request: HttpRequest): Promise<HttpResponse<Pagination<Model>>>;
+    protected serveMap(request: HttpRequest): Promise<HttpResponse<{
+        [key: string]: Model;
+    }>>;
+    protected serveSelect(request: HttpRequest): Promise<HttpResponse<string[]>>;
+    protected serveExist(request: HttpRequest): Promise<HttpResponse<Boolean>>;
+    protected serveCount(request: HttpRequest): Promise<HttpResponse<Number>>;
+    protected servePost(request: HttpRequest<Model>): Promise<HttpResponse<Model>>;
+    protected servePut(request: HttpRequest<Model>): Promise<HttpResponse<Model>>;
+    protected serveDel(request: HttpRequest): Promise<HttpResponse<Model>>;
     protected readonly unwrap: typeof ServiceRestFormal.unwrap;
     protected readonly fullSelect: typeof ServiceRestFormal.fullSelect;
 }

package/dist/types/index.d.ts

@@ -39,7 +39,9 @@ export declare const StringUtils: typeof _StringUtils;
 /**************************************************************/
 import BaseRepository from "./repository/Repository";
 export declare const Repository: typeof BaseRepository;
-import BaseRepositoryPostgres from "./repository/RepositoryPostgres";
-export declare const RepositoryPostgres: typeof BaseRepositoryPostgres;
+import _RepositoryDatabase from "./repository/RepositoryDatabase";
+export declare const RepositoryPostgres: typeof _RepositoryDatabase;
+import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres";
+export declare const RepositoryDatabasePostgres: typeof _RepositoryDatabasePostgres;
 import _QueryUtils from "./repository/utils/QueryUtils";
 export declare const QueryUtils: typeof _QueryUtils;

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

@@ -0,0 +1,61 @@
+import Repository from "./Repository";
+import { QueryResult } from "pg";
+export interface QueryOptions {
+    schema?: string;
+    filters?: string;
+}
+export interface Chain {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    schema: string;
+}
+export interface Pagination<T> {
+    total: number;
+    elements: T[];
+}
+export type Primitive = string | number | Date | null | undefined;
+export default abstract class RepositoryDatabase extends Repository {
+    protected connected: boolean;
+    protected chain: Chain;
+    init(chain: Chain): void;
+    isConnected(): boolean;
+    protected readonly onConnectListeners: (() => void)[];
+    addOnConnect(listener: () => void): void;
+    protected readonly onQueryWillExecuteListeners: ((key: string) => void)[];
+    addOnQueryWillExecuteListener(listener: (query: string) => void): void;
+    protected readonly onQueryDidExecuteListeners: ((query: string) => void)[];
+    addOnQueryDidExecuteListener(listener: (query: string) => void): void;
+    abstract connect(connection: Chain): Promise<void>;
+    abstract native(query: string, values: any[], options: QueryOptions): Promise<QueryResult>;
+    abstract query<E>(query: string, values: any[], options: QueryOptions): Promise<E[]>;
+    abstract one<E>(tableName: string, id: string): Promise<E>;
+    abstract any<E>(tableName: string, filters: {
+        [key: string]: Primitive | Array<any>;
+    }): Promise<E>;
+    abstract find<E>(tableName: string, filters: {
+        [key: string]: Primitive | Array<any>;
+    }): Promise<E[]>;
+    abstract all_depr<E>(tableName: string, options: QueryOptions): Promise<E[]>;
+    abstract add<E>(tableName: string, object: {
+        [key: string]: Primitive;
+    } | any, id?: string): Promise<E>;
+    abstract addAll<T>(tableName: string, objects: {
+        [key: string]: Primitive;
+    }[]): Promise<T[]>;
+    abstract update<T>(tableName: string, id: string, object: {
+        [key: string]: Primitive;
+    }): Promise<T>;
+    abstract page<T>(tableName: string, sortKey: string, maxResults: number, pageNumber: number, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<Pagination<T>>;
+    abstract count(tableName: string, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<number>;
+    abstract select(tableName: string, select: string, filters?: {
+        [key: string]: Primitive | Array<Primitive>;
+    }): Promise<string[]>;
+    abstract del<T>(tableName: string, id: string): Promise<T>;
+}

package/dist/types/repository/{RepositoryPostgres.d.ts → RepositoryDatabasePostgres.d.ts}

@@ -1,46 +1,21 @@
-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;
-}
+import pg, { QueryResult } from "pg";
+import RepositoryDatabase, { Chain, Pagination, Primitive, QueryOptions } from "./RepositoryDatabase";
 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;
+export default class RepositoryDatabasePostgres extends RepositoryDatabase {
+    private readonly introspectIntervalTime;
     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[];
+    private onIntrospectedListeners;
+    addOnIntrospectedListener(listener: (tables: {
+        [key: string]: Column[];
     }) => void): void;
-    connect(connection: Chain): void;
+    connect(connection: Chain): Promise<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>;
@@ -57,9 +32,9 @@ export default abstract class RepositoryPostgres {
     addAll<T>(tableName: string, objects: {
         [key: string]: Primitive;
     }[]): Promise<T[]>;
-    update(tableName: string, id: string, object: {
+    update<T>(tableName: string, id: string, object: {
         [key: string]: Primitive;
-    }): Promise<unknown[]>;
+    }): Promise<T>;
     page<T>(tableName: string, sortKey: string, maxResults?: number, pageNumber?: number, filters?: {
         [key: string]: Primitive | Array<Primitive>;
     }): Promise<Pagination<T>>;
@@ -69,7 +44,7 @@ export default abstract class RepositoryPostgres {
     select(tableName: string, select: string, filters?: {
         [key: string]: Primitive | Array<Primitive>;
     }): Promise<string[]>;
-    del(tableName: string, id: string): Promise<void>;
+    del<T>(tableName: string, id: string): Promise<T>;
     private toQuery;
     private introspect;
 }

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

@@ -1,4 +1,5 @@
-import { Column, Primitive } from "../RepositoryPostgres";
+import { Column } from "../RepositoryDatabasePostgres";
+import { Primitive } from "../RepositoryDatabase";
 export default abstract class PostgresUtils {
     static stringToCamel(column: string): string;
     static camelToSnake(column: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ismx-nexo-node-app",
-  "version": "0.3.27",
+  "version": "0.3.29",
   "description": "",
   "scripts": {
     "build": "rm -rf ./dist && npx tsc",

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

@@ -1,31 +1,30 @@
-import Service, {HttpRequest, HttpResponse} from "./Service";
-import ServiceRestFormal, {Wrapper} from "./ServiceRestFormal";
-import RepositoryPostgres, {Pagination} from "../repository/RepositoryPostgres";
-import BusinessErrors from "../business/BusinessErrors";
+import {HttpRequest, HttpResponse} from "./Service";
+import ServiceRestFormal from "./ServiceRestFormal";
+import {Pagination} from "../repository/RepositoryDatabase";
+import RepositoryDatabase from "../repository/RepositoryDatabase";
 
-export default class ServiceRestFormalTemplate<Req=any, Res=any>
+export default class ServiceRestFormalTemplate<Model=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) {
+	readonly database!: RepositoryDatabase;
+
+	readonly get!: ServiceRestFormal<any, Model>;
+	readonly getList!: ServiceRestFormal<any, Model[]>;
+	readonly post!: ServiceRestFormal<Model, Model>;
+	readonly postList!: ServiceRestFormal<Model[], Model[]>;
+	readonly put!: ServiceRestFormal<Model, Model>;
+	readonly del!: ServiceRestFormal<any, Model>;
+
+	readonly select!: ServiceRestFormal<any, string[]>;
+	readonly exist!: ServiceRestFormal<any, Boolean>;
+	readonly count!: ServiceRestFormal<any, Number>;
+	readonly page!: ServiceRestFormal<any, Pagination<Model>>;
+	readonly map!: ServiceRestFormal<any, { [key:string]: Model }>;
+
+	constructor(resource: string, database: RepositoryDatabase, tableName: string) {
 		this.resource = resource;
+		this.database = database;
 		this.tableName = tableName;
 
 		this.get = new ServiceRestFormal("GET", `${resource}`);
@@ -62,36 +61,48 @@ export default class ServiceRestFormalTemplate<Req=any, Res=any>
 		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);
+	protected indexer = "id"
+	getFormalId(request: HttpRequest): string {
+		let id = request.query?.[this.indexer];
+		if (id === undefined) throw new Error();
+		else return id;
+	}
+
+	getFormalPage(request: HttpRequest): { maxResults: number, pageNumber: number } {
+		let maxResultsStr = request.query?.["maxResults"];
+		if (!maxResultsStr) throw new Error();
+		let maxResults = Number.parseInt(maxResultsStr);
+		let pageNumberStr = request.query?.["pageNumber"];
+		if (!pageNumberStr) throw new Error();
+		let pageNumber = Number.parseInt(pageNumberStr);
+		return { maxResults, pageNumber }
+	}
+
+	protected async serveGet(request: HttpRequest): Promise<HttpResponse<Model>> {
+		let id = this.getFormalId(request);
+		let result = await this.database.one<Model>(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 serveGetList(request: HttpRequest): Promise<HttpResponse<Model[]>> {
+		return HttpResponse.ok(await this.database.find<Model>(this.tableName, { ...request.query }));
 	}
 
-	protected async servePostList(request: HttpRequest<Req>): Promise<HttpResponse<Res[]>> {
+	protected async servePostList(request: HttpRequest<Model[]>): Promise<HttpResponse<Model[]>> {
 		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));
+		return HttpResponse.ok(this.database.addAll<Model>(this.tableName, list as any));
 	}
 
-	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);
+	protected async servePage(request: HttpRequest): Promise<HttpResponse<Pagination<Model>>> {
+		let { maxResults, pageNumber } = this.getFormalPage(request);
+		let results = await this.database.page<Model>(this.tableName, "timestamp", maxResults, pageNumber);
 		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) {
+	protected async serveMap(request: HttpRequest): Promise<HttpResponse<{[key: string]: Model}>> {
+		let results = await this.database.find<Model>(this.tableName, { ...request.query });
+		let response: {[key: string]: Model} = {}; for (let result of results) {
 			let key = (result as any)[this.indexer];
 			if (!key) return HttpResponse.ok({});
 			else response[key] = result;
@@ -99,32 +110,31 @@ export default class ServiceRestFormalTemplate<Req=any, Res=any>
 		return HttpResponse.ok(response);
 	}
 
-	protected indexer = "id"
-	protected async serveSelect(request: HttpRequest<Req>): Promise<HttpResponse<string[]>> {
+	protected async serveSelect(request: HttpRequest): 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>> {
+	protected async serveExist(request: HttpRequest): Promise<HttpResponse<Boolean>> {
 		return HttpResponse.ok((await this.database.count(this.tableName, { ...request.query })) > 0);
 	}
 
-	protected async serveCount(request: HttpRequest<Req>): Promise<HttpResponse<Number>> {
+	protected async serveCount(request: HttpRequest): 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);
+	protected async servePost(request: HttpRequest<Model>): Promise<HttpResponse<Model>> {
+		let entity = this.database.add<Model>(this.tableName, request.body);
 		return HttpResponse.ok(entity);
 	}
 
-	protected async servePut(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+	protected async servePut(request: HttpRequest<Model>): Promise<HttpResponse<Model>> {
 		return HttpResponse.ok("not implemented yet");
 	}
 
-	protected async serveDel(request: HttpRequest<Req>): Promise<HttpResponse<Res>> {
+	protected async serveDel(request: HttpRequest): Promise<HttpResponse<Model>> {
 		return HttpResponse.ok("not implemented yet");
 	}
 

package/src/main/node/index.ts

@@ -52,8 +52,11 @@ export const StringUtils = _StringUtils;
 import BaseRepository from "./repository/Repository";
 export const Repository = BaseRepository
 
-import BaseRepositoryPostgres from "./repository/RepositoryPostgres";
-export const RepositoryPostgres = BaseRepositoryPostgres
+import _RepositoryDatabase from "./repository/RepositoryDatabase";
+export const RepositoryPostgres = _RepositoryDatabase
+
+import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres";
+export const RepositoryDatabasePostgres = _RepositoryDatabasePostgres
 
 import _QueryUtils from "./repository/utils/QueryUtils";
 export const QueryUtils = _QueryUtils;

package/src/main/node/repository/RepositoryDatabase.ts

@@ -0,0 +1,81 @@
+import Repository from "./Repository";
+import {QueryResult} from "pg";
+
+export interface QueryOptions {
+    schema?: string;
+    filters?: string;
+}
+
+export interface Chain {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+    schema: string;
+}
+
+export interface Pagination<T> {
+    total: number;
+    elements: T[];
+}
+
+export type Primitive = string | number | Date | null | undefined;
+
+export default abstract class RepositoryDatabase extends Repository
+{
+    protected connected: boolean = false;
+
+    protected chain!: Chain;
+
+    init(chain: Chain) {
+        this.chain = chain;
+    }
+
+    isConnected() {
+        return this.connected;
+    }
+
+    protected readonly onConnectListeners: (()=>void)[] = [];
+    addOnConnect(listener: () => void) {
+        this.onConnectListeners.push(listener);
+    }
+
+    protected readonly onQueryWillExecuteListeners: ((key:string)=>void)[] = [];
+    addOnQueryWillExecuteListener(listener: (query: string) => void) {
+        this.onQueryWillExecuteListeners.push(listener);
+    }
+
+    protected readonly onQueryDidExecuteListeners: ((query:string)=>void)[] = [];
+    addOnQueryDidExecuteListener(listener: (query:string)=>void) {
+        this.onQueryDidExecuteListeners.push(listener);
+    }
+
+    abstract connect(connection: Chain): Promise<void>;
+
+    abstract native(query: string, values: any[], options: QueryOptions): Promise<QueryResult>;
+
+    abstract query<E>(query: string, values: any[], options: QueryOptions): Promise<E[]>;
+
+    abstract one<E>(tableName: string, id: string): Promise<E>;
+
+    abstract any<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E>;
+
+    abstract find<E>(tableName: string, filters: { [key: string]: Primitive | Array<any> }): Promise<E[]>;
+
+    abstract all_depr<E>(tableName: string, options: QueryOptions): Promise<E[]>;
+
+    abstract add<E>(tableName: string, object: {[key:string]:Primitive} | any, id?: string): Promise<E>;
+
+    abstract addAll<T>(tableName: string, objects: {[key:string]:Primitive }[]): Promise<T[]>;
+
+    abstract update<T>(tableName: string, id: string, object: {[key:string]:Primitive}): Promise<T>;
+
+    abstract page<T>(tableName: string, sortKey: string, maxResults: number, pageNumber: number, filters?: {[key:string]:Primitive|Array<Primitive>}): Promise<Pagination<T>>;
+
+    abstract count(tableName: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<number>;
+
+    abstract select(tableName: string, select: string, filters?: { [key: string]: Primitive | Array<Primitive> }): Promise<string[]>;
+
+    abstract del<T>(tableName: string, id: string): Promise<T>;
+}

package/src/main/node/repository/{RepositoryPostgres.ts → RepositoryDatabasePostgres.ts}

@@ -1,83 +1,42 @@
 import pg, {ClientConfig, QueryResult, QueryResultRow} from "pg";
 import PostgresUtils from "./utils/PostgresUtils";
-
-export interface QueryOptions {
-    schema?: string;
-    filters?: string;
-}
-
-export interface Chain extends ClientConfig {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    database: string;
-    schema: string;
-}
+import RepositoryDatabase, {Chain, Pagination, Primitive, QueryOptions} from "./RepositoryDatabase";
 
 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
+export default class RepositoryDatabasePostgres extends RepositoryDatabase
 {
-    protected chain!: Chain;
+    private readonly introspectIntervalTime: number = 60 * 60 * 1000;
 
     protected client!: pg.Client;
 
-    private connected: boolean = false;
-
     private tables: { [key: string]: Column[] } = {};
 
-    private onConnectListeners: (()=>void)[] = [];
-
-    private onQueryWillExecuteListeners: ((key:string)=>void)[] = [];
-
-    private onQueryDidExecuteListeners: ((key:string)=>void)[] = [];
-
-    private onIntrospectedListener: ((tables: { [p: string]: Column[] })=>void)[] = [];
-
-    private introspectIntervalTime = 5 * 60 * 1000
-
     private schema: string = "public";
 
-    constructor()
-    {
-        this.query = this.query.bind(this)
-        this.one = this.one.bind(this)
-        this.add = this.add.bind(this)
-        this.update = this.update.bind(this)
-        this.del = this.del.bind(this)
-        this.introspect = this.introspect.bind(this)
+    constructor() {
+        super();
+        this.native = this.native.bind(this);
     }
 
     init(chain: Chain)
     {
-        this.chain = chain;
+        super.init(chain);
         this.schema = chain.schema || "public";
         this.connect(chain);
     }
 
-    isConnected() {
-        return this.connected;
+    private onIntrospectedListeners: ((tables: {[key: string]:Column[]})=>void)[] = [];
+    addOnIntrospectedListener(listener: (tables: {[key: string]:Column[]})=>void): void {
+        this.onIntrospectedListeners.push(listener);
     }
 
-    addOnConnect(listener: () => void) { this.onConnectListeners.push(listener); }
-    addOnQueryWillExecuteListener(listener: (query: string) => void) { this.onQueryWillExecuteListeners.push(listener); }
-    setIntrospectInterval(time: number) { this.introspectIntervalTime = time; }
-    addOnIntrospected(listener: (tables: { [p: string]: Column[] })=>void) { this.onIntrospectedListener.push(listener); }
-
-    connect(connection: Chain) {
+    async connect(connection: Chain): Promise<void> {
         this.client = new pg.Client(connection);
-        this.client.connect().then(async () => {
+        return this.client.connect().then(async () => {
             await this.introspect();
             setInterval(this.introspect, this.introspectIntervalTime);
             this.connected = true;
@@ -155,7 +114,7 @@ export default abstract class RepositoryPostgres
         return this.query(query, values);
     }
 
-    async update(tableName: string, id: string, object: {[key:string]:Primitive})
+    async update<T>(tableName: string, id: string, object: {[key:string]:Primitive}): Promise<T>
     {
         if (!id) throw new Error(`field 'id' is mandatory when updating ${tableName}`);
         if (!this.tables[tableName]) throw new Error(`table ${tableName} does not exist`);
@@ -167,7 +126,7 @@ export default abstract class RepositoryPostgres
         let query = `UPDATE ${this.schema}.${tableName} SET (${columns.join(",")}) = (${params}) WHERE id = $1 `
         query += `RETURNING *`;
 
-        return this.query(query, values);
+        return this.query<T>(query, values).then((result) => result[0]);
     }
 
     async page<T>(tableName: string, sortKey: string, maxResults: number = 50, pageNumber: number = 0, filters?: {[key:string]:Primitive|Array<Primitive>}): Promise<Pagination<T>>
@@ -203,7 +162,7 @@ export default abstract class RepositoryPostgres
         return this.query<{list:string[]}>(query, values).then((result) => result[0].list);
     }
 
-    async del(tableName: string, id: string)
+    async del<T>(tableName: string, id: string): Promise<T>
     {
         throw new Error(`not implemented yet`);
     }
@@ -239,7 +198,7 @@ export default abstract class RepositoryPostgres
         for (let table of result.rows)
             this.tables[table["name"]] = table["columns"];
 
-        this.onIntrospectedListener.forEach((l) => l(this.tables));
+        this.onIntrospectedListeners.forEach((l) => l(this.tables));
 
     }
 

package/src/main/node/repository/utils/PostgresUtils.ts

@@ -1,4 +1,5 @@
-import {Column, Primitive} from "../RepositoryPostgres";
+import {Column} from "../RepositoryDatabasePostgres";
+import {Primitive} from "../RepositoryDatabase";
 
 export default abstract class PostgresUtils
 {