topbit 1.0.0 → 3.0.0

package/src/extends/referer.js

@@ -0,0 +1,68 @@
+'use strict';
+
+class Referer {
+  constructor(options = {}) {
+
+    this.allow = [];
+
+    this.failedCode = 404;
+
+    if (typeof options !== 'object') {
+      options = {};
+    }
+
+    for (let k in options) {
+      switch (k) {
+        case 'allow':
+          if (options[k] === '*' || (options[k] instanceof Array)) {
+            this.allow = options[k];
+          }
+          break;
+        
+        case 'failedCode':
+          if (typeof options[k] === 'number' && options[k] >=400 && options[k] < 500)
+            this.failedCode = options[k];
+          break;
+
+      }
+    }
+
+  }
+
+  mid() {
+    let self = this;
+
+    return async (c, next) => {
+
+      if (c.headers.referer === undefined) c.headers.referer = '';
+
+      let stat = false;
+
+      if (self.allow === '*' || self.allow.length === 0 ) {
+        stat = true;
+      }
+      else {
+        let refer = c.headers.referer;
+
+        for (let i = self.allow.length - 1; i >= 0; i--) {
+          if (refer.indexOf(self.allow[i]) === 0) {
+            stat = true;
+            break;
+          }
+        }
+
+      }
+      
+      if (stat) {
+        await next(c);
+      } else {
+        c.status(self.failedCode).to('');
+      }
+
+    };
+
+  }
+
+}
+
+module.exports = Referer;

package/src/extends/resource.js

