ismx-nexo-node-app 0.4.83 → 0.4.85

package/dist/js/business/BusinessServer.js

@@ -154,16 +154,19 @@ class BusinessServer extends Business_1.default {
             }
         });
     }
-    load(path) {
+    load(parent, path) {
         return __awaiter(this, void 0, void 0, function* () {
             const { readdir } = yield Promise.resolve().then(() => __importStar(require('fs/promises')));
             const pathModule = yield Promise.resolve().then(() => __importStar(require('path')));
             const { fileURLToPath } = yield Promise.resolve().then(() => __importStar(require('url')));
-            const files = yield readdir(path);
+            // @ts-ignore
+            const __dirname = pathModule.dirname(fileURLToPath(parent));
+            const servicesPath = pathModule.join(__dirname, path);
+            const files = yield readdir(servicesPath);
             for (const file of files) {
                 if (!file.endsWith('.ts') && !file.endsWith('.js'))
                     continue;
-                const modulePath = pathModule.join(path, file);
+                const modulePath = pathModule.join(servicesPath, file);
                 const mod = yield Promise.resolve(`${modulePath}`).then(s => __importStar(require(s)));
                 const ServiceClass = Object.values(mod)[0];
                 // @ts-ignore

package/dist/js/business/FormalLoopbackBusiness.js

@@ -0,0 +1,92 @@
+"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 LoopbackBusiness_1 = __importDefault(require("./LoopbackBusiness"));
+class FormalLoopbackBusiness extends LoopbackBusiness_1.default {
+    constructor() {
+        super();
+    }
+    get(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/', request);
+        });
+    }
+    list(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/list', request);
+        });
+    }
+    select(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/select', request);
+        });
+    }
+    count(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/count', request);
+        });
+    }
+    keymap(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/keymap', request);
+        });
+    }
+    map(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/map', request);
+        });
+    }
+    exist(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/exist', request);
+        });
+    }
+    post(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'POST', '/', request);
+        });
+    }
+    put(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'PUT', '/', request);
+        });
+    }
+    del(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'DELETE', '/', request);
+        });
+    }
+    call(tag_1, method_1, endpoint_1) {
+        const _super = Object.create(null, {
+            loopback: { get: () => super.loopback }
+        });
+        return __awaiter(this, arguments, void 0, function* (tag, method, endpoint, request = {}) {
+            return this.deformalize(() => _super.loopback.call(this, method, `${tag}/${endpoint}`, request));
+        });
+    }
+    deformalize(call) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield call();
+            if (result.ok) {
+                let wrapper = yield result.json();
+                return wrapper.data;
+            }
+            else {
+                const errorBody = yield result.json();
+                throw new Error(JSON.stringify(errorBody));
+            }
+        });
+    }
+}
+exports.default = FormalLoopbackBusiness;

package/dist/js/business/FormalProxyBusiness.js

@@ -0,0 +1,92 @@
+"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 ProxyBusiness_1 = __importDefault(require("./ProxyBusiness"));
+class FormalProxyBusiness extends ProxyBusiness_1.default {
+    constructor() {
+        super();
+    }
+    get(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/', request);
+        });
+    }
+    list(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/list', request);
+        });
+    }
+    select(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/select', request);
+        });
+    }
+    count(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/count', request);
+        });
+    }
+    keymap(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/keymap', request);
+        });
+    }
+    map(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/map', request);
+        });
+    }
+    exist(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'GET', '/exist', request);
+        });
+    }
+    post(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'POST', '/', request);
+        });
+    }
+    put(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'PUT', '/', request);
+        });
+    }
+    del(tag_1) {
+        return __awaiter(this, arguments, void 0, function* (tag, request = {}) {
+            return this.call(tag, 'DELETE', '/', request);
+        });
+    }
+    call(tag_1, method_1, endpoint_1) {
+        const _super = Object.create(null, {
+            call: { get: () => super.call }
+        });
+        return __awaiter(this, arguments, void 0, function* (tag, method, endpoint, request = {}) {
+            return this.deformalize(() => _super.call.call(this, tag, method, endpoint, request));
+        });
+    }
+    deformalize(call) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield call();
+            if (result.ok) {
+                let wrapper = yield result.json();
+                return wrapper.data;
+            }
+            else {
+                const errorBody = yield result.json();
+                throw new Error(JSON.stringify(errorBody));
+            }
+        });
+    }
+}
+exports.default = FormalProxyBusiness;

