ismx-nexo-node-app 0.3.24

package/dist/js/api/Service.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponse = void 0;
+class HttpResponse {
+    static ok(content) {
+        let response = new HttpResponse();
+        response.content = content;
+        response.httpCode = 200;
+        return response;
+    }
+    static ko(httpCode, content) {
+        let response = new HttpResponse();
+        response.content = content;
+        response.httpCode = httpCode;
+        return response;
+    }
+}
+exports.HttpResponse = HttpResponse;
+class Service {
+    constructor(method, endpoint = "/") {
+        this.method = method;
+        this.endpoint = endpoint;
+        Service.services.push(this);
+    }
+    serve(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return HttpResponse.ok({});
+        });
+    }
+    static clone(request, clone) {
+        var _a, _b, _c;
+        return { id: request.id, url: request.url, method: request.method, timestamp: request.timestamp, params: (_a = clone.params) !== null && _a !== void 0 ? _a : {}, query: (_b = clone.query) !== null && _b !== void 0 ? _b : {}, body: clone.body, headers: (_c = clone.headers) !== null && _c !== void 0 ? _c : {} };
+    }
+}
+Service.services = [];
+exports.default = Service;

package/dist/js/api/ServiceRest.js

@@ -0,0 +1,33 @@
+"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 Service_1 = __importDefault(require("./Service"));
+class ServiceRest extends Service_1.default {
+    constructor(method, endpoint = "/") {
+        super(method, endpoint);
+    }
+    serve(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let response = yield this.serveRest(request);
+            response.headers = { "Content-Type": "application/json" };
+            return response;
+        });
+    }
+    serveRest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {};
+        });
+    }
+}
+exports.default = ServiceRest;

package/dist/js/api/ServiceRestFormal.js

@@ -0,0 +1,97 @@
+"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 __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 Service_1 = __importStar(require("./Service"));
+const ServiceRest_1 = __importDefault(require("./ServiceRest"));
+class ServiceRestFormal extends ServiceRest_1.default {
+    constructor(method, endpoint = "/") {
+        super(method, endpoint);
+    }
+    serveRest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let response = yield this.serveRestFormal(request);
+                let content = ({ code: "0", description: "Service execution OK", data: response.content });
+                return Object.assign({}, response, { content });
+            }
+            catch (error) {
+                let content = ({ code: "-1", description: "Internal server error", debug: error.message });
+                throw error;
+            }
+        });
+    }
+    serveRestFormal(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok(null);
+        });
+    }
+    unwrap(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return ServiceRestFormal.unwrap(request);
+        });
+    }
+    fullSelect(request, api) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return ServiceRestFormal.fullSelect(request, api);
+        });
+    }
+    static unwrap(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let response = yield request;
+            if (response.httpCode !== 200)
+                throw response.content;
+            else
+                return (_a = response.content) === null || _a === void 0 ? void 0 : _a.data;
+        });
+    }
+    static fullSelect(request, api) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return api.select.serve(request).then((result) => {
+                var _a;
+                let select = (_a = result.content) === null || _a === void 0 ? void 0 : _a.data;
+                let requests = select === null || select === void 0 ? void 0 : select.map((selectId) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    let result = yield api.full.serve(Service_1.default.clone(request, { query: { id: selectId } }));
+                    return (_a = result.content) === null || _a === void 0 ? void 0 : _a.data;
+                }));
+                return Promise.all(requests !== null && requests !== void 0 ? requests : []);
+            });
+        });
+    }
+}
+exports.default = ServiceRestFormal;

package/dist/js/api/ServiceRestFormalTemplate.js

