ismx-nexo-node-app 0.3.24

package/dist/js/business/utils/NumberUtils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NumberUtils {
+    static random(lower, upper) {
+        return Math.floor(Math.random() * (upper + 1 - lower)) + lower;
+    }
+}
+exports.default = NumberUtils;

package/dist/js/business/utils/StringUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class StringUtils {
+    static base64Decode(base64) {
+        return Buffer.from(base64, 'base64');
+    }
+    static base64Encode(buffer) {
+        return buffer.toString('base64');
+    }
+    static base64UrlDecode(base64) {
+        let base64String = base64.replace(/-/g, '+').replace(/_/g, '/');
+        const padding = base64String.length % 4;
+        if (padding === 2)
+            base64String += '==';
+        else if (padding === 3)
+            base64String += '=';
+        return StringUtils.base64Decode(base64String);
+    }
+}
+exports.default = StringUtils;

package/dist/js/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryPostgres = exports.Repository = 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;
+const ServiceRest_1 = __importDefault(require("./api/ServiceRest"));
+exports.ServiceRest = ServiceRest_1.default;
+const ServiceRestFormal_1 = __importDefault(require("./api/ServiceRestFormal"));
+exports.ServiceRestFormal = ServiceRestFormal_1.default;
+const ServiceRestFormalTemplate_1 = __importDefault(require("./api/ServiceRestFormalTemplate"));
+exports.ServiceRestFormalTemplate = ServiceRestFormalTemplate_1.default;
+const Business_1 = __importDefault(require("./business/Business"));
+exports.Business = Business_1.default;
+const BusinessState_1 = __importDefault(require("./business/BusinessState"));
+exports.BusinessState = BusinessState_1.default;
+const BusinessProxy_1 = __importDefault(require("./business/BusinessProxy"));
+exports.BusinessProxy = BusinessProxy_1.default;
+const BusinessServer_1 = __importDefault(require("./business/BusinessServer"));
+exports.BusinessServer = BusinessServer_1.default;
+const BusinessThread_1 = __importDefault(require("./business/BusinessThread"));
+exports.BusinessThread = BusinessThread_1.default;
+const BusinessErrors_1 = __importDefault(require("./business/BusinessErrors"));
+exports.BusinessErrors = BusinessErrors_1.default;
+const BusinessLogger_1 = __importDefault(require("./business/BusinessLogger"));
+exports.BusinessLogger = BusinessLogger_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;

package/dist/js/repository/Repository.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Repository {
+}
+exports.default = Repository;

package/dist/js/repository/RepositoryPostgres.js

