ismx-nexo-node-app 0.3.44 → 0.3.45

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.RepositoryDatabasePostgres = exports.RepositoryDatabase = 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.RepositoryRestFormalTemplate = exports.RepositoryRestFormal = exports.RepositoryRest = exports.RepositoryDatabasePostgres = exports.RepositoryDatabase = 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"));
 class Service extends Service_1.default {
 }
@@ -92,6 +92,18 @@ const RepositoryDatabasePostgres_1 = __importDefault(require("./repository/Repos
 class RepositoryDatabasePostgres extends RepositoryDatabasePostgres_1.default {
 }
 exports.RepositoryDatabasePostgres = RepositoryDatabasePostgres;
+const RepositoryRest_1 = __importDefault(require("./repository/RepositoryRest"));
+class RepositoryRest extends RepositoryRest_1.default {
+}
+exports.RepositoryRest = RepositoryRest;
+const RepositoryRestFormal_1 = __importDefault(require("./repository/RepositoryRestFormal"));
+class RepositoryRestFormal extends RepositoryRestFormal_1.default {
+}
+exports.RepositoryRestFormal = RepositoryRestFormal;
+const RepositoryRestFormalTemplate_1 = __importDefault(require("./repository/RepositoryRestFormalTemplate"));
+class RepositoryRestFormalTemplate extends RepositoryRestFormalTemplate_1.default {
+}
+exports.RepositoryRestFormalTemplate = RepositoryRestFormalTemplate;
 const QueryUtils_1 = __importDefault(require("./repository/utils/QueryUtils"));
 class QueryUtils extends QueryUtils_1.default {
 }

package/dist/js/repository/RepositoryRest.js

@@ -15,17 +15,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Repository_1 = __importDefault(require("./Repository"));
 const QueryUtils_1 = __importDefault(require("./utils/QueryUtils"));
 class RepositoryRest extends Repository_1.default {
-    constructor(baseUrl, options) {
+    constructor(baseUrl, options = {}) {
         super();
         this.baseUrl = baseUrl;
-        this.interceptor = options === null || options === void 0 ? void 0 : options.interceptor;
-    }
-    setOnRequestListener(listener) {
-        this.onRequestListener = listener;
+        this.options = options;
     }
     call() {
         return __awaiter(this, arguments, void 0, function* (method = 'GET', endpoint = '/', request = {}) {
-            var _a;
+            var _a, _b, _c, _d, _e;
             // Especifica el método de la llamada HTTP al recurso.
             request.method = method;
             // Completa la información de las cabeceras con cabeceras comunes por llamada a API.
@@ -33,20 +30,23 @@ class RepositoryRest extends Repository_1.default {
             headers.set('Content-Type', 'application/json');
             headers.set('Cache-Control', 'no-cache');
             headers.set('Pragma', 'no-cache');
-            for (let header in request.headers)
-                headers.set(header, request.headers[header]);
+            for (const header of Object.keys(headers))
+                headers.set(header, (_b = (_a = request.headers) === null || _a === void 0 ? void 0 : _a[header]) !== null && _b !== void 0 ? _b : "");
             // Notifica que una petición REST va a ser realizada
-            (_a = this.onRequestListener) === null || _a === void 0 ? void 0 : _a.call(this, method, endpoint, request);
+            request = (_e = (_d = (_c = this.options).interceptor) === null || _d === void 0 ? void 0 : _d.call(_c, endpoint, request)) !== null && _e !== void 0 ? _e : request;
             // Realiza la llamada a la API con las cabeceras y la URL base de la llamada.
-            let timestamp = new Date();
-            let call = fetch(this.baseUrl + endpoint + QueryUtils_1.default.map(request.query), Object.assign(Object.assign({}, request), { headers }));
+            let call = fetch(this.baseUrl + endpoint + QueryUtils_1.default.map(request.query), Object.assign(Object.assign({}, request), { body: method === "GET" ? JSON.stringify(request.body) : undefined, headers }));
             // Añade información adicional a la respuesta y devuelve el resultado (o el error en su caso).
             return call.then((res) => {
-                var _a;
-                let response = res;
-                response.duration = new Date().valueOf() - timestamp.valueOf();
-                response.timestamp = timestamp;
-                (_a = this.interceptor) === null || _a === void 0 ? void 0 : _a.call(this, response);
+                var _a, _b;
+                let headers = {};
+                res.headers.forEach((value, key) => headers[key] = value);
+                let response = {
+                    httpCode: res.status,
+                    content: res.json(),
+                    headers
+                };
+                (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.onResponse) === null || _b === void 0 ? void 0 : _b.call(_a, response);
                 return response;
             });
         });

package/dist/js/repository/RepositoryRestFormal.js

@@ -14,31 +14,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const RepositoryRest_1 = __importDefault(require("./RepositoryRest"));
 class RepositoryRestFormal extends RepositoryRest_1.default {
-    constructor(baseUrl, ...methods) {
-        super(baseUrl);
+    constructor(baseUrl, options) {
+        super(baseUrl, options);
     }
-    call() {
+    callFormal() {
         const _super = Object.create(null, {
             call: { get: () => super.call }
         });
         return __awaiter(this, arguments, void 0, function* (method = 'GET', endpoint = '/', request = {}) {
-            request.body = JSON.stringify(request.body);
             return _super.call.call(this, method, endpoint, request)
-                .then((call) => __awaiter(this, void 0, void 0, function* () {
-                let json = yield call.json();
-                if (json.code === "0")
-                    return json.data;
-                else { // @ts-ignore
-                    throw new FormalError(json.code, json.description, call);
+                .then((response) => __awaiter(this, void 0, void 0, function* () {
+                let content = response.content;
+                if (content) {
+                    if (content.code === "0")
+                        return content.data;
+                    else
+                        throw { code: content.code, description: content.description };
                 }
+                else
+                    return {};
             }))
                 .catch((error) => {
-                // @ts-ignore
-                if (error instanceof FormalError)
-                    throw error;
-                else { // @ts-ignore
-                    throw new FormalError("-1", "ConnectionError", undefined, error);
-                }
+                throw { id: "-1", code: "-1", description: "ConnectionError", error };
             });
         });
     }

package/dist/js/repository/RepositoryRestFormalTemplate.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RepositoryRestFormal_1 = __importDefault(require("./RepositoryRestFormal"));
+class RepositoryRestFormalTemplate {
+    constructor(baseUrl, options) {
+        this.repository = new RepositoryRestFormal_1.default(baseUrl, options);
+    }
+    get(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, request = {}) {
+            request.query = Object.assign(Object.assign({}, request.query), { id });
+            return this.repository.callFormal("GET", "/", request);
+        });
+    }
+    getList() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/list", request))) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    post(body_1) {
+        return __awaiter(this, arguments, void 0, function* (body, request = {}) {
+            var _a;
+            request.body = body;
+            return (_a = (yield this.repository.callFormal("POST", "/", request))) !== null && _a !== void 0 ? _a : body;
+        });
+    }
+    postList(body_1) {
+        return __awaiter(this, arguments, void 0, function* (body, request = {}) {
+            var _a;
+            request.body = body;
+            return (_a = (yield this.repository.callFormal("POST", "/list", request))) !== null && _a !== void 0 ? _a : body;
+        });
+    }
+    full(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, request = {}) {
+            request.query = Object.assign(Object.assign({}, request.query), { id });
+            return this.repository.callFormal("GET", "/full", request);
+        });
+    }
+    fullList() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/full/list", request))) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    put(id_1, body_1) {
+        return __awaiter(this, arguments, void 0, function* (id, body, request = {}) {
+            var _a;
+            request.query = Object.assign(Object.assign({}, request.query), { id });
+            request.body = body;
+            return (_a = (yield this.repository.callFormal("PUT", "/", request))) !== null && _a !== void 0 ? _a : body;
+        });
+    }
+    del(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, request = {}) {
+            request.query = Object.assign(Object.assign({}, request.query), { id });
+            return this.repository.callFormal("DELETE", "/", request);
+        });
+    }
+    delete() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            return this.repository.callFormal('DELETE', "/", request);
+        });
+    }
+    select() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/select", request))) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    exist() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/exist", request))) !== null && _a !== void 0 ? _a : false;
+        });
+    }
+    count() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/count", request))) !== null && _a !== void 0 ? _a : 0;
+        });
+    }
+    page(results_1, page_1) {
+        return __awaiter(this, arguments, void 0, function* (results, page, request = {}) {
+            var _a, _b;
+            (_a = request.query) !== null && _a !== void 0 ? _a : (request.query = {});
+            request.query["maxResults"] = results.toString();
+            request.query["pageNumber"] = page.toString();
+            return (_b = (yield this.repository.callFormal("GET", "/page", request))) !== null && _b !== void 0 ? _b : { elements: [], total: 0 };
+        });
+    }
+    map() {
+        return __awaiter(this, arguments, void 0, function* (request = {}) {
+            var _a;
+            return (_a = (yield this.repository.callFormal("GET", "/map", request))) !== null && _a !== void 0 ? _a : {};
+        });
+    }
+    call(method, endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.repository.callFormal(method, endpoint, request);
+        });
+    }
+}
+exports.default = RepositoryRestFormalTemplate;