@@ -0,0 +1,398 @@
+'use strict';
+
+//const fs = require('fs');
+
+const zlib = require('node:zlib')
+const fs = require('node:fs')
+
+const fsp = fs.promises
+
+let _typemap = {
+  '.css'  : 'text/css; charset=utf-8',
+  '.js'   : 'text/javascript; charset=utf-8',
+  '.txt'  : 'text/plain; charset=utf-8',
+  '.json' : 'application/json; charset=utf-8',
+  '.lrc'  : 'text/plain; charset=utf-8',
+  '.md'   : 'text/plain; charset=utf-8',
+  '.html' : 'text/html; charset=utf-8',
+  '.xml'  : 'text/xml; charset=utf-8',
+
+  '.svg'  : 'image/svg+xml',
+  '.jpg'  : 'image/jpeg',
+  '.jpeg' : 'image/jpeg',
+  '.png'  : 'image/png',
+  '.gif'  : 'image/gif',
+  '.ico'  : 'image/x-icon',
+  '.webp' : 'image/webp',
+  '.tif'  : 'image/tiff',
+  '.tiff' : 'image/tiff',
+  '.avif' : 'image/avif',
+  '.apng' : 'image/apng',
+
+  '.mp3'  : 'audio/mpeg',
+  '.flac' : 'audio/flac',
+  '.wav'  : 'audio/x-wav',
+  '.mp4'  : 'video/mp4',
+  '.webm' : 'video/webm',
+
+  '.otf'  : 'font/otf',
+  '.ttf'  : 'font/ttf',
+  '.wtf'  : 'font/wtf',
+  '.woff' : 'font/woff',
+  '.ttc'  : 'font/ttc',
+  '.woff2' : 'font/woff2',
+
+  '.pdf': 'application/pdf',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+}
+
+/**
+ * 处理静态资源的请求，需要把中间件挂载到一个分组下，否则会影响全局，如果一个只做静态分发的服务则可以全局启用。
+ */
+
+class Resource {
+
+  constructor(options = {}) {
+
+    this.cache = new Map()
+
+    this.staticPath = ''
+
+    //最大缓存，单位为字节，0表示不限制。
+    this.maxCacheSize = 128_000_000
+
+    this.size = 0
+
+    //控制释放缓存的概率，1到100
+    this.prob = 6
+
+    //失败缓存统计，当失败缓存计数达到一个阈值，则会清空缓存。
+    this.cacheFailed = 0
+
+    this.failedLimit = 50
+
+    this.compress = true
+
+    this.cacheControl = null
+
+    this.routePath = '/static/*'
+
+    this.prepath = ''
+    
+    this.routeGroup = `__static_${parseInt(Math.random()*10000)}_`
+
+    this.decodePath = false
+
+    this.maxFileSize = 10_000_000
+
+    if (typeof options !== 'object') {
+      options = {}
+    }
+
+    for (let k in options) {
+      switch(k) {
+        case 'staticPath':
+          this.staticPath = options[k]
+          break
+
+        case 'maxCacheSize':
+        case 'maxFileSize':
+          if (typeof options[k] === 'number') {
+            this[k] = options[k]
+          }
+          break
+
+        case 'failedLimit':
+          if (options[k] > 0) {
+            this.failedLimit = options[k]
+          }
+          break
+
+        case 'compress':
+          this.compress = options[k]
+          break
+
+        case 'cacheControl':
+          this.cacheControl = options[k]
+          break
+        
+        case 'routePath':
+          if (typeof options[k] === 'string') {
+            this.routePath = options[k]
+          }
+          break
+
+        case 'routeGroup':
+          if (typeof options[k] === 'string') {
+            this.routeGroup = options[k]
+          }
+          break
+        
+        case 'decodePath':
+          this.decodePath = options[k]
+          break
+
+        case 'prepath':
+          this.prepath = options[k]
+
+          if (this.prepath.length > 0 && this.prepath[0] !== '/') {
+            this.prepath = `/${this.prepath}`
+          }
+          break
+
+        case 'prob':
+          if (typeof options[k] === 'number' && options[k] >= 1 && options[k] <= 100) {
+            this.prob = options[k]
+          }
+          break
+
+      }
+    }
+
+    if (this.maxCacheSize < 10_000_000) {
+      this.maxCacheSize = 10_000_000
+    }
+
+    if (this.maxFileSize < 10000 || this.maxFileSize > 500_000_000) {
+      this.maxFileSize = 10_000_000
+    }
+
+    if (this.staticPath.length > 1 && this.staticPath[ this.staticPath.length-1 ] === '/') {
+      this.staticPath = this.staticPath.substring(0, this.staticPath.length-1)
+    }
+
+    this.ctypeMap = _typemap
+
+    for (let k in this.ctypeMap) {
+      this.ctypeMap[ k.toUpperCase() ] = _typemap[k]
+    }
+
+  }
+
+  addType(tobj) {
+    let lower_name, up_name;
+
+    for (let k in tobj) {
+      lower_name = k.toLowerCase()
+
+      up_name = k.toUpperCase()
+
+      this.ctypeMap[lower_name] = tobj[k]
+
+      this.ctypeMap[up_name] = tobj[k]
+    }
+  }
+
+  extName(filename) {
+    let extind = filename.length - 1
+    let extstart = filename.length - 5
+
+    while (extind > 0 && extind >= extstart) {
+      if (filename[extind] === '.') break
+
+      extind -= 1
+    }
+
+    return filename.substring(extind)
+  }
+
+  filetype(extname) {
+    if (this.ctypeMap[extname] !== undefined) {
+      return this.ctypeMap[extname]
+    }
+
+    return 'application/octet-stream'
+  }
+
+  removeGroupCache(filepre) {
+    let keys = this.cache.keys()
+    for (let k of keys) {
+      if (k.indexOf(filepre) === 0) this.cache.delete(k)
+    }
+  }
+
+  removeNameCache(name) {
+    let keys = this.cache.keys()
+    for (let k of keys) {
+      if (k.lastIndexOf(name) >= 0) this.cache.delete(k)
+    }
+  }
+
+  removeCache(filepath) {
+    if (this.cache.has(filepath)) {
+      this.cache.delete(filepath)
+    }
+  }
+
+  clearCache() {
+    this.size = 0
+    this.cacheFailed = 0
+    this.cache.clear()
+  }
+
+  async pipeData(pathfile, ctx, filesize) {
+    let stm = fs.createReadStream(pathfile)
+    let dataBuffer = []
+    let total = 0
+
+    if (ctx.major === 2) {
+      ctx.sendHeader()
+    }
+
+    return new Promise((rv, rj) => {
+      stm.on('data', data => {
+        if (filesize <= this.maxFileSize) {
+          total += data.length
+          dataBuffer.push(data)
+        }
+      })
+
+      stm.on('error', err => {
+        dataBuffer = null
+        !stm.destroyed && stm.destroy()
+        rj(err)
+      })
+
+      stm.on('end', () => {
+        if (dataBuffer && dataBuffer.length > 0) {
+          let retData = Buffer.concat(dataBuffer, total)
+          dataBuffer = null
+          rv(retData)
+        } else {
+          rv(null)
+        }
+      })
+
+      stm.pipe(ctx.res)
+    })
+
+  }
+
+  mid() {
+    let self = this
+
+    return async (c, next) => {
+      let rpath = c.param.starPath || c.path
+
+      if (rpath[0] !== '/') {
+        rpath = `/${rpath}`
+      }
+
+      let real_path = rpath
+
+      if (self.decodePath) {
+        try {
+          real_path = decodeURIComponent(rpath)
+        } catch (err) {
+          real_path = rpath
+        }
+      }
+
+      let pathfile = `${self.staticPath}${self.prepath}${real_path}`
+  
+      if (self.cache.has(real_path)) {
+        let r = self.cache.get(real_path)
+
+        c.setHeader('content-type', r.type)
+        c.setHeader('content-length', r.data.length)
+        
+        if (r.gzip) {
+          c.setHeader('content-encoding', 'gzip')
+        }
+
+        if (self.cacheControl) {
+          c.setHeader('cache-control', self.cacheControl)
+        }
+
+        return c.to(r.data)
+      }
+
+      let data = null
+
+      let extname = this.extName(pathfile)
+
+      let ctype = self.filetype(extname)
+
+      let zipdata = null
+
+      try {
+        if (ctype.indexOf('text/') === 0
+            || extname === '.json'
+            || ctype.indexOf('font/') === 0)
+        {
+          data = await fsp.readFile(pathfile)
+
+          //若文件很小，压缩后的数据很可能要比源文件还大，所以对超过1k的文件进行压缩，否则不进行压缩。
+          if (data && data.length > 1024) {
+              zipdata = await new Promise((rv, rj) => {
+                  zlib.gzip(data, (err, d) => {
+                    if (err) {
+                      rj(err)
+                    } else {
+                      rv(d)
+                    }
+                  })
+              }).catch(err => {
+                zipdata = null
+              })
+          }
+
+          c.setHeader('content-type', ctype)
+            .setHeader('content-length', zipdata ? zipdata.length : data.length)
+
+          if (zipdata) {
+            c.setHeader('content-encoding', 'gzip')
+          }
+
+          self.cacheControl && c.setHeader('cache-control', self.cacheControl);
+
+          c.sendHeader().to(zipdata || data)
+        } else {
+          let fst = await fsp.stat(pathfile)
+
+          c.setHeader('content-type', ctype).setHeader('content-length', fst.size);
+
+          self.cacheControl && c.setHeader('cache-control', self.cacheControl);
+
+          data = await this.pipeData(pathfile, c, fst.size)
+          //说明数据太大，放弃了缓存
+          if (!data) return;
+        }
+
+        if (self.cacheFailed >= self.failedLimit) {
+          //以{self.prob}%概率决定是否释放缓存。
+          if (parseInt(Math.random() * 100) < self.prob) {
+            self.clearCache()
+          }
+
+        } else if (self.maxCacheSize > 0 && self.size >= self.maxCacheSize) {
+
+          if (self.cacheFailed < 1000_0000)
+            self.cacheFailed++
+
+        } else {
+          self.cache.set(real_path, {
+            data : zipdata || data,
+            type : ctype,
+            gzip : zipdata ? true : false,
+          })
+
+          self.size += zipdata ? zipdata.length : data.length
+        }
+      } catch (err) {
+        c.status(404).to('read file failed')
+      }
+  
+    }
+
+  }
+
+  init(app, group = null) {
+    app.get(this.routePath, async c => {}, {group: group || this.routeGroup})
+    app.use(this.mid(), {group : group || this.routeGroup})
+  }
+
+}
+
+module.exports = Resource

