UNPKG

49.7 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 evt = JSON.parse(event.toString());
76 // 根据API网关设置的环境常量参数正确配置线上版本的运行环境，取代AONE的本地、日常、预发、灰度等环境部署支持开发。
77 // 全局变量仅仅用于放在整个应用生命周期变量
78 global['__env__'] = _.get(evt, 'headers.__env__', 'prod');
79 __cors__ = {};
80 if (global['__env__'] !== 'prod' && global['__env__'] !== 'gray') {
81 // 非生产环境或灰度环境，需要禁用CORS功能禁止跨域访问增加安全性。
82 if (evt.headers.origin) {
83 // 获取源站动态允许请求跨域 (FIXME 需要进行安全限制对来源服务器网址合法性进行安全限制，本地开发调试全部放开请求)
84 __cors__['Access-Control-Allow-Origin'] = evt.headers.origin;
85 // __cors__['Access-Control-Allow-Origin'] = '*' // 不能设置为任意值浏览器有安全限制
86 }
87 __cors__['Access-Control-Allow-Credentials'] = 'true';
88 __cors__['Access-Control-Allow-Headers'] = 'Origin, X-Requested-With, Content-Type, Accept';
89 __cors__['Access-Control-Allow-Methods'] = 'POST, OPTIONS';
90 }
91 // 支持跨域的验证请求方法的合法性规避掉过滤掉不安全的请求。
92 switch (evt.httpMethod) {
93 case 'GET':
94 case 'POST':
95 break;
96 case 'OPTIONS':
97 if (global['__env__'] == 'prod' || global['__env__'] == 'gray') {
98 // 生产和灰度环境下禁止跨域OPTIONS请求以便于增强安全性
99 callback(null, {
100 statusCode: 501,
101 });
102 }
103 else {
104 // 非生产和灰度环境下才允许支持跨域OPTIONS请求
105 callback(null, {
106 statusCode: 200,
107 headers: __assign({}, __cors__),
108 });
109 }
110 return [2 /*return*/];
111 default:
112 // 禁止任何的非法请求严格进行约定限制
113 callback(null, {
114 statusCode: 502,
115 });
116 return [2 /*return*/];
117 }
118 if (!evt['triggerName']) return [3 /*break*/, 6];
119 _a = evt['triggerName'];
120 switch (_a) {
121 case '__axjs-preheat-timer__': return [3 /*break*/, 1];
122 }
123 return [3 /*break*/, 5];
124 case 1:
125 _c.trys.push([1, 3, , 4]);
126 payload = JSON.parse(evt['payload']);
127 xassert(payload['url'] && payload['timeout']);
128 return [4 /*yield*/, xpost(payload['url'], payload['param'], undefined, payload['timeout'])];
129 case 2:
130 _c.sent();
131 return [3 /*break*/, 4];
132 case 3:
133 err_1 = _c.sent();
134 // ignore error
135 xlog(JSON.stringify(xerror(err_1)).replace(/\r/g, '').replace(/\n/g, ''));
136 return [3 /*break*/, 4];
137 case 4: return [3 /*break*/, 5];
138 case 5: return [2 /*return*/];
139 case 6:
140 if (evt['path'] === '/__axjs-preheat-timer__') {
141 // 预热api网关的空请求心跳接口实现
142 return [2 /*return*/];
143 }
144 _c.label = 7;
145 case 7:
146 global['__evt__'] = event.toString(); // FIXME 需要设计上下文定义请求实例生命周期变量
147 __api__ = _.get(evt, 'headers.__api__', evt.path) // 最终控制器与app子目录下的ts文件保持完全的一一映射关系。
148 ;
149 __url__ = evt['headers']['X-Forwarded-Proto'] + '://' + evt['headers']['CA-Host'] + evt['path'];
150 __header__ = evt['headers'];
151 param = Object.assign({ __api__: __api__, __url__: __url__, __header__: __header__ }, // header请求中的两个框架层面上的预定义参数 TODO 需要移除掉并非应用关心的内容
152 evt.pathParameters || {}, // 路由重写参数 domain/[a]/[b]?xxx (可被GET参数覆盖)
153 evt.queryParameters || {} // GET请求参数 domain/path?a=x&b=x
154 );
155 out = {};
156 _b = evt.httpMethod;
157 switch (_b) {
158 case 'GET': return [3 /*break*/, 8];
159 case 'POST': return [3 /*break*/, 9];
160 }
161 return [3 /*break*/, 13];
162 case 8: return [3 /*break*/, 14];
163 case 9:
164 _c.trys.push([9, 10, , 12]);
165 post = {};
166 if (_.isString(evt.body)) {
167 body = evt.body;
168 if (evt.isBase64Encoded) {
169 body = new Buffer(evt.body, 'base64').toString();
170 }
171 post = init_1.parse_post_param(evt['headers'], body);
172 }
173 param = Object.assign(param, post); // 用post参数覆盖掉get参数，用于灵活的设置请求参数兼容get和post两种方法方便开发调试。
174 return [3 /*break*/, 12];
175 case 10:
176 err_2 = _c.sent();
177 xlog(err_2, evt.httpMethod, evt.body);
178 return [4 /*yield*/, xwarn(err_2)
179 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
180 ];
181 case 11:
182 _c.sent();
183 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
184 callback(null, {
185 statusCode: 503,
186 });
187 return [2 /*return*/];
188 case 12: return [3 /*break*/, 14];
189 case 13:
190 xlog(evt.httpMethod, evt.body);
191 // 400 Bad Request 客户端请求的语法错误，服务器无法理解
192 callback(null, {
193 statusCode: 504,
194 });
195 return [2 /*return*/];
196 case 14:
197 _c.trys.push([14, 16, , 18]);
198 cookie = _.get(evt['headers'], 'Cookie', undefined);
199 if (!cookie) {
200 cookie = _.get(evt['headers'], 'cookie', '');
201 }
202 global['__request_cookies__'] = require('cookie').parse(cookie);
203 // 获取use-agent请求头部信息
204 global['__user_agent__'] = evt['headers']['User-Agent'];
205 // 获取客户端的IP地址信息
206 global['__client_ip__'] = evt['headers']['X-Real-IP'];
207 return [4 /*yield*/, init_1.request_process(__api__, param)
208 // 处理response的cookies设置
209 ];
210 case 15:
211 // TODO WEB请求需要对404页面以及ERROR页面进行兼容处理（在framework内部进行细节的错误判断在out中透传status的http的状态吗正确错误返回）
212 // 404 Not Found 服务器无法根据客户端的请求找到资源（网页）。通过此代码，网站设计人员可设置"您所请求的资源无法找到"的个性页面
213 // 403 Forbidden 服务器理解请求客户端的请求，但是拒绝执行此请求（权限验证处理错误）
214 out = _c.sent();
215 setCookie = { 'Set-Cookie': undefined };
216 if (!_.isEmpty(global['__respond_cookies__'])) {
217 setCookie['Set-Cookie'] = _.values(global['__respond_cookies__']);
218 }
219 if (global['__redirect_url__']) {
220 callback(null, {
221 statusCode: 302,
222 headers: __assign({ "Location": global['__redirect_url__'] }, setCookie),
223 });
224 global['__redirect_url__'] = undefined;
225 }
226 else if (_.isString(out)) {
227 htmlResponse = {
228 isBase64Encoded: true,
229 statusCode: 200,
230 headers: __assign({ "Content-type": "text/html; charset=utf-8" }, setCookie, __cors__),
231 // base64 encode body so it can be safely returned as JSON value
232 body: new Buffer(out).toString('base64')
233 };
234 callback(null, htmlResponse);
235 }
236 else {
237 jsonResponse = {
238 isBase64Encoded: true,
239 statusCode: 200,
240 headers: __assign({ "Content-type": "application/json" }, __cors__),
241 // base64 encode body so it can be safely returned as JSON value
242 body: new Buffer(JSON.stringify(out)).toString('base64')
243 };
244 callback(null, jsonResponse);
245 }
246 return [3 /*break*/, 18];
247 case 16:
248 err_3 = _c.sent();
249 // 通知框架自身实现逻辑的意外报错（框架自身不论何种情况都应该正常工作，一旦出现此问题大多数情况是框架自身问题或者流量引发的运维问题）
250 return [4 /*yield*/, xwarn({
251 __api__: __api__, __url__: __url__, param: param, message: err_3.message, stack: xstack(err_3)
252 })
253 // 500 Internal Server Error 服务器内部错误，无法完成请求
254 ];
255 case 17:
256 // 通知框架自身实现逻辑的意外报错（框架自身不论何种情况都应该正常工作，一旦出现此问题大多数情况是框架自身问题或者流量引发的运维问题）
257 _c.sent();
258 // 500 Internal Server Error 服务器内部错误，无法完成请求
259 callback(null, { statusCode: 505 });
260 return [3 /*break*/, 18];
261 case 18: return [2 /*return*/];
262 }
263 });
264 });
265};
266// API参数的识别逻辑，为普通字符串路径定义与app下的ts文件路由完全一一对应，优先取HEADER中的定义，再取GET中的形参定义或者POST形参定义进行参数请求的覆盖处理。
267// PARAM请求的参数处理要求为BASE64编码化的JSON字符串。
268// "event": {
269// "body": "ewoJImFwaSI6ICIvYS9iL2MiLAoJInBhcmFtIjogImFzZGZhc2RmYXNkZiIKfQ==", => 对应于POST请求数据
270// "headers": {
271// "X-Ca-Api-Gateway": "B25CD51B-5815-4775-9EAB-6D481BC1AE17",
272// "__api__": "/web/mobile/test", =》 自定义转义PATH的路径信息对于SEO优化兼容处理（也可以在GET或POST请求中传递对应参数）
273// "X-Forwarded-For": "42.120.74.88",
274// "Content-Type": "application/json"
275// },
276// "httpMethod": "POST",
277// "isBase64Encoded": true,
278// "path": "/", =》 没有意义用于前端根据需要自己进行扩展别名映射处理，后端的控制器不以此为标准，可以对同一个控制器定义N个不同的路径标识。
279// "pathParameters": {},
280// "queryParameters": {} => 对应于GET请求数据
281// },
282// "query": {},
283// "context": {
284// "requestId": "B25CD51B-5815-4775-9EAB-6D481BC1AE17",
285// "credentials": {
286// "accessKeyId": "",
287// "accessKeySecret": "",
288// "securityToken": ""
289// },
290// "function": {
291// "name": "test",
292// "handler": "index.handler",
293// "memory": 128,
294// "timeout": 300
295// },
296// "services": {
297// "name": "alilang",
298// "logProject": "",
299// "logStore": ""
300// },
301// "region": "cn-shanghai",
302// "accountId": "1734066057689528"
303// }
304// }
305// 最新版本event的API网关的FC返回数据格式：
306// CA-Host请求域名、
307// X-Forwarded-Proto
308// "path": "/test", ==》》基本上可以拼接出__url__参数可以省略掉此冗余参数配置了。
309// ==》》借助route.map.ts文件的映射关系定义省略掉__api__配置进一步简化网关应用。
310// "httpMethod": "GET",
311// "isBase64Encoded": true,
312// "X-Forwarded-For": "42.120.74.103", // 客户端请求IP地址用户判定所属区域信息海外访问问题优化依赖点
313// "X-Real-IP": "42.120.74.103",
314// Cookie
315// User-Agent =>> PC站和M站自适应问题
316// Accept-Language =>> 浏览器客户端的语言类型自动适配多语言架构设计问题
317// let x = {
318// "body": "",
319// "headers": {
320// "X-Ca-Api-Gateway": "B276F77B-334E-4857-AE64-65BAFD419E2A",
321// "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",
322// "X-Forwarded-Proto": "https",
323// "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",
324// "__url__": "https://toufang.alibaba-inc.com/test",
325// "CA-Host": "toufang.alibaba-inc.com",
326// "Cache-Control": "max-age=0",
327// "upgrade-insecure-requests": "1",
328// "Accept-Language": "zh-CN,zh;q=0.9",
329// "__api__": "/web/test/test",
330// "Accept-Encoding": "gzip, deflate, br",
331// "X-Forwarded-For": "42.120.74.103",
332// "X-Real-IP": "42.120.74.103",
333// "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8"
334// },
335// "httpMethod": "GET",
336// "isBase64Encoded": true,
337// "path": "/test",
338// "pathParameters": {},
339// "queryParameters": {}
340// }
341//# 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: 501,\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: 502,\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: 503,\n                })\n                return\n            }\n            break\n        default:\n            xlog(evt.httpMethod, evt.body)\n            // 400\tBad Request\t客户端请求的语法错误，服务器无法理解\n            callback(null, {\n                statusCode: 504,\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: 505})\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