topbit 1.0.0 → 3.0.0

package/src/midcore.js

@@ -0,0 +1,213 @@
+'use strict';
+
+class MidCore {
+
+  constructor(options = {}) {
+    this.debug = true;
+    if (options.debug !== undefined) {
+      this.debug = options.debug;
+    }
+
+    this.errorHandle = options.errorHandle;
+    
+    if (typeof this.errorHandle !== 'function') {
+      this.errorHandle = (err, errname) => {
+        this.debug && console.error(errname, err);
+      };
+    }
+
+    this.globalKey = `_GLOBAL_0129_${Math.random().toString(16).substring(2)}_`;
+
+    this.midGroup = {};
+
+    this.midGroup[ this.globalKey ] = [
+      async (ctx) => {
+        if (typeof ctx.requestCall === 'function') {
+          return await ctx.requestCall(ctx);
+        }
+      }
+    ];
+
+    this.stackCache = [];
+  }
+
+  /**
+   * @param {function} midcall 回调函数
+   * @param {array|object|string} 选项
+   */
+  addCache(midcall, options = {}) {
+    this.stackCache.push({
+      callback: midcall,
+      options: options
+    });
+  };
+
+  /**
+   * @param {object} groupTable 路由分组表
+   */
+  addFromCache() {
+    let m = null;
+    while((m = this.stackCache.pop()) !== undefined) {
+      this.add(m.callback, m.options);
+    }
+  };
+
+  //如果某一分组添加时，已经有全局中间件，需要先把全局中间件添加到此分组。
+  initGroup(group, fromGroup='') {
+    this.midGroup[group] = [];
+    let mids = this.midGroup[this.globalKey];
+    
+    /* if (fromGroup && group !== fromGroup && this.midGroup[fromGroup])
+      mids = this.midGroup[fromGroup]; */
+
+    for(let i=0; i < mids.length; i++) {
+      this.midGroup[group].push(mids[i]);
+    }
+  };
+
+  /**
+   * @param {async function} midcall 接受参数(ctx, next)。
+   * @param {string|Array|object} options 选项。
+   * options如果是字符串则表示针对分组添加中间件，如果是数组或正则表达式则表示匹配规则。
+   * 如果你想针对某一分组添加中间件，同时还要设置匹配规则，则可以使用以下形式：
+   * {
+   *   pathname  : string | Array,
+   *   group : string
+   * }
+   */
+  add(midcall, options = {}) {
+    if (typeof midcall === 'object') {
+      if (midcall.mid && typeof midcall.mid === 'function') {
+        
+        midcall = midcall.mid();
+
+      } else if (midcall.middleware
+            && typeof midcall.middleware === 'function'
+            && midcall.middleware.constructor.name === 'AsyncFunction')
+      {
+        midcall = midcall.middleware.bind(midcall);
+      }
+
+    }
+
+    if (typeof midcall !== 'function' || midcall.constructor.name !== 'AsyncFunction') {
+      throw new Error('callback and middleware function must use async');
+    }
+    
+    let pathname = null;
+    let group = null;
+    let method = null;
+    //let from_group = '';
+    if (typeof options === 'string') {
+      if (options[0] === '@') {
+        options = { group: options.substring(1) }
+      } else {
+        options = [options]
+      }
+    }
+
+    if (Array.isArray(options)) {
+      pathname = options;
+    } if (options && typeof options === 'object') {
+      if (options.name !== undefined) {
+        if (typeof options.name === 'string' && options.name.trim()) {
+          pathname = [options.name.trim()];
+        } else if (Array.isArray(options.name) && options.name.length > 0) {
+          pathname = options.name;
+        }
+      }
+
+      if (options.group !== undefined && typeof options.group === 'string') {
+        group = options.group;
+      }
+
+      /* if (options.from && typeof options.from === 'string') {
+        from_group = options.from;
+      } */
+
+      if (options.method !== undefined) {
+        if (typeof options.method === 'string' && options.method.length > 0) {
+          method = [options.method];
+        } else if (Array.isArray(options.method) && options.method.length > 0) {
+          method = options.method;
+        }
+        //请求方法如果传递了小写，都转换为大写。
+        method && method.forEach((m, index) => {
+          method[index] = m.toUpperCase();
+        });
+      }
+    }
+
+    let self = this;
+    let makeRealMid = (prev_mid, grp) => {
+      let nextcall = self.midGroup[grp][prev_mid];
+
+      if (!method && !pathname) {
+        return async (ctx) => { return await midcall(ctx, nextcall); };
+      }
+
+      let methodTable = null;
+      method && (methodTable = {}) && method.forEach(a => { methodTable[a] = true; });
+
+      let nameTable = null;
+      pathname && (nameTable = {}) && pathname.forEach(a => { nameTable[a] = true; });
+
+      if (methodTable && !nameTable) {
+        return async (ctx) => {
+          if (!methodTable[ctx.method]) {
+            return await nextcall(ctx);
+          }
+  
+          return await midcall(ctx, nextcall);
+        }
+      }
+
+      if (!methodTable && nameTable) {
+        return async (ctx) => {
+          if (!nameTable[ctx.name]) {
+            return await nextcall(ctx);
+          }
+
+          return await midcall(ctx, nextcall);
+        }
+      }
+
+      return async (ctx) => {
+        if (!methodTable[ctx.method] || !nameTable[ctx.name]) {
+          return await nextcall(ctx);
+        }
+
+        return await midcall(ctx, nextcall);
+      };
+    };
+
+    let last = 0;
+    if (group) {
+      if (!this.midGroup[group]) {
+        this.initGroup(group);
+        //this.initGroup(group, from_group);
+      }
+      last = this.midGroup[group].length - 1;
+      this.midGroup[group].push(makeRealMid(last, group));
+    } else {
+      //全局添加中间件
+      for (let k in this.midGroup) {
+        last = this.midGroup[k].length - 1;
+        this.midGroup[k].push(makeRealMid(last, k));
+      }
+    }
+    return this;
+  }
+
+  exec(ctx, group='') {
+    if (!group || this.midGroup[group] === undefined) {
+      group = this.globalKey;
+    }
+
+    let last = this.midGroup[group].length - 1;
+    return this.midGroup[group][last](ctx);
+  }
+
+}
+
+module.exports = MidCore;