package/src/extends/session.js

@@ -0,0 +1,174 @@
+'use strict'
+
+const fs = require('node:fs')
+const crypto = require('node:crypto')
+
+/*
+  这个模块用于titbit框架的登录会话，调用一定要在cookie中间件之后。
+  整体的过程就是在基于cookie中间件的解析结果，如果检测到cookie中有会话ID
+  则寻找文件并读取数据，解析成JSON对象添加到c.session；如果cookie中
+  没有会话ID或者读取文件失败则创建会话文件并发送Set-Cookie头部信息保存会话ID。
+*/
+
+class Session {
+
+  constructor() {
+    this.expires = false
+    this.domain  = false
+    this.path  = '/'
+    this.sessionDir = '/tmp'
+
+    this.ds = '/'
+
+    if (process.platform.indexOf('win') === 0) {
+      this.ds = '\\'
+      this.sessionDir = 'C:\\Users\\Public\\sess'
+      try {
+        fs.accessSync(this.sessionDir)
+      } catch (err) {
+        fs.mkdirSync(this.sessionDir)
+      }
+    }
+
+    this.prefix = 'titbit_sess_'
+
+    this.sessionKey = 'TITBIT_SESSID'
+
+    this.error = null
+
+  }
+
+  init(app) {
+    let proto = app.httpServ.Content.prototype
+
+    let self = this
+
+    proto.sessionError = function (options={}) {
+      let err = self.error
+      if (options.clear) self.error = null
+      return err
+    }
+
+    proto.setSession = function (key, data) {
+      this._session[key] = data
+      this._sessionState = true
+    }
+
+    proto.getSession = function (key = null) {
+      if (key === null) {
+        return this._session
+      }
+
+      return this._session[key] || null
+    }
+
+    proto.deleteSession = function (key) {
+      delete this._session[key]
+      this._sessionState = true
+    }
+
+    proto.clearSession = function () {
+      this._sessionState = false
+      this._session = {}
+      fs.unlink(this._sessFile, (err) => {
+        err && (self.error = err)
+      })
+    }
+
+  }
+
+  mid() {
+    let self = this
+
+    return async (c, next) => {
+      c._session = {}
+      c._sessionState = false
+      c._sessFile = ''
+
+      let sess_file = ''
+      let sessid = c.cookie[ self.sessionKey ]
+      let sess_state
+
+      if (sessid) {
+        sess_file = `${self.sessionDir}${self.ds}${self.prefix}${sessid}`
+        c._sessFile = sess_file
+
+        await new Promise((rv, rj) => {
+          fs.readFile(sess_file, (err, data) => {
+            if (err) {
+              rj(err)
+            } else {
+              sess_state = true
+              rv(data)
+            }
+          })
+        }).then(data => {
+          c._session = JSON.parse(data)
+        }, err => {
+          sess_state = false
+        }).catch(err => {
+          self.error = err
+        })
+      }
+
+      if (sessid === undefined || sess_state === false) {
+        let org_name = `${c.host}_${Date.now()}__${Math.random()}`
+
+        let hash = crypto.createHash('sha1')
+
+        hash.update(org_name)
+
+        sessid = hash.digest('hex')
+  
+        sess_file = self.prefix + sessid
+  
+        let set_cookie = `${self.sessionKey}=${sessid};`
+
+        if (self.expires) {
+          var t = new Date(Date.now() + self.expires * 1000)
+          set_cookie += `Expires=${t.toString()};`
+        }
+  
+        set_cookie += `Path=${self.path};`
+  
+        if (self.domain) {
+          set_cookie += `Domain=${self.domain}`
+        }
+  
+        let session_path_file = `${self.sessionDir}/${sess_file}`
+
+        c._sessFile = session_path_file
+
+        await new Promise((rv, rj) => {
+          fs.writeFile(session_path_file, '{}', err => {
+            if (err) {
+              rj(err)
+            } else {
+              rv(true)
+            }
+          })
+        }).then(data => {
+          c.setHeader('set-cookie', set_cookie)
+        }, err => {
+          self.error = err
+        })
+
+      }
+
+      await next()
+
+      if (c._sessionState) {
+        let tmpText = JSON.stringify(c._session)
+        fs.writeFile(c._sessFile, tmpText, (err) => {
+          self.error = err
+        })
+      }
+      
+      c._session = null
+    }
+
+  }
+
+}
+
+module.exports = Session

package/src/extends/setfinal.js

@@ -0,0 +1,50 @@
+'use strict'
+
+class SetFinal {
+
+  constructor(options = {}) {
+    
+    this.finalHandle = null
+
+    this.http1Final = null
+
+    this.http2Final = null
+
+    for (let k in options) {
+      
+      switch(k) {
+
+        case 'http1Final':
+        case 'http2Final':
+        case 'finalHandle':
+          if (typeof options[k] === 'function') {
+            this.finalHandle = options[k]
+          }
+          break
+
+      }
+
+    }
+
+  }
+
+  init(app) {
+
+    if (app.config.http2) {
+      this.finalHandle = this.http2Final
+    } else {
+      this.finalHandle = this.http1Final
+    }
+    
+    if (typeof this.finalHandle === 'function' && this.finalHandle.constructor.name === 'AsyncFunction')
+    {
+      app.midware.addFinal = () => {
+        app.midware.add(this.finalHandle)
+      }
+    }
+
+  }
+
+}
+
+module.exports = SetFinal