UNPKG

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