UNPKG

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