package/dist/types/index.d.ts

@@ -57,6 +57,15 @@ export declare abstract class RepositoryDatabase extends _RepositoryDatabase {
 import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres";
 export declare class RepositoryDatabasePostgres extends _RepositoryDatabasePostgres {
 }
+import _RepositoryRest from "./repository/RepositoryRest";
+export declare class RepositoryRest<B = any, R = any> extends _RepositoryRest<B, R> {
+}
+import _RepositoryRestFormal from "./repository/RepositoryRestFormal";
+export declare class RepositoryRestFormal<B = any, R = any> extends _RepositoryRestFormal<B, R> {
+}
+import _RepositoryRestFormalTemplate from "./repository/RepositoryRestFormalTemplate";
+export declare class RepositoryRestFormalTemplate<M = any> extends _RepositoryRestFormalTemplate<M> {
+}
 import _QueryUtils from "./repository/utils/QueryUtils";
 export declare abstract class QueryUtils extends _QueryUtils {
 }

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

@@ -1,17 +1,12 @@
-import Repository from './Repository';
-import { HttpRequest } from "../api/Service";
-export interface RestResponse<E = any> extends Response {
-    timestamp?: Date;
-    duration?: number;
-}
+import Repository from "./Repository";
+import { HttpRequest, HttpResponse } from "../api/Service";
 export interface RestOptions {
-    interceptor: (response: RestResponse) => void;
+    interceptor?: (endpoint: string, request: HttpRequest) => HttpRequest | undefined;
+    onResponse?: (response: HttpResponse) => void;
 }
-export default class RepositoryRest<S = any> extends Repository {
+export default class RepositoryRest<Body = any, Res = any> extends Repository {
     private readonly baseUrl;
-    private readonly interceptor?;
-    private onRequestListener?;
+    private readonly options;
     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>>;
+    call<B = Body, E = Res>(method?: string, endpoint?: string, request?: HttpRequest<B>): Promise<HttpResponse<E>>;
 }

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

@@ -1,7 +1,7 @@
-import RepositoryRest from "./RepositoryRest";
+import RepositoryRest, { RestOptions } 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>;
+export default class RepositoryRestFormal<Body = any, S = any> extends RepositoryRest<Body, Wrapper<S>> {
+    constructor(baseUrl: string, options?: RestOptions);
+    callFormal<B = Body, E = S>(method?: string, endpoint?: string, request?: HttpRequest<B>): Promise<E | undefined>;
 }

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

@@ -0,0 +1,24 @@
+import { RestOptions } from "./RepositoryRest";
+import { HttpRequest } from "../api/Service";
+import { Pagination } from "./RepositoryDatabase";
+export default class RepositoryRestFormalTemplate<Model> {
+    private readonly repository;
+    constructor(baseUrl: string, options?: RestOptions);
+    get(id: string, request?: HttpRequest): Promise<Model | undefined>;
+    getList(request?: HttpRequest): Promise<Model[]>;
+    post(body: Model, request?: HttpRequest): Promise<Model>;
+    postList(body: Model[], request?: HttpRequest): Promise<Model[]>;
+    full(id: string, request?: HttpRequest): Promise<Model | undefined>;
+    fullList(request?: HttpRequest): Promise<Model[]>;
+    put(id: string, body: Model, request?: HttpRequest): Promise<Model>;
+    del(id: string, request?: HttpRequest): Promise<Model | undefined>;
+    delete(request?: HttpRequest): Promise<any>;
+    select(request?: HttpRequest): Promise<string[]>;
+    exist(request?: HttpRequest): Promise<boolean>;
+    count(request?: HttpRequest): Promise<number>;
+    page(results: number, page: number, request?: HttpRequest): Promise<Pagination<Model>>;
+    map(request?: HttpRequest): Promise<{
+        [key: string]: Model;
+    }>;
+    call<B, E>(method: string, endpoint: string, request: HttpRequest<B>): Promise<E | undefined>;
+}

package/package.json

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

package/src/main/node/index.ts

@@ -58,5 +58,14 @@ export abstract class RepositoryDatabase extends _RepositoryDatabase {}
 import _RepositoryDatabasePostgres from "./repository/RepositoryDatabasePostgres";
 export class RepositoryDatabasePostgres extends _RepositoryDatabasePostgres {}
 
+import _RepositoryRest from "./repository/RepositoryRest";
+export class RepositoryRest<B=any,R=any> extends _RepositoryRest<B,R> {}
+
+import _RepositoryRestFormal from "./repository/RepositoryRestFormal";
+export class RepositoryRestFormal<B=any,R=any> extends _RepositoryRestFormal<B,R> {}
+
+import _RepositoryRestFormalTemplate from "./repository/RepositoryRestFormalTemplate";
+export class RepositoryRestFormalTemplate<M=any> extends _RepositoryRestFormalTemplate<M> {}
+
 import _QueryUtils from "./repository/utils/QueryUtils";
 export abstract class QueryUtils extends _QueryUtils {}

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

@@ -1,39 +1,29 @@
-import Repository from './Repository';
+import Repository from "./Repository";
 import {HttpRequest, HttpResponse} from "../api/Service";
 import QueryUtils from "./utils/QueryUtils";
 
-export interface RestResponse<E=any> extends Response {
-  timestamp?: Date;
-  duration?: number;
-}
-
 export interface RestOptions {
-  interceptor: (response: RestResponse) => void;
+  interceptor?: (endpoint: string, request: HttpRequest) => HttpRequest | undefined
+  onResponse?: (response: HttpResponse) => void;
 }
 
-export default class RepositoryRest<S=any> extends Repository
+export default class RepositoryRest<Body=any,Res=any> extends Repository
 {
   private readonly baseUrl: string;
 
-  private readonly interceptor?: (response: RestResponse) => void;
-
-  private onRequestListener?: (method: string, endpoint: string, request: HttpRequest)=>void;
+  private readonly options: RestOptions
 
-  constructor(baseUrl: string, options?: RestOptions) {
+  constructor(baseUrl: string, options: RestOptions={}) {
     super();
     this.baseUrl = baseUrl;
-    this.interceptor = options?.interceptor;
-  }
-
-  setOnRequestListener(listener: (method: string, endpoint: string, request: HttpRequest)=>void) {
-    this.onRequestListener = listener;
+    this.options = options;
   }
 
-  async call<E = S>(
+  async call<B=Body, E = Res>(
     method: string = 'GET',
     endpoint: string = '/',
-    request: HttpRequest = {},
-  ): Promise<RestResponse<E>>
+    request: HttpRequest<B> = {},
+  ): Promise<HttpResponse<E>>
   {
     // Especifica el método de la llamada HTTP al recurso.
     request.method = method;
@@ -43,25 +33,28 @@ export default class RepositoryRest<S=any> extends Repository
     headers.set('Content-Type', 'application/json');
     headers.set('Cache-Control', 'no-cache');
     headers.set('Pragma', 'no-cache');
-    for (let header in request.headers)
-      headers.set(header, request.headers[header]);
+    for (const header of Object.keys(headers))
+      headers.set(header, request.headers?.[header] ?? "")
 
     // Notifica que una petición REST va a ser realizada
-    this.onRequestListener?.(method, endpoint, request);
+    request = this.options.interceptor?.(endpoint, request) ?? request
 
     // Realiza la llamada a la API con las cabeceras y la URL base de la llamada.
-    let timestamp = new Date();
     let call = fetch(this.baseUrl + endpoint + QueryUtils.map(request.query), {
       ...request,
-      headers
+        body: method === "GET" ? JSON.stringify(request.body) : undefined,
+        headers
     });
 
     // Añade información adicional a la respuesta y devuelve el resultado (o el error en su caso).
     return call.then((res: Response) => {
-      let response: RestResponse<E> = res;
-      response.duration = new Date().valueOf() - timestamp.valueOf()
-      response.timestamp = timestamp;
-      this.interceptor?.(response);
+      let headers: any = {}; res.headers.forEach((value, key) => headers[key] = value);
+      let response: HttpResponse<E> = {
+        httpCode: res.status,
+        content: res.json() as E,
+        headers
+      };
+      this.options?.onResponse?.(response);
       return response;
     });
   }

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

@@ -1,36 +1,30 @@
-import RepositoryRest from "./RepositoryRest";
+import RepositoryRest, {RestOptions} from "./RepositoryRest";
 import {Wrapper} from "../api/ServiceRestFormal";
 import {HttpRequest} from "../api/Service";
+import { FormalError} from "../business/BusinessErrors";
 
-export default class RepositoryRestFormal<S=any> extends RepositoryRest<Wrapper<S>> {
+export default class RepositoryRestFormal<Body=any, S=any> extends RepositoryRest<Body, Wrapper<S>> {
 
-	constructor(baseUrl: string, ...methods: RepositoryRest[]) {
-		super(baseUrl);
+	constructor(baseUrl: string, options?: RestOptions) {
+		super(baseUrl, options);
 	}
 
-	async call<E = S>(
+	async callFormal<B = Body, E = S>(
 		method: string = 'GET',
 		endpoint: string = '/',
-		request: HttpRequest = {},
-	): Promise<E> {
-
-		request.body = JSON.stringify(request.body);
-
-		return super.call<E>(method, endpoint, request)
-			.then(async (call) => {
-				let json = await call.json();
-				if (json.code === "0") return json.data;
-				else { // @ts-ignore
-					throw new FormalError(json.code, json.description, call);
-				}
+		request: HttpRequest<B> = {},
+	): Promise<E | undefined> {
 
+		return super.call<B, Wrapper<E>>(method, endpoint, request)
+			.then(async (response) => {
+				let content = response.content;
+				if (content) {
+					if (content.code === "0") return content.data;
+					else throw { code: content.code, description: content.description } as FormalError;
+				} else return {} as E;
 			})
-			.catch((error: any) => {
-				// @ts-ignore
-				if (error instanceof FormalError) throw error;
-				else { // @ts-ignore
-					throw new FormalError("-1", "ConnectionError", undefined, error)
-				}
+			.catch((error) => {
+				throw { id: "-1", code: "-1", description: "ConnectionError", error } as FormalError
 			});
 	}
 }

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

@@ -0,0 +1,84 @@
+import {RestOptions} from "./RepositoryRest";
+import RepositoryRestFormal from "./RepositoryRestFormal";
+import {HttpRequest} from "../api/Service";
+import {Pagination} from "./RepositoryDatabase";
+
+export default class RepositoryRestFormalTemplate<Model> {
+
+	private readonly repository: RepositoryRestFormal;
+
+	constructor(baseUrl: string, options?: RestOptions) {
+		this.repository = new RepositoryRestFormal(baseUrl, options);
+	}
+
+	async get(id: string, request: HttpRequest = {}): Promise<Model | undefined> {
+		request.query = { ...request.query, id }
+		return this.repository.callFormal<any, Model>("GET", "/", request);
+	}
+
+	async getList(request: HttpRequest = {}): Promise<Model[]> {
+		return (await this.repository.callFormal("GET", "/list", request)) ?? [];
+	}
+
+	async post(body: Model, request: HttpRequest = {}): Promise<Model> {
+		request.body = body
+		return (await this.repository.callFormal("POST", "/", request)) ?? body;
+	}
+
+	async postList(body: Model[], request: HttpRequest = {}): Promise<Model[]> {
+		request.body = body;
+		return (await this.repository.callFormal("POST", "/list", request)) ?? body;
+	}
+
+	async full(id: string, request: HttpRequest = {}): Promise<Model | undefined> {
+		request.query = { ...request.query, id }
+		return this.repository.callFormal("GET", "/full", request);
+	}
+
+	async fullList(request: HttpRequest = {}): Promise<Model[]> {
+		return (await this.repository.callFormal("GET", "/full/list", request)) ?? [];
+	}
+
+	async put(id: string, body: Model, request: HttpRequest = {}): Promise<Model> {
+		request.query = { ...request.query, id };
+		request.body = body;
+		return (await this.repository.callFormal("PUT", "/", request)) ?? body;
+	}
+
+
+	async del(id: string, request: HttpRequest = {}): Promise<Model | undefined> {
+		request.query = { ...request.query, id };
+		return this.repository.callFormal("DELETE", "/", request);
+	}
+
+	async delete(request: HttpRequest = {}) {
+		return this.repository.callFormal('DELETE', "/", request);
+	}
+
+	async select(request: HttpRequest={}): Promise<string[]> {
+		return (await this.repository.callFormal("GET", "/select", request)) ?? [];
+	}
+
+	async exist(request: HttpRequest={}): Promise<boolean> {
+		return (await this.repository.callFormal("GET", "/exist", request)) ?? false;
+	}
+
+	async count(request: HttpRequest={}): Promise<number> {
+		return (await this.repository.callFormal("GET", "/count", request)) ?? 0;
+	}
+
+	async page(results: number, page: number, request: HttpRequest={}): Promise<Pagination<Model>> {
+		request.query ??= {};
+		request.query["maxResults"] = results.toString();
+		request.query["pageNumber"] = page.toString();
+		return (await this.repository.callFormal("GET", "/page", request)) ?? { elements: [], total: 0};
+	}
+
+	async map(request: HttpRequest={}): Promise<{ [key: string]: Model }> {
+		return (await this.repository.callFormal("GET", "/map", request)) ?? {};
+	}
+
+	async call<B, E>(method: string, endpoint: string, request: HttpRequest<B>): Promise<E | undefined> {
+		return this.repository.callFormal<B, E>(method, endpoint, request);
+	}
+}