@bxjs/base/framework/init.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
/// <reference path="../error.d.ts" />
function get_root_path_prefix() {
    return path.join(__dirname, '../../../../');
}
exports.get_root_path_prefix = get_root_path_prefix;
// 先加载框架层面的错误定义，再加载用户层面的错误定义，支持用户定义错误覆盖框架层面的错误多语言消息定义。
require('../error');
var path = require('path');
require(path.join(get_root_path_prefix(), './app/error')); // 初始化应用扩展的错误
var base_1 = require("./base");
var session_1 = require("./session");
require(path.join(get_root_path_prefix(), './app/global.out') + '.' + base_1.get_suffix_ts_or_js()); // 初始化应用一些枚举常量定义等方法
// 初始化IoC容器
require(path.join(get_root_path_prefix(), './app/plugins/container'));
var fs = require('fs');
var view = require('nunjucks');
var _ = require('lodash');
var typeis = require('type-is');
var querystring = require('querystring');
function get_app_entries_path_prefix() {
    return path.join(get_root_path_prefix(), './app/entries');
}
// https://github.com/eqfox/http-body-parser 参照koa的源码正确解析post请求参数
// 兼容application/json和application/x-www-form-urlencoded两种请求类型。
function parse_post_param(headers, body) {
    try {
        if (!body) {
            return {};
        }
        if (typeis({ headers: headers }, ['json'])) {
            return JSON.parse(body.toString(headers['content-encoding'] || 'utf8'));
        }
        else if (typeof headers['Content-Type'] == 'string' && headers['Content-Type'].match(/application\/json/)) {
            // bugfix API网关的字段类型值的赋值差异与type-is库的字段名称不兼容问题(content-type与Content-Type区别)
            return JSON.parse(body.toString(headers['content-encoding'] || 'utf8'));
        }
        else if (typeis({ headers: headers }, ['urlencoded'])) {
            return querystring.parse(body.toString(headers['content-encoding'] || 'utf8'));
        }
        else if (typeof headers['Content-Type'] == 'string' && headers['Content-Type'] == 'application/x-www-form-urlencoded') {
            // bugfix 线上乐高post请求参数解析不正确问题调试做兼容适配处理 TODO 待查原因为啥typeis库失效了
            // application/x-www-form-urlencoded
            return querystring.parse(body.toString(headers['content-encoding'] ||
                headers['Content-Encoding'] || 'utf8'));
        }
        else {
            xthrow(ERR$PARAM, { headers: headers, body: body });
        }
    }
    catch (err) {
        xthrow(err, { headers: headers, body: body });
    }
}
exports.parse_post_param = parse_post_param;
// 请求前置过滤处理
function filter_request_begin(api_path, param) {
    return __awaiter(this, void 0, void 0, function () {
        var entry, obj, api_callback, context;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    entry = require(api_path).default;
                    xassert(entry);
                    obj = new entry();
                    if (!obj._) return [3 /*break*/, 2];
                    // 强制执行请求参数验证逻辑
                    xassert(_.isFunction(obj._));
                    return [4 /*yield*/, obj._(param)];
                case 1:
                    _a.sent();
                    _a.label = 2;
                case 2:
                    api_callback = obj.$$;
                    if (!('__mock__' in param)) return [3 /*break*/, 3];
                    api_callback = obj.$ ? obj.$ : undefined;
                    return [3 /*break*/, 5];
                case 3:
                    if (!obj.context) return [3 /*break*/, 5];
                    xassert(_.isFunction(obj.context));
                    context = obj.context();
                    xassert(_.isPlainObject(context.param) && _.isFunction(context.auth));
                    return [4 /*yield*/, context.auth()];
                case 4:
                    _a.sent();
                    _a.label = 5;
                case 5: return [2 /*return*/, api_callback];
            }
        });
    });
}
// web页面的请求支持get或post，get仅仅用于页面跳转，自动兼容get和post用于表单递交以及web端的接口数据的返回处理（测试场景下支持get线上环境只支持post协议）。
function web_request_process(api, param) {
    return __awaiter(this, void 0, void 0, function () {
        var prefix, api_path, out, is_html_request, api_callback, err_1, api_callback, data;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    prefix = get_app_entries_path_prefix();
                    api_path = prefix + "/web/" + api;
                    out = undefined;
                    is_html_request = fs.existsSync(path.resolve(__dirname, prefix + "/web/" + api + ".html"));
                    _a.label = 1;
                case 1:
                    _a.trys.push([1, 4, , 9]);
                    return [4 /*yield*/, filter_request_begin(api_path, param)];
                case 2:
                    api_callback = _a.sent();
                    xassert(_.isFunction(api_callback));
                    return [4 /*yield*/, api_callback(param)]; // 回调API对应的业务逻辑实现
                case 3:
                    out = _a.sent(); // 回调API对应的业务逻辑实现
                    if (is_html_request) {
                        // 仅在web请求html页面的时候如果检测到302跳转的时候忽略模板渲染直接返回
                        if (global['__redirect_url__'] !== undefined) {
                            return [2 /*return*/];
                        }
                        // 将out转换到对应的html试图绑定之后再输出
                        view.configure(path.resolve(__dirname, prefix + "/web"), { noCache: true, autoescape: false });
                        out = view.render("./" + api + ".html", out);
                        return [2 /*return*/, out];
                    }
                    else {
                        // 对于web页面的关联ajax接口进行规范rest接口数据格式的统一处理
                        return [2 /*return*/, {
                                success: true,
                                content: out,
                                errorLevel: undefined,
                                errorCode: undefined,
                                errorMsg: undefined,
                            }];
                    }
                    return [3 /*break*/, 9];
                case 4:
                    err_1 = _a.sent();
                    // 业务错误报警处理 TODO 需要考虑错误忽略问题
                    return [4 /*yield*/, xwarn(err_1, api, param)];
                case 5:
                    // 业务错误报警处理 TODO 需要考虑错误忽略问题
                    _a.sent();
                    if (!is_html_request) return [3 /*break*/, 7];
                    // 只对业务逻辑错误处理区分框架错误还是业务错误（业务错误error页面显示，框架错误http错误状态码）FIXME 需要改进掉
                    xassert(fs.existsSync(path.resolve(__dirname, prefix + "/web/error." + base_1.get_suffix_ts_or_js())) &&
                        fs.existsSync(path.resolve(__dirname, prefix + "/web/error.html")));
                    api_callback = require(prefix + "/web/error." + base_1.get_suffix_ts_or_js()).default;
                    xassert(_.isFunction(api_callback));
                    return [4 /*yield*/, api_callback(err_1)];
                case 6:
                    out = _a.sent();
                    view.configure(path.resolve(__dirname, prefix + "/web"), { noCache: true, autoescape: false });
                    out = view.render("./error.html", out);
                    return [2 /*return*/, out];
                case 7:
                    data = xerror(err_1);
                    return [2 /*return*/, {
                            success: false,
                            content: data.param,
                            errorLevel: 'error',
                            errorCode: data.code,
                            errorMsg: data.msg,
                        }];
                case 8: return [3 /*break*/, 9];
                case 9: return [2 /*return*/];
            }
        });
    });
}
// rest api接口自动兼容get或post请求处理协议（测试场景下支持get线上环境只支持post协议）
function rest_request_process(api, param) {
    return __awaiter(this, void 0, void 0, function () {
        var prefix, api_path, api_callback, out, err_2, data;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    _a.trys.push([0, 3, , 5]);
                    prefix = get_app_entries_path_prefix();
                    api_path = prefix + "/rest/" + api;
                    return [4 /*yield*/, filter_request_begin(api_path, param)];
                case 1:
                    api_callback = _a.sent();
                    xassert(_.isFunction(api_callback));
                    return [4 /*yield*/, api_callback(param)]; // 回调API对应的业务逻辑实现
                case 2:
                    out = _a.sent() // 回调API对应的业务逻辑实现
                    ;
                    return [2 /*return*/, {
                            success: true,
                            content: out,
                            errorLevel: undefined,
                            errorCode: undefined,
                            errorMsg: undefined,
                        }];
                case 3:
                    err_2 = _a.sent();
                    return [4 /*yield*/, xwarn(err_2, api, param)];
                case 4:
                    _a.sent();
                    data = xerror(err_2);
                    return [2 /*return*/, {
                            success: false,
                            content: data.param,
                            errorLevel: 'error',
                            errorCode: data.code,
                            errorMsg: data.msg,
                        }];
                case 5: return [2 /*return*/];
            }
        });
    });
}
// 返回格式是HTML还是JSON取决于API路径对应的ts文件是否存在同名的html模板文件，如果存在则返回HTML否则全部返回JSON数据。
// 约定规范：POST请求都是restful的API接口（根据web和rest的路径进行具体区分），GET请求对应的路径有HTML就是WEB请求否则就是JSON请求。
// 通过约定简化路由的定义。
function request_process(api, param) {
    return __awaiter(this, void 0, void 0, function () {
        var out;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, session_1.__framework_session_init__()
                    // 根据API的前缀命名规范自动识别应用类型是纯rest项目还是纯web项目进行对应的处理逻辑
                ];
                case 1:
                    _a.sent();
                    if (!/^\/web\//.test(api)) return [3 /*break*/, 3];
                    return [4 /*yield*/, web_request_process(api.replace(/^\/web\//, ''), param)];
                case 2: return [2 /*return*/, _a.sent()];
                case 3:
                    if (!/^\/rest\//.test(api)) return [3 /*break*/, 5];
                    return [4 /*yield*/, rest_request_process(api.replace(/^\/rest\//, ''), param)];
                case 4:
                    out = _a.sent();
                    global['__redirect_url__'] = undefined;
                    return [2 /*return*/, out];
                case 5:
                    // TODO 正确优化界面提示返回HTTPS状态码错误！！！！过滤无效URL定义。
                    xthrow(ERR$PARAM, [api, param]);
                    _a.label = 6;
                case 6: return [2 /*return*/];
            }
        });
    });
}
exports.request_process = request_process;
// ajax返回成功结构说明
// {
//     success: true,
//     content: 返回内容，{}/[]
// }
// ajax返回失败结构说明
// {
//     success: false,
//     errorLevel:['info’, 'warn’, 'error’, 'fault’],
//     errorCode:错误码,
//     errorMsg:错误信息说明
// }
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["init.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sCAAsC;AACtC;IACI,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;AAC/C,CAAC;AAFD,oDAEC;AAED,sDAAsD;AACtD,OAAO,CAAC,UAAU,CAAC,CAAA;AACnB,IAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AAC5B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,aAAa,CAAC,CAAC,CAAA,CAAC,aAAa;AAEvE,+BAA0C;AAC1C,qCAAoD;AAEpD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,kBAAkB,CAAC,GAAG,GAAG,GAAG,0BAAmB,EAAE,CAAC,CAAA,CAAC,mBAAmB;AAEhH,WAAW;AACX,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,yBAAyB,CAAC,CAAC,CAAA;AAErE,IAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AACxB,IAAM,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;AAChC,IAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAC3B,IAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAA;AACjC,IAAM,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;AAE1C;IACI,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,eAAe,CAAC,CAAA;AAC7D,CAAC;AAED,iEAAiE;AACjE,8DAA8D;AAC9D,0BAAiC,OAAO,EAAE,IAAI;IAC1C,IAAI;QACA,IAAI,CAAC,IAAI,EAAE;YACP,OAAO,EAAE,CAAA;SACZ;QACD,IAAI,MAAM,CAAC,EAAC,OAAO,SAAA,EAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE;YAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAA;SAC1E;aAAM,IAAI,OAAO,OAAO,CAAC,cAAc,CAAC,IAAI,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE;YACzG,0EAA0E;YAC1E,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAA;SAC1E;aACI,IAAI,MAAM,CAAC,EAAC,OAAO,SAAA,EAAC,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE;YACxC,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAA;SACjF;aAAM,IAAI,OAAO,OAAO,CAAC,cAAc,CAAC,IAAI,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,IAAI,mCAAmC,EAAE;YACrH,4DAA4D;YAC5D,oCAAoC;YACpC,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC;gBAC9D,OAAO,CAAC,kBAAkB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAA;SAC9C;aACI;YACD,MAAM,CAAC,SAAS,EAAE,EAAC,OAAO,SAAA,EAAE,IAAI,MAAA,EAAC,CAAC,CAAA;SACrC;KACJ;IAAC,OAAO,GAAG,EAAE;QACV,MAAM,CAAC,GAAG,EAAE,EAAC,OAAO,SAAA,EAAE,IAAI,MAAA,EAAC,CAAC,CAAA;KAC/B;AACL,CAAC;AAzBD,4CAyBC;AAED,WAAW;AACX,8BAAoC,QAAgB,EAAE,KAAU;;;;;;oBACtD,KAAK,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAA;oBACvC,OAAO,CAAC,KAAK,CAAC,CAAA;oBACR,GAAG,GAAG,IAAI,KAAK,EAAE,CAAA;yBACnB,GAAG,CAAC,CAAC,EAAL,wBAAK;oBACL,eAAe;oBACf,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;oBAC5B,qBAAM,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAA;;oBAAlB,SAAkB,CAAA;;;oBAGlB,YAAY,GAAG,GAAG,CAAC,EAAE,CAAA;yBACrB,CAAA,UAAU,IAAI,KAAK,CAAA,EAAnB,wBAAmB;oBACnB,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;;;yBAGpC,GAAG,CAAC,OAAO,EAAX,wBAAW;oBACX,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;oBAC5B,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,CAAA;oBAC7B,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;oBACrE,qBAAM,OAAO,CAAC,IAAI,EAAE,EAAA;;oBAApB,SAAoB,CAAA;;wBAG5B,sBAAO,YAAY,EAAA;;;;CACtB;AAED,8FAA8F;AAC9F,6BAAmC,GAAW,EAAE,KAAU;;;;;;oBAClD,MAAM,GAAG,2BAA2B,EAAE,CAAA;oBACtC,QAAQ,GAAM,MAAM,aAAQ,GAAK,CAAA;oBACjC,GAAG,GAAQ,SAAS,CAAA;oBACpB,eAAe,GACf,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAK,MAAM,aAAQ,GAAG,UAAO,CAAC,CAAC,CAAA;;;;oBAGhD,qBAAM,oBAAoB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAA;;oBAA1D,YAAY,GAAG,SAA2C;oBAC9D,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAA;oBAC7B,qBAAM,YAAY,CAAC,KAAK,CAAC,EAAA,CAAC,iBAAiB;;oBAAjD,GAAG,GAAG,SAAyB,CAAA,CAAC,iBAAiB;oBACjD,IAAI,eAAe,EAAE;wBACjB,0CAA0C;wBAC1C,IAAI,MAAM,CAAC,kBAAkB,CAAC,KAAK,SAAS,EAAE;4BAC1C,sBAAM;yBACT;wBACD,0BAA0B;wBAC1B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAK,MAAM,SAAM,CAAC,EAAE,EAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;wBAC5F,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,OAAK,GAAG,UAAO,EAAE,GAAG,CAAC,CAAA;wBACvC,sBAAO,GAAG,EAAA;qBACb;yBAAM;wBACH,sCAAsC;wBACtC,sBAAO;gCACH,OAAO,EAAE,IAAI;gCACb,OAAO,EAAE,GAAG;gCACZ,UAAU,EAAE,SAAS;gCACrB,SAAS,EAAE,SAAS;gCACpB,QAAQ,EAAE,SAAS;6BACtB,EAAA;qBACJ;;;;oBAED,2BAA2B;oBAC3B,qBAAM,KAAK,CAAC,KAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAAA;;oBAD5B,2BAA2B;oBAC3B,SAA4B,CAAA;yBAExB,eAAe,EAAf,wBAAe;oBACf,iEAAiE;oBACjE,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAK,MAAM,gBAAa,GAAG,0BAAmB,EAAE,CAAC,CAAC;wBAC1F,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAK,MAAM,oBAAiB,CAAC,CAAC,CAAC,CAAA;oBACnE,YAAY,GAAG,OAAO,CAAI,MAAM,gBAAa,GAAG,0BAAmB,EAAE,CAAC,CAAC,OAAO,CAAA;oBAClF,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAA;oBAC7B,qBAAM,YAAY,CAAC,KAAG,CAAC,EAAA;;oBAA7B,GAAG,GAAG,SAAuB,CAAA;oBAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAK,MAAM,SAAM,CAAC,EAAE,EAAC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;oBAC5F,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAA;oBACtC,sBAAO,GAAG,EAAA;;oBAEN,IAAI,GAAG,MAAM,CAAC,KAAG,CAAC,CAAA;oBACtB,sBAAO;4BACH,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI,CAAC,KAAK;4BACnB,UAAU,EAAE,OAAO;4BACnB,SAAS,EAAE,IAAI,CAAC,IAAI;4BACpB,QAAQ,EAAE,IAAI,CAAC,GAAG;yBACrB,EAAA;;;;;;CAGZ;AAED,wDAAwD;AACxD,8BAAoC,GAAW,EAAE,KAAU;;;;;;;oBAE/C,MAAM,GAAG,2BAA2B,EAAE,CAAA;oBACtC,QAAQ,GAAM,MAAM,cAAS,GAAK,CAAA;oBACnB,qBAAM,oBAAoB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAA;;oBAA1D,YAAY,GAAG,SAA2C;oBAC9D,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAA;oBACzB,qBAAM,YAAY,CAAC,KAAK,CAAC,EAAA,CAAC,iBAAiB;;oBAAjD,GAAG,GAAG,SAAyB,CAAC,iBAAiB;oBAAlB;oBACnC,sBAAO;4BACH,OAAO,EAAE,IAAI;4BACb,OAAO,EAAE,GAAG;4BACZ,UAAU,EAAE,SAAS;4BACrB,SAAS,EAAE,SAAS;4BACpB,QAAQ,EAAE,SAAS;yBACtB,EAAA;;;oBAED,qBAAM,KAAK,CAAC,KAAG,EAAE,GAAG,EAAE,KAAK,CAAC,EAAA;;oBAA5B,SAA4B,CAAA;oBACxB,IAAI,GAAG,MAAM,CAAC,KAAG,CAAC,CAAA;oBACtB,sBAAO;4BACH,OAAO,EAAE,KAAK;4BACd,OAAO,EAAE,IAAI,CAAC,KAAK;4BACnB,UAAU,EAAE,OAAO;4BACnB,SAAS,EAAE,IAAI,CAAC,IAAI;4BACpB,QAAQ,EAAE,IAAI,CAAC,GAAG;yBACrB,EAAA;;;;;CAGR;AAED,yEAAyE;AACzE,oFAAoF;AACpF,eAAe;AACf,yBAAsC,GAAW,EAAE,KAAU;;;;;wBACzD,qBAAM,oCAA0B,EAAE;oBAClC,gDAAgD;kBADd;;oBAAlC,SAAkC,CAAA;yBAE9B,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAApB,wBAAoB;oBACb,qBAAM,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,EAAA;wBAApE,sBAAO,SAA6D,EAAA;;yBAC7D,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,EAArB,wBAAqB;oBAClB,qBAAM,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,EAAA;;oBAArE,GAAG,GAAG,SAA+D;oBACzE,MAAM,CAAC,kBAAkB,CAAC,GAAG,SAAS,CAAA;oBACtC,sBAAO,GAAG,EAAA;;oBAEV,0CAA0C;oBAC1C,MAAM,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;;;;;;CAEtC;AAbD,0CAaC;AAED,eAAe;AACf,IAAI;AACJ,qBAAqB;AACrB,0BAA0B;AAC1B,IAAI;AACJ,eAAe;AACf,IAAI;AACJ,sBAAsB;AACtB,qDAAqD;AACrD,qBAAqB;AACrB,sBAAsB;AACtB,IAAI","sourcesContent":["/// <reference path=\"../error.d.ts\" />\nexport function get_root_path_prefix() {\n    return path.join(__dirname, '../../../../')\n}\n\n// 先加载框架层面的错误定义，再加载用户层面的错误定义，支持用户定义错误覆盖框架层面的错误多语言消息定义。\nrequire('../error')\nconst path = require('path')\nrequire(path.join(get_root_path_prefix(), './app/error')) // 初始化应用扩展的错误\n\nimport {get_suffix_ts_or_js} from './base'\nimport {__framework_session_init__} from './session'\n\nrequire(path.join(get_root_path_prefix(), './app/global.out') + '.' + get_suffix_ts_or_js()) // 初始化应用一些枚举常量定义等方法\n\n// 初始化IoC容器\nrequire(path.join(get_root_path_prefix(), './app/plugins/container'))\n\nconst fs = require('fs')\nconst view = require('nunjucks')\nconst _ = require('lodash')\nconst typeis = require('type-is')\nconst querystring = require('querystring')\n\nfunction get_app_entries_path_prefix() {\n    return path.join(get_root_path_prefix(), './app/entries')\n}\n\n// https://github.com/eqfox/http-body-parser 参照koa的源码正确解析post请求参数\n// 兼容application/json和application/x-www-form-urlencoded两种请求类型。\nexport function parse_post_param(headers, body) {\n    try {\n        if (!body) {\n            return {}\n        }\n        if (typeis({headers}, ['json'])) {\n            return JSON.parse(body.toString(headers['content-encoding'] || 'utf8'))\n        } else if (typeof headers['Content-Type'] == 'string' && headers['Content-Type'].match(/application\\/json/)) {\n            // bugfix API网关的字段类型值的赋值差异与type-is库的字段名称不兼容问题(content-type与Content-Type区别)\n            return JSON.parse(body.toString(headers['content-encoding'] || 'utf8'))\n        }\n        else if (typeis({headers}, ['urlencoded'])) {\n            return querystring.parse(body.toString(headers['content-encoding'] || 'utf8'))\n        } else if (typeof headers['Content-Type'] == 'string' && headers['Content-Type'] == 'application/x-www-form-urlencoded') {\n            // bugfix 线上乐高post请求参数解析不正确问题调试做兼容适配处理 TODO 待查原因为啥typeis库失效了\n            // application/x-www-form-urlencoded\n            return querystring.parse(body.toString(headers['content-encoding'] ||\n                headers['Content-Encoding'] || 'utf8'))\n        }\n        else {\n            xthrow(ERR$PARAM, {headers, body})\n        }\n    } catch (err) {\n        xthrow(err, {headers, body})\n    }\n}\n\n// 请求前置过滤处理\nasync function filter_request_begin(api_path: string, param: any) {\n    const entry = require(api_path).default\n    xassert(entry)\n    const obj = new entry()\n    if (obj._) {\n        // 强制执行请求参数验证逻辑\n        xassert(_.isFunction(obj._))\n        await obj._(param)\n    }\n    // 对于MOCK还是正式请求路由的调用判断处理\n    let api_callback = obj.$$\n    if ('__mock__' in param) {\n        api_callback = obj.$ ? obj.$ : undefined\n    } else {\n        // 正式请求前置处理：auth鉴权、等等操作统一框架代码实现\n        if (obj.context) {\n            xassert(_.isFunction(obj.context))\n            const context = obj.context()\n            xassert(_.isPlainObject(context.param) && _.isFunction(context.auth))\n            await context.auth()\n        }\n    }\n    return api_callback\n}\n\n// web页面的请求支持get或post，get仅仅用于页面跳转，自动兼容get和post用于表单递交以及web端的接口数据的返回处理（测试场景下支持get线上环境只支持post协议）。\nasync function web_request_process(api: string, param: any) {\n    let prefix = get_app_entries_path_prefix()\n    let api_path = `${prefix}/web/${api}`\n    let out: any = undefined\n    let is_html_request: boolean =\n        fs.existsSync(path.resolve(__dirname, `${prefix}/web/${api}.html`))\n\n    try {\n        let api_callback = await filter_request_begin(api_path, param)\n        xassert(_.isFunction(api_callback))\n        out = await api_callback(param) // 回调API对应的业务逻辑实现\n        if (is_html_request) {\n            // 仅在web请求html页面的时候如果检测到302跳转的时候忽略模板渲染直接返回\n            if (global['__redirect_url__'] !== undefined) {\n                return\n            }\n            // 将out转换到对应的html试图绑定之后再输出\n            view.configure(path.resolve(__dirname, `${prefix}/web`), {noCache: true, autoescape: false})\n            out = view.render(`./${api}.html`, out)\n            return out\n        } else {\n            // 对于web页面的关联ajax接口进行规范rest接口数据格式的统一处理\n            return {\n                success: true,\n                content: out,\n                errorLevel: undefined,\n                errorCode: undefined,\n                errorMsg: undefined,\n            }\n        }\n    } catch (err) {\n        // 业务错误报警处理 TODO 需要考虑错误忽略问题\n        await xwarn(err, api, param)\n\n        if (is_html_request) {\n            // 只对业务逻辑错误处理区分框架错误还是业务错误（业务错误error页面显示，框架错误http错误状态码）FIXME 需要改进掉\n            xassert(fs.existsSync(path.resolve(__dirname, `${prefix}/web/error.` + get_suffix_ts_or_js())) &&\n                fs.existsSync(path.resolve(__dirname, `${prefix}/web/error.html`)))\n            let api_callback = require(`${prefix}/web/error.` + get_suffix_ts_or_js()).default\n            xassert(_.isFunction(api_callback))\n            out = await api_callback(err)\n            view.configure(path.resolve(__dirname, `${prefix}/web`), {noCache: true, autoescape: false})\n            out = view.render(`./error.html`, out)\n            return out\n        } else {\n            let data = xerror(err)\n            return {\n                success: false,\n                content: data.param,\n                errorLevel: 'error',\n                errorCode: data.code,\n                errorMsg: data.msg,\n            }\n        }\n    }\n}\n\n// rest api接口自动兼容get或post请求处理协议（测试场景下支持get线上环境只支持post协议）\nasync function rest_request_process(api: string, param: any) {\n    try {\n        let prefix = get_app_entries_path_prefix()\n        let api_path = `${prefix}/rest/${api}`\n        let api_callback = await filter_request_begin(api_path, param)\n        xassert(_.isFunction(api_callback))\n        let out = await api_callback(param) // 回调API对应的业务逻辑实现\n        return {\n            success: true,\n            content: out,\n            errorLevel: undefined,\n            errorCode: undefined,\n            errorMsg: undefined,\n        }\n    } catch (err) {\n        await xwarn(err, api, param)\n        let data = xerror(err)\n        return {\n            success: false,\n            content: data.param,\n            errorLevel: 'error',\n            errorCode: data.code,\n            errorMsg: data.msg,\n        }\n    }\n\n}\n\n// 返回格式是HTML还是JSON取决于API路径对应的ts文件是否存在同名的html模板文件，如果存在则返回HTML否则全部返回JSON数据。\n// 约定规范：POST请求都是restful的API接口（根据web和rest的路径进行具体区分），GET请求对应的路径有HTML就是WEB请求否则就是JSON请求。\n// 通过约定简化路由的定义。\nexport async function request_process(api: string, param: any) {\n    await __framework_session_init__()\n    // 根据API的前缀命名规范自动识别应用类型是纯rest项目还是纯web项目进行对应的处理逻辑\n    if (/^\\/web\\//.test(api)) {\n        return await web_request_process(api.replace(/^\\/web\\//, ''), param)\n    } else if (/^\\/rest\\//.test(api)) {\n        let out = await rest_request_process(api.replace(/^\\/rest\\//, ''), param)\n        global['__redirect_url__'] = undefined\n        return out\n    } else {\n        // TODO 正确优化界面提示返回HTTPS状态码错误！！！！过滤无效URL定义。\n        xthrow(ERR$PARAM, [api, param])\n    }\n}\n\n// ajax返回成功结构说明\n// {\n//     success: true,\n//     content: 返回内容，{}/[]\n// }\n// ajax返回失败结构说明\n// {\n//     success: false,\n//     errorLevel:['info’, 'warn’, 'error’, 'fault’],\n//     errorCode:错误码,\n//     errorMsg:错误信息说明\n// }"]}