package/dist/js/business/LoopbackBusiness.js

@@ -0,0 +1,44 @@
+"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 ProxyBusiness_1 = __importDefault(require("./ProxyBusiness"));
+class LoopbackBusiness extends ProxyBusiness_1.default {
+    constructor(loopback = "http://localhost") {
+        super();
+        this.modules = {
+            loopback: {
+                id: "loopback",
+                tag: "loopback",
+                host: loopback,
+            }
+        };
+    }
+    call(tag, method, endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.loopback(method, endpoint, request);
+        });
+    }
+    loopback(method, endpoint, request) {
+        const _super = Object.create(null, {
+            call: { get: () => super.call }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.call.call(this, "loopback", endpoint, method, request);
+        });
+    }
+    setModules(modules) {
+        throw new Error("Cannot set modules in loopback proxy");
+    }
+}
+exports.default = LoopbackBusiness;

package/dist/js/business/{BusinessProxy.js → ProxyBusiness.js}

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_fetch_1 = __importStar(require("node-fetch"));
 const QueryUtils_1 = __importDefault(require("../repository/utils/QueryUtils"));
-class BusinessProxy {
+class ProxyBusiness {
     constructor() {
         this.modules = {};
         this.onError = (error) => error;
@@ -67,8 +67,10 @@ class BusinessProxy {
                 body = JSON.stringify(request.body);
             }
             // Realiza la llamada a la API con las cabeceras y la URL base de la llamada.
-            return (0, node_fetch_1.default)(module.host + endpoint + QueryUtils_1.default.map(request.query), Object.assign(Object.assign({}, request), { method, body: method !== "GET" ? body : undefined, headers })).catch((error) => { throw this.onError(error); });
+            return (0, node_fetch_1.default)(module.host + endpoint + QueryUtils_1.default.map(request.query), Object.assign(Object.assign({}, request), { method, body: method !== "GET" ? body : undefined, headers })).catch((error) => {
+                throw this.onError(error);
+            });
         });
     }
 }
-exports.default = BusinessProxy;
+exports.default = ProxyBusiness;

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.RestUtils = exports.QueryUtils = exports.RepositoryRestFormalTemplate = exports.RepositoryRestFormal = exports.RepositoryRest = exports.RepositoryDatabasePostgres = exports.RepositoryDatabase = exports.Repository = exports.ArrayUtils = exports.StringUtils = exports.NumberUtils = exports.CryptoUtils = exports.DateUtils = exports.BusinessLogger = exports.FormalError = exports.BusinessErrors = exports.BusinessThreadState = exports.BusinessThread = exports.BusinessServer = exports.BusinessProxy = exports.BusinessState = exports.Business = exports.ColorUtils = exports.ServiceRestFormalTemplate = exports.ServiceRestFormal = exports.ServiceRest = exports.HttpResponse = exports.Service = void 0;
+exports.RestUtils = exports.QueryUtils = exports.RepositoryRestFormalTemplate = exports.RepositoryRestFormal = exports.RepositoryRest = exports.RepositoryDatabasePostgres = exports.RepositoryDatabase = exports.Repository = exports.ArrayUtils = exports.StringUtils = exports.NumberUtils = exports.CryptoUtils = exports.DateUtils = exports.BusinessLogger = exports.FormalError = exports.BusinessErrors = exports.BusinessThreadState = exports.BusinessThread = exports.BusinessServer = exports.FormalProxyBusiness = exports.ProxyBusiness = exports.BusinessState = exports.Business = exports.ColorUtils = 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 {
 }