@@ -0,0 +1,127 @@
+"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 Service_1 = require("./Service");
+const ServiceRestFormal_1 = __importDefault(require("./ServiceRestFormal"));
+class ServiceRestFormalTemplate {
+    constructor(resource, tableName) {
+        this.indexer = "id";
+        this.unwrap = ServiceRestFormal_1.default.unwrap;
+        this.fullSelect = ServiceRestFormal_1.default.fullSelect;
+        this.resource = resource;
+        this.tableName = tableName;
+        this.get = new ServiceRestFormal_1.default("GET", `${resource}`);
+        this.get.serveRestFormal = this.serveGet.bind(this);
+        this.getList = new ServiceRestFormal_1.default("GET", `${resource}/list`);
+        this.getList.serveRestFormal = this.serveGetList.bind(this);
+        this.postList = new ServiceRestFormal_1.default("POST", `${resource}/list`);
+        this.postList.serveRestFormal = this.servePostList.bind(this);
+        this.page = new ServiceRestFormal_1.default("GET", `${resource}/page`);
+        this.page.serveRestFormal = this.servePage.bind(this);
+        this.map = new ServiceRestFormal_1.default("GET", `${resource}/map`);
+        this.map.serveRestFormal = this.serveMap.bind(this);
+        this.select = new ServiceRestFormal_1.default("GET", `${resource}/select`);
+        this.select.serveRestFormal = this.serveSelect.bind(this);
+        this.exist = new ServiceRestFormal_1.default("GET", `${resource}/exist`);
+        this.exist.serveRestFormal = this.serveExist.bind(this);
+        this.count = new ServiceRestFormal_1.default("GET", `${resource}/count`);
+        this.count.serveRestFormal = this.serveCount.bind(this);
+        this.post = new ServiceRestFormal_1.default("POST", `${resource}`);
+        this.post.serveRestFormal = this.servePost.bind(this);
+        this.put = new ServiceRestFormal_1.default("PUT", `${resource}`);
+        this.put.serveRestFormal = this.servePut.bind(this);
+        this.del = new ServiceRestFormal_1.default("DELETE", `${resource}`);
+        this.del.serveRestFormal = this.serveDel.bind(this);
+    }
+    serveGet(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let id = this.errors.getQuery("id", request.query);
+            let result = yield this.database.one(this.tableName, id);
+            return Service_1.HttpResponse.ok(result);
+        });
+    }
+    serveGetList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok(yield this.database.find(this.tableName, Object.assign({}, request.query)));
+        });
+    }
+    servePostList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let list = request.body;
+            if (!(list instanceof Array))
+                throw new Error("body must be a list");
+            return Service_1.HttpResponse.ok(this.database.addAll(this.tableName, list));
+        });
+    }
+    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);
+            return Service_1.HttpResponse.ok(results);
+        });
+    }
+    serveMap(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let results = yield this.database.find(this.tableName, Object.assign({}, request.query));
+            let response = {};
+            for (let result of results) {
+                let key = result[this.indexer];
+                if (!key)
+                    return Service_1.HttpResponse.ok({});
+                else
+                    response[key] = result;
+            }
+            return Service_1.HttpResponse.ok(response);
+        });
+    }
+    serveSelect(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            let selection = (_b = (_a = request.query) === null || _a === void 0 ? void 0 : _a["selection"]) !== null && _b !== void 0 ? _b : this.indexer;
+            (_c = request.query) === null || _c === void 0 ? true : delete _c["selection"];
+            let select = yield this.database.select(this.tableName, selection, Object.assign({}, request.query));
+            return Service_1.HttpResponse.ok(select);
+        });
+    }
+    serveExist(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok((yield this.database.count(this.tableName, Object.assign({}, request.query))) > 0);
+        });
+    }
+    serveCount(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok((yield this.database.count(this.tableName, Object.assign({}, request.query))));
+        });
+    }
+    servePost(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let entity = this.database.add(this.tableName, request.body);
+            return Service_1.HttpResponse.ok(entity);
+        });
+    }
+    servePut(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok("not implemented yet");
+        });
+    }
+    serveDel(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Service_1.HttpResponse.ok("not implemented yet");
+        });
+    }
+}
+exports.default = ServiceRestFormalTemplate;

package/dist/js/business/Business.js

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

package/dist/js/business/BusinessErrors.js

