UNPKG

50.2 kBJavaScriptView Raw
1"use strict";
2var __assign = (this && this.__assign) || Object.assign || function(t) {
3 for (var s, i = 1, n = arguments.length; i < n; i++) {
4 s = arguments[i];
5 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
6 t[p] = s[p];
7 }
8 return t;
9};
10var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
11 return new (P || (P = Promise))(function (resolve, reject) {
12 function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
13 function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
14 function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
15 step((generator = generator.apply(thisArg, _arguments || [])).next());
16 });
17};
18var __generator = (this && this.__generator) || function (thisArg, body) {
19 var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
20 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
21 function verb(n) { return function (v) { return step([n, v]); }; }
22 function step(op) {
23 if (f) throw new TypeError("Generator is already executing.");
24 while (_) try {
25 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;
26 if (y = 0, t) op = [op[0] & 2, t.value];
27 switch (op[0]) {
28 case 0: case 1: t = op; break;
29 case 4: _.label++; return { value: op[1], done: false };
30 case 5: _.label++; y = op[1]; op = [0]; continue;
31 case 7: op = _.ops.pop(); _.trys.pop(); continue;
32 default:
33 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
34 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
35 if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
36 if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
37 if (t[2]) _.ops.pop();
38 _.trys.pop(); continue;
39 }
40 op = body.call(thisArg, _);
41 } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
42 if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
43 }
44};
45Object.defineProperty(exports, "__esModule", { value: true });
46require('source-map-support').install();
47require('tsconfig-paths').register();
48var init_1 = require("./init");
49var _ = require('lodash');
50// // 临时调试线上日志打印
51// //framework/index.ts(8,13): error TS2339: Property 'setLogLevel' does not exist on type 'Console'
52// exports.handler = async function (event, context, callback) {
53// // console.setLogLevel('error') 不能写在此会导致编译错误阿里云自己扩展的私有方法
54// console.log('xxxxx', 'yyyyy', 'zzzzzz')
55// console.error('xxxxx1', 'yyyyy1', 'zzzzzz1')
56// let out = '<html><body>zzzzzz</body></html>'
57// let htmlResponse = {
58// isBase64Encoded: true,
59// statusCode: 200,
60// headers: {
61// "Content-type": "text/html; charset=utf-8",
62// },
63// // base64 encode body so it can be safely returned as JSON value
64// body: new Buffer(out as string).toString('base64')
65// }
66// callback(null, htmlResponse)
67// }
68// 基于阿里云的函数计算统一入口的路由处理
69exports.handler = function (event, context, callback) {
70 return __awaiter(this, void 0, void 0, function () {
71 var evt, __cors__, _a, payload, err_1, __api__, __url__, __header__, param, out, _b, post, body, err_2, cookie, setCookie, htmlResponse, jsonResponse, err_3;
72 return __generator(this, function (_c) {
73 switch (_c.label) {
74 case 0:
75 // TODO 增加对于定时器的功能模拟实现
76 // xlog('$$$$=>' + event.toString())
77 // TODO 去除掉换行方便方便SLS上的日志输出排版显示
78 xlog('$$$$=>' + event.toString().replace(/\r/g, '').replace(/\n/g, ''));
79 evt = JSON.parse(event.toString());
80 // 根据API网关设置的环境常量参数正确配置线上版本的运行环境，取代AONE的本地、日常、预发、灰度等环境部署支持开发。
81 // 全局变量仅仅用于放在整个应用生命周期变量
82 global['__env__'] = _.get(evt, 'headers.__env__', 'prod');
83 __cors__ = {};
84 if (global['__env__'] !== 'prod' && global['__env__'] !== 'gray') {
85 // 非生产环境或灰度环境，需要禁用CORS功能禁止跨域访问增加安全性。
86 if (evt.headers.origin) {
87 // 获取源站动态允许请求跨域 (FIXME 需要进行安全限制对来源服务器网址合法性进行安全限制，本地开发调试全部放开请求)
88 __cors__['Access-Control-Allow-Origin'] = evt.headers.origin;
89 // __cors__['Access-Control-Allow-Origin'] = '*' // 不能设置为任意值浏览器有安全限制
90 }
91 __cors__['Access-Control-Allow-Credentials'] = 'true';
92 __cors__['Access-Control-Allow-Headers'] = 'Origin, X-Requested-With, Content-Type, Accept';
93 __cors__['Access-Control-Allow-Methods'] = 'POST, OPTIONS';
94 }
95 // 支持跨域的验证请求方法的合法性规避掉过滤掉不安全的请求。
96 switch (evt.httpMethod) {
97 case 'GET':
98 case 'POST':
99 break;
100 case 'OPTIONS':
101 if (global['__env__'] == 'prod' || global['__env__'] == 'gray') {
102 // 生产和灰度环境下禁止跨域OPTIONS请求以便于增强安全性
103 callback(null, {
104 statusCode: 400,
105 });
106 }
107 else {
108 // 非生产和灰度环境下才允许支持跨域OPTIONS请求
109 callback(null, {
110 statusCode: 200,
111 headers: __assign({}, __cors__),
112 });
113 }
114 return [2 /*return*/];
115 default:
116 // 禁止任何的非法请求严格进行约定限制
117 callback(null, {
118 statusCode: 400,
119 });
120 return [2 /*return*/];
121 }
122 if (!evt['triggerName']) return [3 /*break*/, 6];
123 _a = evt['triggerName'];
124 switch (_a) {
125 case '__axjs-preheat-timer__': return [3 /*break*/, 1];
126 }
127 return [3 /*break*/, 5];
128 case 1:
129 _c.trys.push([1, 3, , 4]);
130 payload = JSON.parse(evt['payload']);
131 xassert(payload['url'] && payload['timeout']);
132 return [4 /*yield*/, xpost(payload['url'], payload['param'], undefined, payload['timeout'])];
133 case 2:
134 _c.sent();
135 return [3 /*break*/, 4];
136 case 3:
137 err_1 = _c.sent();
138 // ignore error
139 xlog(JSON.stringify(xerror(err_1)).replace(/\r/g, '').replace(/\n/g, ''));
140 return [3 /*break*/, 4];
141 case 4: return [3 /*break*/, 5];
142 case 5: return [2 /*return*/];
143 case 6:
144 if (evt['path'] === '/__axjs-preheat-timer__') {
145 // 预热api网关的空请求心跳接口实现
146 return [2 /*return*/];
147 }
148 _c.label = 7;
149 case 7:
150 global['__evt__'] = event.toString(); // FIXME 需要设计上下文定义请求实例生命周期变量
151 __api__ = _.get(evt, 'headers.__api__', evt.path) // 最终控制器与app子目录下的ts文件保持完全的一一映射关系。
152 ;
153 __url__ = evt['headers']['X-Forwarded-Proto'] + '://' + evt['headers']['CA-Host'] + evt['path'];
154 __header__ = evt['headers'];
155 param = Object.assign({ __api__: __api__, __url__: __url__, __header__: __header__ }, // header请求中的两个框架层面上的预定义参数 TODO 需要移除掉并非应用关心的内容
156 evt.pathParameters || {}, // 路由重写参数 domain/[a]/[b]?xxx (可被GET参数覆盖)
157 evt.queryParameters || {} // GET请求参数 domain/path?a=x&b=x
158 );
159 out = {};
160 _b = evt.httpMethod;
161 switch (_b) {
162 case 'GET': return [3 /*break*/, 8];
163 case 'POST': return [3 /*break*/, 9];
164 }
165 return [3 /*break*/, 13];
166 case 8: return [3 /*break*/, 14];
167 case 9:
168 _c.trys.push([9, 10, , 12]);
169 post = {};
170 if (_.isString(evt.body)) {
171 body = evt.body;
172 if (evt.isBase64Encoded) {
173 body = new Buffer(evt.body, 'base64').toString();
174 }
175 post = init_1.parse_post_param(evt['headers'], body);
176 }
177 param = Object.assign(param, post); // 用post参数覆盖掉get参数，用于灵活的设置请求参数兼容get和post两种方法方便开发调试。
178 return [3 /*break*/, 12];
179 case 10:
180 err_2 = _c.sent();
181 xlog(err_2, evt.httpMethod, evt.body);
182 return [4 /*yield*/, xwarn(err_2)
183 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
184 ];
185 case 11:
186 _c.sent();
187 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
188 callback(null, {
189 statusCode: 400,
190 });
191 return [2 /*return*/];
192 case 12: return [3 /*break*/, 14];
193 case 13:
194 xlog(evt.httpMethod, evt.body);
195 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
196 callback(null, {
197 statusCode: 400,
198 });
199 return [2 /*return*/];
200 case 14:
201 _c.trys.push([14, 16, , 18]);
202 cookie = _.get(evt['headers'], 'Cookie', undefined);
203 if (!cookie) {
204 cookie = _.get(evt['headers'], 'cookie', '');
205 }
206 global['__request_cookies__'] = require('cookie').parse(cookie);
207 // 获取use-agent请求头部信息
208 global['__user_agent__'] = evt['headers']['User-Agent'];
209 // 获取客户端的IP地址信息
210 global['__client_ip__'] = evt['headers']['X-Real-IP'];
211 return [4 /*yield*/, init_1.request_process(__api__, param)
212 // 处理response的cookies设置
213 ];
214 case 15:
215 // TODO WEB请求需要对404页面以及ERROR页面进行兼容处理（在framework内部进行细节的错误判断在out中透传status的http的状态吗正确错误返回）
216 // 404 Not Found 服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
217 // 403 Forbidden 服务器理解请求客户端的请求，但是拒绝执行此请求（权限验证处理错误）
218 out = _c.sent();
219 setCookie = { 'Set-Cookie': undefined };
220 if (!_.isEmpty(global['__respond_cookies__'])) {
221 setCookie['Set-Cookie'] = _.values(global['__respond_cookies__']);
222 }
223 if (global['__redirect_url__']) {
224 callback(null, {
225 statusCode: 302,
226 headers: __assign({ "Location": global['__redirect_url__'] }, setCookie),
227 });
228 global['__redirect_url__'] = undefined;
229 }
230 else if (_.isString(out)) {
231 htmlResponse = {
232 isBase64Encoded: true,
233 statusCode: 200,
234 headers: __assign({ "Content-type": "text/html; charset=utf-8" }, setCookie, __cors__),
235 // base64 encode body so it can be safely returned as JSON value
236 body: new Buffer(out).toString('base64')
237 };
238 callback(null, htmlResponse);
239 }
240 else {
241 jsonResponse = {
242 isBase64Encoded: true,
243 statusCode: 200,
244 headers: __assign({ "Content-type": "application/json" }, __cors__),
245 // base64 encode body so it can be safely returned as JSON value
246 body: new Buffer(JSON.stringify(out)).toString('base64')
247 };
248 callback(null, jsonResponse);
249 }
250 return [3 /*break*/, 18];
251 case 16:
252 err_3 = _c.sent();
253 // 通知框架自身实现逻辑的意外报错（框架自身不论何种情况都应该正常工作，一旦出现此问题大多数情况是框架自身问题或者流量引发的运维问题）
254 return [4 /*yield*/, xwarn({
255 __api__: __api__, __url__: __url__, param: param, message: err_3.message, stack: xstack(err_3)
256 })
257 // 500 Internal Server Error 服务器内部错误，无法完成请求
258 ];
259 case 17:
260 // 通知框架自身实现逻辑的意外报错（框架自身不论何种情况都应该正常工作，一旦出现此问题大多数情况是框架自身问题或者流量引发的运维问题）
261 _c.sent();
262 // 500 Internal Server Error 服务器内部错误，无法完成请求
263 callback(null, { statusCode: 500 });
264 return [3 /*break*/, 18];
265 case 18: return [2 /*return*/];
266 }
267 });
268 });
269};
270// API参数的识别逻辑，为普通字符串路径定义与app下的ts文件路由完全一一对应，优先取HEADER中的定义，再取GET中的形参定义或者POST形参定义进行参数请求的覆盖处理。
271// PARAM请求的参数处理要求为BASE64编码化的JSON字符串。
272// "event": {
273// "body": "ewoJImFwaSI6ICIvYS9iL2MiLAoJInBhcmFtIjogImFzZGZhc2RmYXNkZiIKfQ==", => 对应于POST请求数据
274// "headers": {
275// "X-Ca-Api-Gateway": "B25CD51B-5815-4775-9EAB-6D481BC1AE17",
276// "__api__": "/web/mobile/test", =》 自定义转义PATH的路径信息对于SEO优化兼容处理（也可以在GET或POST请求中传递对应参数）
277// "X-Forwarded-For": "42.120.74.88",
278// "Content-Type": "application/json"
279// },
280// "httpMethod": "POST",
281// "isBase64Encoded": true,
282// "path": "/", =》 没有意义用于前端根据需要自己进行扩展别名映射处理，后端的控制器不以此为标准，可以对同一个控制器定义N个不同的路径标识。
283// "pathParameters": {},
284// "queryParameters": {} => 对应于GET请求数据
285// },
286// "query": {},
287// "context": {
288// "requestId": "B25CD51B-5815-4775-9EAB-6D481BC1AE17",
289// "credentials": {
290// "accessKeyId": "",
291// "accessKeySecret": "",
292// "securityToken": ""
293// },
294// "function": {
295// "name": "test",
296// "handler": "index.handler",
297// "memory": 128,
298// "timeout": 300
299// },
300// "services": {
301// "name": "alilang",
302// "logProject": "",
303// "logStore": ""
304// },
305// "region": "cn-shanghai",
306// "accountId": "1734066057689528"
307// }
308// }
309// 最新版本event的API网关的FC返回数据格式：
310// CA-Host请求域名、
311// X-Forwarded-Proto
312// "path": "/test", ==》》基本上可以拼接出__url__参数可以省略掉此冗余参数配置了。
313// ==》》借助route.map.ts文件的映射关系定义省略掉__api__配置进一步简化网关应用。
314// "httpMethod": "GET",
315// "isBase64Encoded": true,
316// "X-Forwarded-For": "42.120.74.103", // 客户端请求IP地址用户判定所属区域信息海外访问问题优化依赖点
317// "X-Real-IP": "42.120.74.103",
318// Cookie
319// User-Agent =>> PC站和M站自适应问题
320// Accept-Language =>> 浏览器客户端的语言类型自动适配多语言架构设计问题
321// let x = {
322// "body": "",
323// "headers": {
324// "X-Ca-Api-Gateway": "B276F77B-334E-4857-AE64-65BAFD419E2A",
325// "Cookie": "cna=r5snEzzOvA0CASp4Smdq+II/; UM_distinctid=162bcd61d9111cd-080e0f43e6b60d-33697b04-13c680-162bcd61d92c86; _tb_token_=H8U7BqixF3YVR3GnhMRz; NEW2_ACR_JSESSIONID=VM566F91-K5CP8QIVMQTSAH3C4H5X1-DRIHYJHJ-QE2; _new_cr_session0=1AbLByOMHeZe3G41KYd5WcPdC%2Fi8qvGHUBTK8Fbrfx8Soi%2BHELuxxA6jros7W%2FqC1YtebgB3auEF5lu1SCzUzTkt6v%2FiFeN%2FptbvBRziYEGXSEVhWnUlBR2tfpjrXMnIcfb2%2FwnGkH4vkeMIJ1Bvuw%3D%3D; emplId=149337; hrc_sidebar=open; traceId=7d4b16de-74bc-4eac-884b-54ca0354e4aa; SSO_LANG=ZH-CN; SSO_EMPID_HASH=9db1ed21402f7c36674b5e6e6de1fc68; animate_date=201864; aa=xxxxxxx; cn_1260001221_dplus=%7B%22distinct_id%22%3A%20%22162bcd61d9111cd-080e0f43e6b60d-33697b04-13c680-162bcd61d92c86%22%2C%22sp%22%3A%20%7B%22%24_sessionid%22%3A%200%2C%22%24_sessionTime%22%3A%201528086234%2C%22%24dp%22%3A%200%2C%22%24_sessionPVTime%22%3A%201528086234%7D%7D; isg=BDw8SonyS9utyn5fedYRe-uRDdzwNAD0-51BHha9_ScJ4dxrNkWw77KQxQmZqRi3",
326// "X-Forwarded-Proto": "https",
327// "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36",
328// "__url__": "https://toufang.alibaba-inc.com/test",
329// "CA-Host": "toufang.alibaba-inc.com",
330// "Cache-Control": "max-age=0",
331// "upgrade-insecure-requests": "1",
332// "Accept-Language": "zh-CN,zh;q=0.9",
333// "__api__": "/web/test/test",
334// "Accept-Encoding": "gzip, deflate, br",
335// "X-Forwarded-For": "42.120.74.103",
336// "X-Real-IP": "42.120.74.103",
337// "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
338// },
339// "httpMethod": "GET",
340// "isBase64Encoded": true,
341// "path": "/test",
342// "pathParameters": {},
343// "queryParameters": {}
344// }
345//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["require('source-map-support').install()\nrequire('tsconfig-paths').register()\nimport {request_process, parse_post_param} from './init'\n\nconst _ = require('lodash')\n\n// // 临时调试线上日志打印\n// //framework/index.ts(8,13): error TS2339: Property 'setLogLevel' does not exist on type 'Console'\n// exports.handler = async function (event, context, callback) {\n//     // console.setLogLevel('error') 不能写在此会导致编译错误阿里云自己扩展的私有方法\n//     console.log('xxxxx', 'yyyyy', 'zzzzzz')\n//     console.error('xxxxx1', 'yyyyy1', 'zzzzzz1')\n//     let out = '<html><body>zzzzzz</body></html>'\n//     let htmlResponse = {\n//         isBase64Encoded: true,\n//         statusCode: 200,\n//         headers: {\n//             \"Content-type\": \"text/html; charset=utf-8\",\n//         },\n//         // base64 encode body so it can be safely returned as JSON value\n//         body: new Buffer(out as string).toString('base64')\n//     }\n//     callback(null, htmlResponse)\n// }\n\n// 基于阿里云的函数计算统一入口的路由处理\nexports.handler = async function (event, context, callback) {\n    // TODO 增加对于定时器的功能模拟实现\n    // xlog('$$$$=>' + event.toString())\n    // TODO 去除掉换行方便方便SLS上的日志输出排版显示\n    xlog('$$$$=>' + event.toString().replace(/\\r/g, '').replace(/\\n/g, ''))\n\n    let evt = JSON.parse(event.toString())\n\n    // 根据API网关设置的环境常量参数正确配置线上版本的运行环境，取代AONE的本地、日常、预发、灰度等环境部署支持开发。\n    // 全局变量仅仅用于放在整个应用生命周期变量\n    global['__env__'] = _.get(evt, 'headers.__env__', 'prod')\n\n    const __cors__ = {}\n    if (global['__env__'] !== 'prod' && global['__env__'] !== 'gray') {\n        // 非生产环境或灰度环境，需要禁用CORS功能禁止跨域访问增加安全性。\n        if (evt.headers.origin) {\n            // 获取源站动态允许请求跨域 (FIXME 需要进行安全限制对来源服务器网址合法性进行安全限制，本地开发调试全部放开请求)\n            __cors__['Access-Control-Allow-Origin'] = evt.headers.origin\n            // __cors__['Access-Control-Allow-Origin'] = '*' // 不能设置为任意值浏览器有安全限制\n        }\n        __cors__['Access-Control-Allow-Credentials'] = 'true'\n        __cors__['Access-Control-Allow-Headers'] = 'Origin, X-Requested-With, Content-Type, Accept'\n        __cors__['Access-Control-Allow-Methods'] = 'POST, OPTIONS'\n    }\n\n    // 支持跨域的验证请求方法的合法性规避掉过滤掉不安全的请求。\n    switch (evt.httpMethod) {\n        case 'GET':\n        case 'POST':\n            break\n        case 'OPTIONS':\n            if (global['__env__'] == 'prod' || global['__env__'] == 'gray') {\n                // 生产和灰度环境下禁止跨域OPTIONS请求以便于增强安全性\n                callback(null, {\n                    statusCode: 400,\n                })\n            } else {\n                // 非生产和灰度环境下才允许支持跨域OPTIONS请求\n                callback(null, {\n                    statusCode: 200,\n                    headers: {\n                        ...__cors__,\n                    },\n                })\n            }\n            return\n        default:\n            // 禁止任何的非法请求严格进行约定限制\n            callback(null, {\n                statusCode: 400,\n            })\n            return\n    }\n\n    // TODO 需要对于事件定时器进行统一的约定在应用层可扩展自定义相关定时器等事件类型\n    if (evt['triggerName']) {\n        // 对定时触发器的统一拦截处理\n        switch (evt['triggerName']) {\n            case '__axjs-preheat-timer__':\n                // 获取请求参数的配置数据\n                try {\n                    let payload = JSON.parse(evt['payload'])\n                    xassert(payload['url'] && payload['timeout'])\n                    await xpost(payload['url'], payload['param'], undefined, payload['timeout'])\n                } catch (err) {\n                    // ignore error\n                    xlog(JSON.stringify(xerror(err)).replace(/\\r/g, '').replace(/\\n/g, ''))\n                }\n                break\n        }\n        return\n    } else if (evt['path'] === '/__axjs-preheat-timer__') {\n        // 预热api网关的空请求心跳接口实现\n        return\n    }\n    global['__evt__'] = event.toString() // FIXME 需要设计上下文定义请求实例生命周期变量\n    // 先以HEAER中的__api__字段进行识别，如果HEADER中没有定义再使用URL路径对应的PATH识别，以此支持SEO等前端路径重写问题。\n    let __api__ = _.get(evt, 'headers.__api__', evt.path) // 最终控制器与app子目录下的ts文件保持完全的一一映射关系。\n    // 改进为根据API网关的相关参数自动拼接出来正确的URL网址请求路径\n    let __url__ = evt['headers']['X-Forwarded-Proto'] + '://' + evt['headers']['CA-Host'] + evt['path']\n    // 将全部的HEADER信息透传到应用中\n    let __header__ = evt['headers']\n\n    let param = Object.assign(\n        {__api__, __url__, __header__}, // header请求中的两个框架层面上的预定义参数 TODO 需要移除掉并非应用关心的内容\n        evt.pathParameters || {}, // 路由重写参数 domain/[a]/[b]?xxx (可被GET参数覆盖)\n        evt.queryParameters || {} // GET请求参数 domain/path?a=x&b=x\n    )\n    let out = {}\n\n    // // 条件日志打印线上临时问题排查处理（TODO 增加业务逻辑扩展注入的钩子实现）\n    // let xdebug = async (...args) => {\n    //     if (!_.includes(__url__, 'y.alibaba-inc.com')) {\n    //         return\n    //     }\n    //     await xwarn(...args)\n    // }\n    // global['xdebug'] = xdebug // 全局可用\n    // await xdebug({param, evt})\n\n    switch (evt.httpMethod) {\n        case 'GET':\n            break\n        case 'POST':\n            try {\n                // 阿里云API网关的POST请求参数是JSON字符串的BASE64编码所以需要进行转义处理\n                let post = {}\n                if (_.isString(evt.body)) {\n                    let body = evt.body\n                    if (evt.isBase64Encoded) {\n                        body = new Buffer(evt.body, 'base64').toString()\n                    }\n                    post = parse_post_param(evt['headers'], body)\n                }\n                param = Object.assign(param, post) // 用post参数覆盖掉get参数，用于灵活的设置请求参数兼容get和post两种方法方便开发调试。\n            } catch (err) {\n                xlog(err, evt.httpMethod, evt.body)\n                await xwarn(err)\n                // 400\tBad Request\t客户端请求的语法错误，服务器无法理解\n                callback(null, {\n                    statusCode: 400,\n                })\n                return\n            }\n            break\n        default:\n            xlog(evt.httpMethod, evt.body)\n            // 400\tBad Request\t客户端请求的语法错误，服务器无法理解\n            callback(null, {\n                statusCode: 400,\n            })\n            return\n    }\n\n    try {\n        // 解析请求中的cookies数据并转换为JSON对象存储到全局变量中便于后续应用xcookie接口使用\n        let cookie = _.get(evt['headers'], 'Cookie', undefined)\n        if (!cookie) {\n            cookie = _.get(evt['headers'], 'cookie', '')\n        }\n        global['__request_cookies__'] = require('cookie').parse(cookie)\n\n        // 获取use-agent请求头部信息\n        global['__user_agent__'] = evt['headers']['User-Agent']\n        // 获取客户端的IP地址信息\n        global['__client_ip__'] = evt['headers']['X-Real-IP']\n\n        // TODO WEB请求需要对404页面以及ERROR页面进行兼容处理（在framework内部进行细节的错误判断在out中透传status的http的状态吗正确错误返回）\n        // 404\tNot Found 服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置\"您所请求的资源无法找到\"的个性页面\n        // 403\tForbidden\t服务器理解请求客户端的请求，但是拒绝执行此请求（权限验证处理错误）\n        out = await request_process(__api__, param)\n\n        // 处理response的cookies设置\n        let setCookie = {'Set-Cookie': undefined}\n        if (!_.isEmpty(global['__respond_cookies__'])) {\n            setCookie['Set-Cookie'] = _.values(global['__respond_cookies__'])\n        }\n\n        if (global['__redirect_url__']) {\n            callback(null, {\n                statusCode: 302,\n                headers: {\n                    \"Location\": global['__redirect_url__'],\n                    ...setCookie\n                },\n            })\n            global['__redirect_url__'] = undefined\n        }\n        else if (_.isString(out)) {\n            let htmlResponse = {\n                isBase64Encoded: true,\n                statusCode: 200,\n                headers: {\n                    \"Content-type\": \"text/html; charset=utf-8\",\n                    ...setCookie,\n                    ...__cors__,\n                },\n                // base64 encode body so it can be safely returned as JSON value\n                body: new Buffer(out as string).toString('base64')\n            }\n            callback(null, htmlResponse)\n        } else {\n            let jsonResponse = {\n                isBase64Encoded: true,\n                statusCode: 200,\n                headers: {\n                    \"Content-type\": \"application/json\",\n                    ...__cors__,\n                },\n                // base64 encode body so it can be safely returned as JSON value\n                body: new Buffer(JSON.stringify(out)).toString('base64')\n            }\n            callback(null, jsonResponse)\n        }\n    } catch (err) {\n        // 通知框架自身实现逻辑的意外报错（框架自身不论何种情况都应该正常工作，一旦出现此问题大多数情况是框架自身问题或者流量引发的运维问题）\n        await xwarn({\n            __api__, __url__, param, message: err.message, stack: xstack(err)\n        })\n        // 500\tInternal Server Error\t服务器内部错误，无法完成请求\n        callback(null, {statusCode: 500})\n    }\n}\n\n//  API参数的识别逻辑，为普通字符串路径定义与app下的ts文件路由完全一一对应，优先取HEADER中的定义，再取GET中的形参定义或者POST形参定义进行参数请求的覆盖处理。\n//  PARAM请求的参数处理要求为BASE64编码化的JSON字符串。\n//     \"event\": {\n//         \"body\": \"ewoJImFwaSI6ICIvYS9iL2MiLAoJInBhcmFtIjogImFzZGZhc2RmYXNkZiIKfQ==\", => 对应于POST请求数据\n//         \"headers\": {\n//             \"X-Ca-Api-Gateway\": \"B25CD51B-5815-4775-9EAB-6D481BC1AE17\",\n//             \"__api__\": \"/web/mobile/test\",   =》 自定义转义PATH的路径信息对于SEO优化兼容处理（也可以在GET或POST请求中传递对应参数）\n//             \"X-Forwarded-For\": \"42.120.74.88\",\n//             \"Content-Type\": \"application/json\"\n//         },\n//         \"httpMethod\": \"POST\",\n//         \"isBase64Encoded\": true,\n//         \"path\": \"/\", =》 没有意义用于前端根据需要自己进行扩展别名映射处理，后端的控制器不以此为标准，可以对同一个控制器定义N个不同的路径标识。\n//         \"pathParameters\": {},\n//         \"queryParameters\": {} => 对应于GET请求数据\n//     },\n//     \"query\": {},\n//     \"context\": {\n//         \"requestId\": \"B25CD51B-5815-4775-9EAB-6D481BC1AE17\",\n//         \"credentials\": {\n//             \"accessKeyId\": \"\",\n//             \"accessKeySecret\": \"\",\n//             \"securityToken\": \"\"\n//         },\n//         \"function\": {\n//             \"name\": \"test\",\n//             \"handler\": \"index.handler\",\n//             \"memory\": 128,\n//             \"timeout\": 300\n//         },\n//         \"services\": {\n//             \"name\": \"alilang\",\n//             \"logProject\": \"\",\n//             \"logStore\": \"\"\n//         },\n//         \"region\": \"cn-shanghai\",\n//         \"accountId\": \"1734066057689528\"\n//     }\n// }\n\n// 最新版本event的API网关的FC返回数据格式：\n//      CA-Host请求域名、\n//      X-Forwarded-Proto\n//      \"path\": \"/test\", ==》》基本上可以拼接出__url__参数可以省略掉此冗余参数配置了。\n//                       ==》》借助route.map.ts文件的映射关系定义省略掉__api__配置进一步简化网关应用。\n//      \"httpMethod\": \"GET\",\n//      \"isBase64Encoded\": true,\n//      \"X-Forwarded-For\": \"42.120.74.103\", // 客户端请求IP地址用户判定所属区域信息海外访问问题优化依赖点\n//      \"X-Real-IP\": \"42.120.74.103\",\n//      Cookie\n//      User-Agent       =>> PC站和M站自适应问题\n//      Accept-Language  =>> 浏览器客户端的语言类型自动适配多语言架构设计问题\n// let x = {\n//     \"body\": \"\",\n//     \"headers\": {\n//         \"X-Ca-Api-Gateway\": \"B276F77B-334E-4857-AE64-65BAFD419E2A\",\n//         \"Cookie\": \"cna=r5snEzzOvA0CASp4Smdq+II/; UM_distinctid=162bcd61d9111cd-080e0f43e6b60d-33697b04-13c680-162bcd61d92c86; _tb_token_=H8U7BqixF3YVR3GnhMRz; NEW2_ACR_JSESSIONID=VM566F91-K5CP8QIVMQTSAH3C4H5X1-DRIHYJHJ-QE2; _new_cr_session0=1AbLByOMHeZe3G41KYd5WcPdC%2Fi8qvGHUBTK8Fbrfx8Soi%2BHELuxxA6jros7W%2FqC1YtebgB3auEF5lu1SCzUzTkt6v%2FiFeN%2FptbvBRziYEGXSEVhWnUlBR2tfpjrXMnIcfb2%2FwnGkH4vkeMIJ1Bvuw%3D%3D; emplId=149337; hrc_sidebar=open; traceId=7d4b16de-74bc-4eac-884b-54ca0354e4aa; SSO_LANG=ZH-CN; SSO_EMPID_HASH=9db1ed21402f7c36674b5e6e6de1fc68; animate_date=201864; aa=xxxxxxx; cn_1260001221_dplus=%7B%22distinct_id%22%3A%20%22162bcd61d9111cd-080e0f43e6b60d-33697b04-13c680-162bcd61d92c86%22%2C%22sp%22%3A%20%7B%22%24_sessionid%22%3A%200%2C%22%24_sessionTime%22%3A%201528086234%2C%22%24dp%22%3A%200%2C%22%24_sessionPVTime%22%3A%201528086234%7D%7D; isg=BDw8SonyS9utyn5fedYRe-uRDdzwNAD0-51BHha9_ScJ4dxrNkWw77KQxQmZqRi3\",\n//         \"X-Forwarded-Proto\": \"https\",\n//         \"User-Agent\": \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36\",\n//         \"__url__\": \"https://toufang.alibaba-inc.com/test\",\n//         \"CA-Host\": \"toufang.alibaba-inc.com\",\n//         \"Cache-Control\": \"max-age=0\",\n//         \"upgrade-insecure-requests\": \"1\",\n//         \"Accept-Language\": \"zh-CN,zh;q=0.9\",\n//         \"__api__\": \"/web/test/test\",\n//         \"Accept-Encoding\": \"gzip, deflate, br\",\n//         \"X-Forwarded-For\": \"42.120.74.103\",\n//         \"X-Real-IP\": \"42.120.74.103\",\n//         \"Accept\": \"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8\"\n//     },\n//     \"httpMethod\": \"GET\",\n//     \"isBase64Encoded\": true,\n//     \"path\": \"/test\",\n//     \"pathParameters\": {},\n//     \"queryParameters\": {}\n// }\n"]}
\No newline at end of file