@@ -59,10 +59,14 @@ const BusinessState_1 = __importDefault(require("./business/BusinessState"));
 class BusinessState extends BusinessState_1.default {
 }
 exports.BusinessState = BusinessState;
-const BusinessProxy_1 = __importDefault(require("./business/BusinessProxy"));
-class BusinessProxy extends BusinessProxy_1.default {
+const ProxyBusiness_1 = __importDefault(require("./business/ProxyBusiness"));
+class ProxyBusiness extends ProxyBusiness_1.default {
 }
-exports.BusinessProxy = BusinessProxy;
+exports.ProxyBusiness = ProxyBusiness;
+const FormalProxyBusiness_1 = __importDefault(require("./business/FormalProxyBusiness"));
+class FormalProxyBusiness extends FormalProxyBusiness_1.default {
+}
+exports.FormalProxyBusiness = FormalProxyBusiness;
 const BusinessServer_1 = __importDefault(require("./business/BusinessServer"));
 class BusinessServer extends BusinessServer_1.default {
 }

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

@@ -20,5 +20,5 @@ export default class BusinessServer extends Business {
     setOnEnd(listener: (request: HttpRequest, response: HttpResponse) => any): void;
     private publish;
     private run;
-    load(path: string): Promise<void>;
+    load(parent: string, path: string): Promise<void>;
 }

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

@@ -0,0 +1,21 @@
+import { HttpRequest } from "../api/Service";
+import LoopbackBusiness from "./LoopbackBusiness";
+export default class FormalLoopbackBusiness extends LoopbackBusiness {
+    constructor();
+    get<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    list<Res>(tag: string, request?: HttpRequest): Promise<Res[]>;
+    select(tag: string, request?: HttpRequest): Promise<string[]>;
+    count(tag: string, request?: HttpRequest): Promise<number>;
+    keymap(tag: string, request?: HttpRequest): Promise<{
+        [key: string]: string;
+    }>;
+    map<Res>(tag: string, request?: HttpRequest): Promise<{
+        [key: string]: Res;
+    }>;
+    exist(tag: string, request?: HttpRequest): Promise<boolean>;
+    post<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    put<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    del<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    call<Res>(tag: string, method: string, endpoint: string, request?: HttpRequest): Promise<Res>;
+    private deformalize;
+}

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

@@ -0,0 +1,21 @@
+import { HttpRequest } from "../api/Service";
+import ProxyBusiness from "./ProxyBusiness";
+export default class FormalProxyBusiness extends ProxyBusiness {
+    constructor();
+    get<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    list<Res>(tag: string, request?: HttpRequest): Promise<Res[]>;
+    select(tag: string, request?: HttpRequest): Promise<string[]>;
+    count(tag: string, request?: HttpRequest): Promise<number>;
+    keymap(tag: string, request?: HttpRequest): Promise<{
+        [key: string]: string;
+    }>;
+    map<Res>(tag: string, request?: HttpRequest): Promise<{
+        [key: string]: Res;
+    }>;
+    exist(tag: string, request?: HttpRequest): Promise<boolean>;
+    post<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    put<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    del<Res>(tag: string, request?: HttpRequest): Promise<Res>;
+    call<Res>(tag: string, method: string, endpoint: string, request?: HttpRequest): Promise<Res>;
+    private deformalize;
+}

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

@@ -0,0 +1,11 @@
+import { HttpRequest } from "../api/Service";
+import fetch from 'node-fetch';
+import ProxyBusiness, { Module } from "./ProxyBusiness";
+export default class LoopbackBusiness extends ProxyBusiness {
+    constructor(loopback?: string);
+    call<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<fetch.Response>;
+    loopback<Req, Res>(method: string, endpoint: string, request: HttpRequest<Req>): Promise<fetch.Response>;
+    setModules(modules: {
+        [p: string]: Module;
+    }): void;
+}

package/dist/types/business/{BusinessProxy.d.ts → ProxyBusiness.d.ts}

@@ -5,8 +5,10 @@ export interface Module {
     tag: string;
     host: string;
 }
-export default class BusinessProxy {
-    private modules;
+export default class ProxyBusiness {
+    protected modules: {
+        [key: string]: Module;
+    };
     private onError;
     setModules(modules: {
         [key: string]: Module;

package/dist/types/index.d.ts

@@ -26,19 +26,22 @@ export declare class Business extends BaseBusiness {
 import BaseBusinessState from "./business/BusinessState";
 export declare class BusinessState<M = any> extends BaseBusinessState<M> {
 }
-import BaseBusinessProxy, { Module as BaseModule } from "./business/BusinessProxy";
-export declare class BusinessProxy extends BaseBusinessProxy {
+import BaseProxyBusiness, { Module as BaseModule } from "./business/ProxyBusiness";
+export declare class ProxyBusiness extends BaseProxyBusiness {
 }
 export interface Module extends BaseModule {
 }
+import _FormalProxyBusiness from "./business/FormalProxyBusiness";
+export declare class FormalProxyBusiness extends _FormalProxyBusiness {
+}
 import _BusinessServer from "./business/BusinessServer";
 export declare class BusinessServer extends _BusinessServer {
 }
-import BaseBusinessThread from "./business/BusinessThread";
-export declare abstract class BusinessThread extends BaseBusinessThread {
+import _BusinessThread from "./business/BusinessThread";
+export declare abstract class BusinessThread extends _BusinessThread {
 }
-import BaseBusinessThreadState from "./business/BusinessThreadState";
-export declare abstract class BusinessThreadState<Model = any> extends BaseBusinessThreadState<Model> {
+import _BusinessThreadState from "./business/BusinessThreadState";
+export declare abstract class BusinessThreadState<Model = any> extends _BusinessThreadState<Model> {
 }
 import BaseBusinessErrors, { ErrorType as _ErrorType, FormalError as _FormalError } from "./business/BusinessErrors";
 export declare class BusinessErrors extends BaseBusinessErrors {

package/package.json

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

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

@@ -116,16 +116,20 @@ export default class BusinessServer extends Business
         }
     }}
 
-    public async load(path: string): Promise<void>
+    public async load(parent: string, path: string): Promise<void>
     {
         const { readdir } = await import('fs/promises');
         const pathModule = await import('path');
         const { fileURLToPath } = await import('url');
 
-        const files = await readdir(path);
+        // @ts-ignore
+        const __dirname = pathModule.dirname(fileURLToPath(parent));
+        const servicesPath = pathModule.join(__dirname, path);
+
+        const files = await readdir(servicesPath);
         for (const file of files) {
             if (!file.endsWith('.ts') && !file.endsWith('.js')) continue;
-            const modulePath = pathModule.join(path, file);
+            const modulePath = pathModule.join(servicesPath, file);
             const mod = await import(modulePath);
             const ServiceClass = Object.values(mod)[0];
             // @ts-ignore

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

@@ -0,0 +1,68 @@
+import {HttpRequest} from "../api/Service";
+import ProxyBusiness from "./ProxyBusiness";
+import {Wrapper} from "../api/ServiceRestFormal";
+import Business from "./Business";
+import fetch from "node-fetch";
+import LoopbackBusiness from "./LoopbackBusiness";
+
+export default class FormalLoopbackBusiness extends LoopbackBusiness {
+
+    constructor() {
+        super();
+    }
+
+    async get<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'GET', '/', request);
+    }
+
+    async list<Res>(tag: string, request: HttpRequest = {}): Promise<Res[]> {
+        return this.call<Res[]>(tag, 'GET', '/list', request);
+    }
+
+    async select(tag: string, request: HttpRequest = {}): Promise<string[]> {
+        return this.call<string[]>(tag, 'GET', '/select', request);
+    }
+
+    async count(tag: string, request: HttpRequest = {}): Promise<number> {
+        return this.call<number>(tag, 'GET', '/count', request);
+    }
+
+    async keymap(tag: string, request: HttpRequest = {}): Promise<{ [key:string]: string }> {
+        return this.call<{ [key:string]: string }>(tag, 'GET', '/keymap', request);
+    }
+
+    async map<Res>(tag: string, request: HttpRequest = {}): Promise<{ [key:string]: Res }> {
+        return this.call<{ [key:string]: Res }>(tag, 'GET', '/map', request);
+    }
+
+    async exist(tag: string, request: HttpRequest = {}): Promise<boolean> {
+        return this.call<boolean>(tag, 'GET', '/exist', request);
+    }
+
+    async post<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'POST', '/', request);
+    }
+
+    async put<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'PUT', '/', request);
+    }
+
+    async del<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'DELETE', '/', request);
+    }
+
+    async call<Res>(tag: string, method: string, endpoint: string, request: HttpRequest = {}): Promise<Res> {
+        return this.deformalize(() => super.loopback<any, Wrapper<Res>>(method, `${tag}/${endpoint}`, request));
+    }
+
+    private async deformalize<Res>(call: () => Promise<fetch.Response>): Promise<Res> {
+        let result = await call();
+        if (result.ok) {
+            let wrapper = await result.json() as Wrapper<Res>;
+            return wrapper.data;
+        } else {
+            const errorBody = await result.json();
+            throw new Error(JSON.stringify(errorBody));
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+import {HttpRequest} from "../api/Service";
+import ProxyBusiness from "./ProxyBusiness";
+import {Wrapper} from "../api/ServiceRestFormal";
+import Business from "./Business";
+import fetch from "node-fetch";
+
+export default class FormalProxyBusiness extends ProxyBusiness {
+
+    constructor() {
+        super();
+    }
+
+    async get<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'GET', '/', request);
+    }
+
+    async list<Res>(tag: string, request: HttpRequest = {}): Promise<Res[]> {
+        return this.call<Res[]>(tag, 'GET', '/list', request);
+    }
+
+    async select(tag: string, request: HttpRequest = {}): Promise<string[]> {
+        return this.call<string[]>(tag, 'GET', '/select', request);
+    }
+
+    async count(tag: string, request: HttpRequest = {}): Promise<number> {
+        return this.call<number>(tag, 'GET', '/count', request);
+    }
+
+    async keymap(tag: string, request: HttpRequest = {}): Promise<{ [key:string]: string }> {
+        return this.call<{ [key:string]: string }>(tag, 'GET', '/keymap', request);
+    }
+
+    async map<Res>(tag: string, request: HttpRequest = {}): Promise<{ [key:string]: Res }> {
+        return this.call<{ [key:string]: Res }>(tag, 'GET', '/map', request);
+    }
+
+    async exist(tag: string, request: HttpRequest = {}): Promise<boolean> {
+        return this.call<boolean>(tag, 'GET', '/exist', request);
+    }
+
+    async post<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'POST', '/', request);
+    }
+
+    async put<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'PUT', '/', request);
+    }
+
+    async del<Res>(tag: string, request: HttpRequest = {}): Promise<Res> {
+        return this.call<Res>(tag, 'DELETE', '/', request);
+    }
+
+    async call<Res>(tag: string, method: string, endpoint: string, request: HttpRequest = {}): Promise<Res> {
+        return this.deformalize(() => super.call<any, Wrapper<Res>>(tag, method, endpoint, request));
+    }
+
+    private async deformalize<Res>(call: () => Promise<fetch.Response>): Promise<Res> {
+        let result = await call();
+        if (result.ok) {
+            let wrapper = await result.json() as Wrapper<Res>;
+            return wrapper.data;
+        } else {
+            const errorBody = await result.json();
+            throw new Error(JSON.stringify(errorBody));
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+import { HttpResponse, HttpRequest } from "../api/Service"
+import fetch, {Body, Headers} from 'node-fetch';
+import QueryUtils from "../repository/utils/QueryUtils";
+import ProxyBusiness, {Module} from "./ProxyBusiness";
+import FormalProxyBusiness from "./FormalProxyBusiness";
+
+export default class LoopbackBusiness extends ProxyBusiness
+{
+    constructor(loopback = "http://localhost") {
+        super();
+        this.modules = {
+            loopback: {
+                id: "loopback",
+                tag: "loopback",
+                host: loopback,
+            }
+        };
+    }
+
+    async call<Req, Res>(tag: string, method: string, endpoint: string, request: HttpRequest<Req>): Promise<fetch.Response> {
+        return this.loopback(method, endpoint, request);
+    }
+
+    async loopback<Req, Res>(method: string, endpoint: string, request: HttpRequest<Req>): Promise<fetch.Response> {
+        return super.call<Req, Res>("loopback", endpoint, method, request);
+    }
+
+    setModules(modules: { [p: string]: Module }) {
+        throw new Error("Cannot set modules in loopback proxy");
+    }
+}

package/src/main/node/business/{BusinessProxy.ts → ProxyBusiness.ts}

@@ -1,7 +1,6 @@
 import { HttpResponse, HttpRequest } from "../api/Service"
 import fetch, {Body, Headers} from 'node-fetch';
 import QueryUtils from "../repository/utils/QueryUtils";
-import {json} from "express";
 
 export interface Module {
     id: string;
@@ -9,9 +8,9 @@ export interface Module {
     host: string;
 }
 
-export default class BusinessProxy
+export default class ProxyBusiness
 {
-    private modules: {[key:string]: Module} = {};
+    protected modules: {[key:string]: Module} = {};
     private onError: (error: Error) => Error = (error) => error;
 
     setModules(modules: {[key:string]: Module}) {
@@ -43,6 +42,8 @@ export default class BusinessProxy
         // Realiza la llamada a la API con las cabeceras y la URL base de la llamada.
         return fetch(module.host + endpoint + QueryUtils.map(request.query), {
             ...request, method, body: method !== "GET" ? body : undefined, headers
-        }).catch((error) => { throw this.onError(error) });
+        }).catch((error) => {
+            throw this.onError(error)
+        });
     }
 }

package/src/main/node/index.ts

@@ -24,18 +24,21 @@ export class Business extends BaseBusiness {}
 import BaseBusinessState from "./business/BusinessState";
 export class BusinessState<M=any> extends BaseBusinessState<M> {}
 
-import BaseBusinessProxy, { Module as BaseModule } from "./business/BusinessProxy";
-export class BusinessProxy extends BaseBusinessProxy {}
+import BaseProxyBusiness, { Module as BaseModule } from "./business/ProxyBusiness";
+export class ProxyBusiness extends BaseProxyBusiness {}
 export interface Module extends BaseModule {}
 
+import _FormalProxyBusiness from "./business/FormalProxyBusiness";
+export class FormalProxyBusiness extends _FormalProxyBusiness {}
+
 import _BusinessServer from "./business/BusinessServer";
 export class BusinessServer extends _BusinessServer {}
 
-import BaseBusinessThread from "./business/BusinessThread";
-export abstract class BusinessThread extends BaseBusinessThread {}
+import _BusinessThread from "./business/BusinessThread";
+export abstract class BusinessThread extends _BusinessThread {}
 
-import BaseBusinessThreadState from "./business/BusinessThreadState";
-export abstract class BusinessThreadState<Model=any> extends BaseBusinessThreadState<Model> {}
+import _BusinessThreadState from "./business/BusinessThreadState";
+export abstract class BusinessThreadState<Model=any> extends _BusinessThreadState<Model> {}
 
 import BaseBusinessErrors, { ErrorType as _ErrorType,  FormalError as _FormalError} from "./business/BusinessErrors";
 export class BusinessErrors extends BaseBusinessErrors {}