package/src/middleware1.js

@@ -0,0 +1,103 @@
+/**
+  module middleware1
+  Copyright (C) 2019.08 BraveWang
+ */
+'use strict';
+
+const MidCore = require('./midcore.js');
+
+class Middleware extends MidCore {
+  /**
+   * 执行中间件，其中核心则是请求回调函数。
+   * @param {object} ctx 请求上下文实例。
+   */
+  async run(ctx) {
+    try {
+      await this.exec(ctx, ctx.group);
+    } catch (err) {
+      
+      this.errorHandle(err, '--ERR-res--');
+
+      try {
+        if (ctx.res && !ctx.res.writableEnded) {
+          ctx.res.statusCode = 500;
+          ctx.res.end();
+        }
+      } catch (err) {}
+
+    } finally {
+      ctx.req = null;
+      ctx.res = null;
+      ctx.data = null;
+      ctx.box = null;
+      ctx.service = null;
+      ctx.requestCall = null;
+      ctx.headers = null;
+      ctx.body = null;
+      ctx.rawBody = null;
+      ctx.files = null;
+      ctx.param = null;
+      ctx.user = null;
+      ctx = null;
+    }
+  }
+
+  /** 这是最终添加的请求中间件。基于洋葱模型，这个中间件最先执行，所以最后会返回响应结果。*/
+  /**
+   *
+   * Node 12 开始废除了finished属性。
+   *
+   */
+  addFinal() {
+    let fr = async (ctx, next) => {
+      await next(ctx);
+
+      if (!ctx.res || ctx.res.writableEnded || !ctx.res.writable || ctx.res.destroyed) {
+        return;
+      }
+
+      /**
+       * 如果已经设置了content-type或者消息头已经发送则直接返回
+       */
+      let content_type = 'text/plain;charset=utf-8';
+      let datatype = typeof ctx.data;
+
+      if (!(ctx.res.headersSent || ctx.res.hasHeader('content-type')) )
+      {
+        if (datatype === 'object') {
+          ctx.res.setHeader('content-type','application/json;charset=utf-8');
+        }
+        else if (datatype === 'string' && ctx.data.length > 1) {
+          switch (ctx.data[0]) {
+            case '{':
+            case '[':
+              content_type = 'application/json;charset=utf-8'; break;
+            case '<':
+              if (ctx.data[1] == '!') {
+                content_type = 'text/html;charset=utf-8';
+              }
+              break;
+            default:;
+          }
+          ctx.res.setHeader('content-type', content_type);
+        }
+      }
+
+      if (!ctx.data) {
+        ctx.res.end()
+      } else if (ctx.data instanceof Buffer || datatype === 'string') {
+        ctx.res.end(ctx.data, ctx.dataEncoding)
+      } else if (datatype === 'number') {
+        ctx.res.end(`${ctx.data}`)
+      } else {
+        ctx.res.end(JSON.stringify(ctx.data))
+      }
+
+    }
+
+    this.add(fr)
+  }
+
+}
+
+module.exports = Middleware;