@@ -0,0 +1,101 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class BusinessErrors {
+    constructor() {
+        this.errors = {};
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    setErrors(errors) {
+        this.errors = errors;
+    }
+    get(code, ...params) {
+        var _a, _b;
+        let error = (_a = this.errors[code]) !== null && _a !== void 0 ? _a : this.getFallback();
+        let result = Object.assign({}, error);
+        for (const p in params)
+            result.description = (_b = result.description) === null || _b === void 0 ? void 0 : _b.replace(`\${${p}}`, params[p]);
+        return result;
+    }
+    except(code, ...params) {
+        let error = this.get(code, ...params);
+        //this.onExcept?.(error)
+        throw error;
+    }
+    notFound(endpoint) {
+        this.except("0004", endpoint);
+    }
+    getQuery(key, query) {
+        if (!query || !query[key])
+            this.except("0011", key);
+        return query[key];
+    }
+    eitherQuery(keys, query) {
+        let result = undefined;
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            if (query[key] !== undefined) {
+                if (!result)
+                    result = { key: key, value: query[key], index: i };
+                else
+                    this.except("0017", keys.join(" or "));
+            }
+        }
+        if (!result)
+            this.except("0016", keys.join(" or "));
+        return result;
+    }
+    getPath(key, path) {
+        if (!path[key])
+            this.except("0012", key);
+        return path[key];
+    }
+    getBody(body) {
+        if (!body)
+            this.except("0013");
+        return body;
+    }
+    getHeaders(key, headers) {
+        if (!headers[key])
+            this.except("0015", key);
+        return headers[key];
+    }
+    isType(key, value, type, assertion) {
+        try {
+            if (!assertion(value))
+                throw new Error();
+        }
+        catch (_a) {
+            this.except("0021", key, type);
+        }
+        return assertion(value);
+    }
+    exists(type, key, value, object) {
+        if (!object)
+            this.except("0030", type, key, value);
+        return object;
+    }
+    isRegex(key, value, regex) {
+        if (!new RegExp(regex).test(value))
+            this.except("0022", key);
+        return value;
+    }
+    isDate(key, value, format) {
+        this.except("0023", key, format);
+        return new Date(value);
+    }
+    getFallback() {
+        return { id: "-1", description: "Internal Server error", code: "-1", httpCode: 500 };
+    }
+}
+exports.default = BusinessErrors;

package/dist/js/business/BusinessLogger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BusinessLogger {
+    i(message) {
+        console.log(`${"I"}: ${new Date().toISOString()}\t${message}`);
+    }
+    ;
+}
+exports.default = BusinessLogger;

package/dist/js/business/BusinessProxy.js

@@ -0,0 +1,90 @@
+"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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fetch_1 = __importStar(require("node-fetch"));
+class BusinessProxy {
+    constructor() {
+        this.modules = {};
+    }
+    setModules(modules) {
+        this.modules = modules;
+    }
+    callFormal(tag, method, endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let response = yield this.call(tag, method, endpoint, request);
+            if ((response === null || response === void 0 ? void 0 : response.code) === "0")
+                return response.data;
+            else
+                throw response;
+        });
+    }
+    call(tag, method, endpoint, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let module = this.modules[tag];
+            if (!module)
+                throw new Error(`Module ${tag} does not exist`);
+            let headers = new node_fetch_1.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]);
+            let response = null;
+            try {
+                response = yield (0, node_fetch_1.default)(`${module.host}${endpoint}${this.map(request.query)}`, {
+                    method: method,
+                    body: method !== "GET" ? JSON.stringify(request.body) : undefined,
+                    headers: headers,
+                });
+            }
+            catch (error) {
+                throw new Error(`Module ${tag} is not responding`);
+            }
+            if (response.ok)
+                return yield response.json();
+            else
+                throw yield response.json();
+        });
+    }
+    map(query = {}) {
+        let queryString = "?";
+        for (const param in query) {
+            if (query[param] === undefined)
+                continue;
+            queryString += `${param}=${query[param]}&`;
+        }
+        return queryString;
+    }
+}
+exports.default = BusinessProxy;

package/dist/js/business/BusinessServer.js