@@ -0,0 +1,215 @@
+"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 pg_1 = __importDefault(require("pg"));
+const PostgresUtils_1 = __importDefault(require("./utils/PostgresUtils"));
+class RepositoryPostgres {
+    constructor() {
+        this.connected = false;
+        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);
+    }
+    init(chain) {
+        this.chain = chain;
+        this.schema = chain.schema || "public";
+        this.connect(chain);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    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());
+        }));
+    }
+    native(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, values = [], options = {}) {
+            this.onQueryWillExecuteListeners.forEach((l) => l(query));
+            let cursor = this.client.query(query, values);
+            this.onQueryDidExecuteListeners.forEach((l) => l(query));
+            return cursor;
+        });
+    }
+    query(query_1) {
+        return __awaiter(this, arguments, void 0, function* (query, values = [], options = {}) {
+            return yield this.native(query, values, options).then((result) => {
+                return PostgresUtils_1.default.snakeToCamel(result.rows);
+            });
+        });
+    }
+    one(tableName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.any(tableName, { id });
+        });
+    }
+    any(tableName, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.find(tableName, filters).then((rows) => rows[0]);
+        });
+    }
+    find(tableName, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let { where, values } = this.toQuery(tableName, filters);
+            let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where}`;
+            return this.query(query, values);
+        });
+    }
+    all_depr(tableName_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, options = {}) {
+            var _a, _b;
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let table = this.tables[tableName];
+            let schema = (_a = options.schema) !== null && _a !== void 0 ? _a : this.schema;
+            return this.query(`
+            SELECT * FROM ${schema}.${tableName} 
+            WHERE ${(_b = options.filters) !== null && _b !== void 0 ? _b : "TRUE"}
+        `);
+        });
+    }
+    add(tableName, object, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.addAll(tableName, [Object.assign({ id: id }, object)]).then((rows) => rows[0]);
+        });
+    }
+    addAll(tableName, objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let table = this.tables[tableName];
+            let columns = PostgresUtils_1.default.columns(table);
+            let query = `INSERT INTO ${this.schema}.${tableName} (${columns.join(",")}) VALUES `;
+            let values = [];
+            let index = 1;
+            for (let object of objects) {
+                let { bindings, values: valueList } = PostgresUtils_1.default.bindOrDefault(table, object, index);
+                index += valueList.length;
+                values.push(...valueList);
+                query += `(${bindings.join(",")}), `;
+            }
+            query = query.slice(0, -2);
+            query += ` RETURNING *`;
+            return this.query(query, values);
+        });
+    }
+    update(tableName, id, object) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!id)
+                throw new Error(`field 'id' is mandatory when updating ${tableName}`);
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let table = this.tables[tableName];
+            let columns = PostgresUtils_1.default.columns(table);
+            let params = columns.map((column, index) => `\$${index + 2}`).join(",");
+            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);
+        });
+    }
+    page(tableName_1, sortKey_1) {
+        return __awaiter(this, arguments, void 0, function* (tableName, sortKey, maxResults = 50, pageNumber = 0, filters) {
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let table = this.tables[tableName];
+            let columns = PostgresUtils_1.default.columns(table);
+            let offset = maxResults * pageNumber;
+            let { where, values } = this.toQuery(tableName, filters, "", 4);
+            let query = `SELECT * FROM ${this.schema}.${tableName} WHERE ${where} ORDER BY $1 LIMIT $2 OFFSET $3`;
+            let elements = this.query(query, [sortKey, maxResults, offset, ...values]);
+            let total = this.count(tableName, filters);
+            return Promise.all([total, elements]).then(([total, elements]) => ({ total, elements }));
+        });
+    }
+    count(tableName, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let { where, values } = this.toQuery(tableName, filters);
+            let query = `SELECT count(*) as count FROM ${this.schema}.${tableName} WHERE ${where}`;
+            return this.query(query, values).then((result) => result[0].count);
+        });
+    }
+    select(tableName, select, filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tables[tableName])
+                throw new Error(`table ${tableName} does not exist`);
+            let { where, values } = this.toQuery(tableName, filters);
+            let query = `SELECT json_agg(${select}) as list FROM ${this.schema}.${tableName} WHERE ${where}`;
+            return this.query(query, values).then((result) => result[0].list);
+        });
+    }
+    del(tableName, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(`not implemented yet`);
+        });
+    }
+    toQuery(tableName, filters, alias = "", index = 1) {
+        let table = this.tables[tableName];
+        let columns = PostgresUtils_1.default.columns(table);
+        let elements = Object.entries(filters !== null && filters !== void 0 ? filters : []);
+        let where = "TRUE";
+        let iter = index;
+        let values = [];
+        for (let [key, value] of elements) {
+            let colum = PostgresUtils_1.default.camelToSnake(key);
+            if (key !== "id" && !columns.includes(colum))
+                continue;
+            if (alias !== "")
+                alias += ".";
+            if (value instanceof Array)
+                where += ` AND ${alias}${colum} = ANY(\$${iter++})`;
+            else
+                where += ` AND ${alias}${colum}=\$${iter++}`;
+            values.push(value);
+        }
+        return { where, values };
+    }
+    introspect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield this.native(`
+            SELECT table_name as name,
+                   json_agg(json_build_object('name', column_name, 'default', column_default)) as columns
+            FROM information_schema.columns
+            WHERE (table_schema = $1 or table_schema = 'public')
+            GROUP BY table_name
+        `, [this.schema]);
+            for (let table of result.rows)
+                this.tables[table["name"]] = table["columns"];
+            this.onIntrospectedListener.forEach((l) => l(this.tables));
+        });
+    }
+}
+exports.default = RepositoryPostgres;

package/dist/js/repository/RepositoryRest.js

@@ -0,0 +1,55 @@
+"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 Repository_1 = __importDefault(require("./Repository"));
+const QueryUtils_1 = __importDefault(require("./utils/QueryUtils"));
+class RepositoryRest extends Repository_1.default {
+    constructor(baseUrl, options) {
+        super();
+        this.baseUrl = baseUrl;
+        this.interceptor = options === null || options === void 0 ? void 0 : options.interceptor;
+    }
+    setOnRequestListener(listener) {
+        this.onRequestListener = listener;
+    }
+    call() {
+        return __awaiter(this, arguments, void 0, function* (method = 'GET', endpoint = '/', request = {}) {
+            var _a;
+            // 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.
+            let headers = new Headers(request.headers);
+            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]);
+            // 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);
+            // 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 }));
+            // 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);
+                return response;
+            });
+        });
+    }
+}
+exports.default = RepositoryRest;

package/dist/js/repository/RepositoryRestFormal.js

@@ -0,0 +1,46 @@
+"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 RepositoryRest_1 = __importDefault(require("./RepositoryRest"));
+class RepositoryRestFormal extends RepositoryRest_1.default {
+    constructor(baseUrl, ...methods) {
+        super(baseUrl);
+    }
+    call() {
+        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 BusinessErrors_1.FormalError(json.code, json.description, call);
+                }
+            }))
+                .catch((error) => {
+                // @ts-ignore
+                if (error instanceof BusinessErrors_1.FormalError)
+                    throw error;
+                else { // @ts-ignore
+                    throw new BusinessErrors_1.FormalError("-1", "ConnectionError", undefined, error);
+                }
+            });
+        });
+    }
+}
+exports.default = RepositoryRestFormal;

package/dist/js/repository/utils/PostgresUtils.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PostgresUtils {
+    static stringToCamel(column) {
+        return column.toLowerCase().replace(/([-_][a-z])/g, group => group.toUpperCase().replace('-', '').replace('_', ''));
+    }
+    static camelToSnake(column) {
+        return column.replace(/([A-Z])/g, '_$1').toLowerCase();
+    }
+    static snakeToCamel(obj) {
+        if (Array.isArray(obj))
+            return obj.map(el => PostgresUtils.snakeToCamel(el));
+        else if (typeof obj === 'function' || obj !== Object(obj) || obj instanceof Date)
+            return obj;
+        else
+            return PostgresUtils.fromEntries(Object.entries(obj).map(([key, value]) => [
+                key.replace(/([-_][a-z])/gi, c => c.toUpperCase().replace(/[-_]/g, '')),
+                PostgresUtils.snakeToCamel(value),
+            ]));
+    }
+    static columns(table) {
+        return table.map((t) => t.name);
+    }
+    static bindOrDefault(table, object, startIndex) {
+        let index = startIndex;
+        let bindings = [];
+        let values = [];
+        table.forEach((colum) => {
+            let value = object[PostgresUtils.stringToCamel(colum.name)];
+            if (value !== undefined || colum.default === undefined) {
+                bindings.push(`\$${index++}`);
+                values.push(value);
+            }
+            else
+                bindings.push("DEFAULT");
+        });
+        return { bindings, values };
+    }
+    static valueOrDefault(columns, object) {
+        return columns.map((column) => {
+            return object[PostgresUtils.stringToCamel(column)];
+        });
+    }
+    static fromEntries(iterable) {
+        const result = {};
+        for (const [key, value] of iterable)
+            result[key] = value;
+        return result;
+    }
+}
+exports.default = PostgresUtils;

package/dist/js/repository/utils/QueryUtils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class QueryUtils {
+    static map(query = {}) {
+        if (!query || Object.entries(query).length === 0)
+            return "";
+        let queryString = "?";
+        for (const param in query)
+            queryString += `${param}=${query[param]}&`;
+        return queryString;
+    }
+}
+exports.default = QueryUtils;

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

@@ -0,0 +1,45 @@
+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 declare class HttpResponse<T = any> {
+    content?: T;
+    httpCode?: number;
+    headers?: {
+        [key: string]: string;
+    };
+    static ok<T = any>(content: T): HttpResponse<any>;
+    static ko<T = any>(httpCode: number, content: T | undefined): HttpResponse<any>;
+}
+export default abstract class Service<Req, Res> {
+    static readonly services: Service<any, any>[];
+    readonly method: string;
+    readonly endpoint: string;
+    protected constructor(method: string, endpoint?: string);
+    serve(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
+    static clone<R, S>(request: HttpRequest<R>, clone: {
+        params?: {
+            [key: string]: string;
+        };
+        query?: {
+            [key: string]: string;
+        };
+        body?: S;
+        headers?: {
+            [key: string]: string;
+        };
+    }): HttpRequest<S>;
+}

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

@@ -0,0 +1,6 @@
+import Service, { HttpRequest, HttpResponse } from "./Service";
+export default class ServiceRest<Req, Res> extends Service<Req, Res> {
+    constructor(method: string, endpoint?: string);
+    serve(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
+    serveRest(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
+}

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

@@ -0,0 +1,23 @@
+import { 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);
+    serveRest(request: HttpRequest<Req>): Promise<HttpResponse<Wrapper<Res>>>;
+    serveRestFormal(request: HttpRequest<Req>): Promise<HttpResponse<Res>>;
+    unwrap<Res>(request: Promise<HttpResponse<Wrapper<Res>>>): Promise<Res | undefined>;
+    fullSelect<Req, Res>(request: HttpRequest<Req>, api: {
+        select: ServiceRestFormal<Req, string[]>;
+        full: ServiceRestFormal<Req, Res>;
+    }): Promise<(Awaited<Res> | undefined)[]>;
+    static unwrap<Res>(request: Promise<HttpResponse<Wrapper<Res>>>): Promise<Res | undefined>;
+    static fullSelect<Req, Res>(request: HttpRequest<Req>, api: {
+        select: ServiceRestFormal<Req, string[]>;
+        full: ServiceRestFormal<Req, Res>;
+    }): Promise<(Awaited<Res> | undefined)[]>;
+}

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

@@ -0,0 +1,40 @@
+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> {
+    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);
+    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;
+    }>>;
+    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>>;
+    protected readonly unwrap: typeof ServiceRestFormal.unwrap;
+    protected readonly fullSelect: typeof ServiceRestFormal.fullSelect;
+}

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

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

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

@@ -0,0 +1,39 @@
+export interface FormalError {
+    id: string;
+    code: string;
+    description: string;
+    httpCode?: number;
+    group?: string;
+}
+export default class BusinessErrors {
+    private errors;
+    init(): Promise<void>;
+    setErrors(errors: {
+        [key: string]: FormalError;
+    }): void;
+    get(code: string, ...params: string[]): FormalError;
+    except(code: string, ...params: string[]): void;
+    notFound(endpoint: string): void;
+    getQuery(key: string, query: {
+        [key: string]: string;
+    } | undefined): string;
+    eitherQuery(keys: string[], query: {
+        [p: string]: string;
+    }): {
+        key: string;
+        value: string;
+        index: number;
+    };
+    getPath(key: string, path: {
+        [key: string]: string;
+    }): string;
+    getBody<T>(body?: T): T;
+    getHeaders(key: string, headers: {
+        [key: string]: string;
+    }): string;
+    isType<T>(key: string, value: string, type: string, assertion: (value: string) => T): T;
+    exists<T>(type: string, key: string, value: string, object?: T): T;
+    isRegex(key: string, value: string, regex: string): string;
+    isDate(key: string, value: string, format: string): Date;
+    getFallback(): FormalError;
+}

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

@@ -0,0 +1,3 @@
+export default class BusinessLogger {
+    i(message: string): void;
+}

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

@@ -0,0 +1,15 @@
+import { HttpRequest } from "../api/Service";
+export interface Module {
+    id: string;
+    tag: string;
+    host: string;
+}
+export default class BusinessProxy {
+    private modules;
+    setModules(modules: {
+        [key: string]: Module;
+    }): void;
+    callFormal<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<Res | undefined>;
+    call<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<Res>;
+    private map;
+}