package/src/middleware2.js

@@ -0,0 +1,116 @@
+/**
+  module middleware2
+  Copyright (C) 2019.08 BraveWang
+ */
+'use strict';
+
+const MidCore = require('./midcore.js');
+
+class Middleware extends MidCore {
+
+  /**
+   * 执行中间件，其中核心则是请求回调函数。
+   * @param {object} ctx 请求上下文实例。
+   */
+  async run(ctx) {
+    try {
+      await this.exec(ctx, ctx.group);
+    } catch (err) {
+      
+      this.errorHandle(err, '--ERR-RESPONSE--');
+
+      if (ctx.stream && !ctx.stream.destroyed && ctx.stream.writable) {
+        try {
+          if (!ctx.stream.headersSent) {
+            ctx.stream.respond({
+              ':status' : '500'
+            });
+          }
+          //ctx.stream.close();
+          ctx.stream.end();
+        } catch (err) {}
+      }
+    } finally {
+      ctx.data = null;
+      ctx.dataHeaders = null;
+      ctx.stream = null;
+      ctx.req = null;
+      ctx.res = null;
+      ctx.service = null;
+      ctx.box = null;
+      ctx.requestCall = null;
+      ctx.body = null;
+      ctx.headers = null;
+      ctx.rawBody = null;
+      ctx.files = null;
+      ctx.param = null;
+      ctx.user = null;
+      ctx = null;
+    }
+
+  }
+
+  /** 这是最终添加的请求中间件。基于洋葱模型，这个中间件最先执行，所以最后会返回响应结果。 */
+  addFinal() {
+    let fr = async (ctx, next) => {
+      await next(ctx);
+
+      if(!ctx.stream || ctx.stream.closed || ctx.stream.destroyed || !ctx.stream.writable) {
+        return ;
+      }
+
+      let content_type = 'text/plain;charset=utf-8';
+      let datatype = typeof ctx.data;
+
+      /** 如果还没有发送头部信息，则判断content-type类型，然后返回。 */
+
+      if (!ctx.stream.headersSent) {
+
+        if (!ctx.dataHeaders['content-type']) {
+
+          if (ctx.data instanceof Buffer || datatype === 'number') {
+            ctx.dataHeaders['content-type'] = content_type;
+          }
+          else if (datatype === 'object') {
+            ctx.dataHeaders['content-type'] = 'application/json;charset=utf-8';
+          }
+          else if (datatype === 'string' && ctx.data.length > 1) {
+            switch (ctx.data[0]) {
+              case '{':
+              case '[':
+                content_type = 'application/json;charset=utf-8'; break;
+
+              case '<':
+                if (ctx.data[1] == '!') {
+                  content_type = 'text/html;charset=utf-8';
+                }
+                break;
+
+              default:;
+            }
+
+            ctx.setHeader('content-type', content_type);
+          }
+          
+        }
+
+        ctx.stream.respond(ctx.dataHeaders)
+      }
+
+      if (!ctx.data) {
+        ctx.stream.end()
+      } else if (ctx.data instanceof Buffer || datatype === 'string') {
+        ctx.stream.end(ctx.data, ctx.dataEncoding)
+      } else if (datatype === 'number') {
+        ctx.stream.end(`${ctx.data}`)
+      } else {
+        ctx.stream.end(JSON.stringify(ctx.data))
+      }
+    }
+
+    this.add(fr)
+  }
+
+}
+
+module.exports = Middleware;