@@ -0,0 +1,97 @@
+"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 Service_1 = require("../api/Service");
+const express_1 = __importDefault(require("express"));
+const Business_1 = __importDefault(require("./Business"));
+const cors_1 = __importDefault(require("cors"));
+class BusinessServer extends Business_1.default {
+    constructor() {
+        super();
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.urlencoded({ extended: false }));
+        this.app.use(express_1.default.json());
+        this.app.use((0, cors_1.default)());
+        this.publish = this.publish.bind(this);
+    }
+    start(port) {
+        this.app.listen(port, this.onStarted);
+    }
+    setServices(services) {
+        services.forEach(this.publish);
+    }
+    publish(service) {
+        switch (service.method) {
+            case "GET":
+                this.app.get(service.endpoint, this.run(service));
+                break;
+            case "POST":
+                this.app.post(service.endpoint, this.run(service));
+                break;
+            case "PUT":
+                this.app.put(service.endpoint, this.run(service));
+                break;
+            case "DELETE":
+                this.app.delete(service.endpoint, this.run(service));
+                break;
+            case "PATCH":
+                this.app.patch(service.endpoint, this.run(service));
+                break;
+            case "*":
+                this.app.all(service.endpoint, this.run(service));
+                break;
+        }
+    }
+    run(service) {
+        return (request, socket) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            let code;
+            let response = Service_1.HttpResponse.ko(500, "Internal server error");
+            // Asigna un valor único a la llamada de la API.
+            request.id = Math.ceil(Math.random() * 1000000).toString();
+            request.timestamp = new Date();
+            let indexParams = request.url.indexOf('?');
+            let endpoint = indexParams > 0 ? request.url.substring(0, indexParams) : request.url;
+            request.endpoint = !!endpoint ? endpoint : "/";
+            try {
+                try {
+                    (_a = this.onRequest) === null || _a === void 0 ? void 0 : _a.call(this, request);
+                }
+                catch (e) { }
+                response = yield ((_b = service.serve) === null || _b === void 0 ? void 0 : _b.call(service, request));
+                response.httpCode = (_c = response.httpCode) !== null && _c !== void 0 ? _c : 200;
+                try {
+                    response = ((_e = (_d = this.onResponse) === null || _d === void 0 ? void 0 : _d.call(this, request, response)) !== null && _e !== void 0 ? _e : response);
+                }
+                catch (e) { }
+            }
+            catch (error) {
+                (_f = this.onError) === null || _f === void 0 ? void 0 : _f.call(this, request, error);
+                let debug = error.message;
+                if (!error.code)
+                    error = { code: "-1", description: "Internal server error", debug };
+                let content = { code: error.code, description: error.description, debug };
+                response = Service_1.HttpResponse.ko(error.httpCode, content);
+            }
+            finally {
+                socket.status((_g = response === null || response === void 0 ? void 0 : response.httpCode) !== null && _g !== void 0 ? _g : 500).send(response === null || response === void 0 ? void 0 : response.content);
+                try {
+                    (_h = this.onEnd) === null || _h === void 0 ? void 0 : _h.call(this, request, response);
+                }
+                catch (e) { }
+            }
+        });
+    }
+}
+exports.default = BusinessServer;

package/dist/js/business/BusinessState.js

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

package/dist/js/business/BusinessThread.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Business_1 = __importDefault(require("./Business"));
+class BusinessThread extends Business_1.default {
+    constructor() {
+        super();
+        setTimeout(() => {
+            setInterval(() => {
+                try {
+                    this.run();
+                }
+                catch (err) {
+                    this.onError();
+                }
+            }, this.interval());
+        }, this.delay());
+    }
+    onError() { }
+}
+exports.default = BusinessThread;

package/dist/js/business/utils/CryptoUtils.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+class CryptoUtils {
+    static zeroPad(buf, blocksize) {
+        const pad = Buffer.alloc((blocksize - (buf.length % blocksize)) % blocksize, 0);
+        return Buffer.concat([buf, pad]);
+    }
+    static encrypt3DES(key, message) {
+        const keyBuf = Buffer.from(key, 'base64');
+        const iv = Buffer.alloc(8, 0);
+        const messageBuf = Buffer.from(message.toString(), 'utf8');
+        const paddedMessageBuf = CryptoUtils.zeroPad(messageBuf, 8);
+        const cipher = crypto_1.default.createCipheriv('des-ede3-cbc', keyBuf, iv);
+        cipher.setAutoPadding(false);
+        const encryptedBuf = Buffer.concat([
+            cipher.update(paddedMessageBuf), cipher.final()
+        ]);
+        const maxLength = Math.ceil(messageBuf.length / 8) * 8;
+        return encryptedBuf.slice(0, maxLength);
+    }
+    static sha256Sign(merchantKey, orderId, encodedOrder) {
+        const orderKeyBuf = CryptoUtils.encrypt3DES(merchantKey, orderId);
+        return crypto_1.default.createHmac('sha256', orderKeyBuf).update(encodedOrder).digest('base64');
+    }
+}
+exports.default = CryptoUtils;