koa-files 2.3.7 → 2.3.8

package/README.md

@@ -5,7 +5,7 @@
 >
 > [![NPM Version][npm-image]][npm-url]
 > [![Download Status][download-image]][npm-url]
-> [![Snyk Vulnerabilities][snyk-image]][snyk-url]
+> [![Languages Status][languages-image]][github-url]
 > ![Node Version][node-image]
 
 ## Installation
@@ -17,13 +17,13 @@ $ npm install koa-files
 ## API
 
 ```js
-const Koa = require('koa');
-const server = require('koa-files');
+import Koa from 'koa';
+import files from 'koa-files';
 
 const app = new Koa();
 
 // Static files server
-app.use(server(root, options));
+app.use(files(root, options));
 ```
 
 - `root` root directory string. nothing above this root directory can be served.
@@ -64,10 +64,8 @@ app.use(server(root, options));
  * @author nuintun
  */
 
-'use strict';
-
-const Koa = require('koa');
-const server = require('koa-files');
+import Koa from 'koa';
+import files from 'koa-files';
 
 const app = new Koa();
 const port = process.env.PORT || 80;
@@ -82,7 +80,7 @@ function httpError(error) {
 }
 
 // Static files server
-app.use(server('tests', { cacheControl: 'public, max-age=31557600' }));
+app.use(files('tests', { cacheControl: 'public, max-age=31557600' }));
 
 // Listen error event
 app.on('error', error => !httpError(error) && console.error(error));
@@ -102,6 +100,6 @@ MIT
 [npm-image]: https://img.shields.io/npm/v/koa-files.svg?style=flat-square
 [npm-url]: https://www.npmjs.org/package/koa-files
 [download-image]: https://img.shields.io/npm/dm/koa-files.svg?style=flat-square
-[snyk-image]: https://img.shields.io/snyk/vulnerabilities/github/nuintun/koa-files.svg?style=flat-square
-[snyk-url]: https://snyk.io/test/github/nuintun/koa-files
+[languages-image]: https://img.shields.io/github/languages/top/nuintun/koa-files?style=flat-square
+[github-url]: https://github.com/nuintun/koa-files
 [node-image]: https://img.shields.io/node/v/koa-files.svg?style=flat-square

package/cjs/Files.cjs

@@ -0,0 +1,389 @@
+/**
+ * @package koa-files
+ * @license MIT
+ * @version 2.3.8
+ * @author nuintun <nuintun@qq.com>
+ * @description A static files serving middleware for koa.
+ * @see https://github.com/nuintun/koa-files#readme
+ */
+
+'use strict';
+
+const etag = require('etag');
+const destroy = require('destroy');
+const fs = require('fs');
+const stream = require('stream');
+const parseRange = require('range-parser');
+const path = require('path');
+const utils = require('./utils.cjs');
+
+function _interopDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+
+const etag__default = /*#__PURE__*/ _interopDefault(etag);
+const destroy__default = /*#__PURE__*/ _interopDefault(destroy);
+const fs__default = /*#__PURE__*/ _interopDefault(fs);
+const parseRange__default = /*#__PURE__*/ _interopDefault(parseRange);
+
+/**
+ * @module Files
+ * @license MIT
+ * @author nuintun
+ */
+/**
+ * @class Files
+ */
+class Files {
+  /**
+   * @constructor
+   * @description Create files service
+   * @param root Files service root
+   * @param options Files service options
+   */
+  constructor(root, options = {}) {
+    this.options = options;
+    this.root = utils.unixify(path.resolve(root));
+  }
+  /**
+   * @private
+   * @method isConditionalGET
+   * @description Check if request is conditional GET
+   * @param context Koa context
+   */
+  isConditionalGET(context) {
+    const { request } = context;
+    return !!(
+      request.get('If-Match') ||
+      request.get('If-None-Match') ||
+      request.get('If-Modified-Since') ||
+      request.get('if-Unmodified-Since')
+    );
+  }
+  /**
+   * @private
+   * @method isPreconditionFailure
+   * @description Check if request precondition failure
+   * @param context Koa context
+   */
+  isPreconditionFailure(context) {
+    const { request, response } = context;
+    // If-Match
+    const match = request.get('If-Match');
+    if (match) {
+      const etag = response.get('ETag');
+      return !etag || (match !== '*' && !utils.isETagFresh(match, etag));
+    }
+    // If-Unmodified-Since
+    const unmodifiedSince = Date.parse(request.get('If-Unmodified-Since'));
+    if (!isNaN(unmodifiedSince)) {
+      const lastModified = Date.parse(response.get('Last-Modified'));
+      return isNaN(lastModified) || lastModified > unmodifiedSince;
+    }
+    return false;
+  }
+  /**
+   * @private
+   * @method isRangeFresh
+   * @description Check if request range fresh
+   * @param context Koa context
+   */
+  isRangeFresh(context) {
+    const { request, response } = context;
+    const ifRange = request.get('If-Range');
+    // No If-Range
+    if (!ifRange) {
+      return true;
+    }
+    // If-Range as etag
+    if (utils.isETag(ifRange)) {
+      const etag = response.get('ETag');
+      return !!(etag && utils.isETagFresh(ifRange, etag));
+    }
+    // If-Range as modified date
+    const lastModified = response.get('Last-Modified');
+    return Date.parse(lastModified) <= Date.parse(ifRange);
+  }
+  /**
+   * @private
+   * @method isIgnore
+   * @description Check if path is ignore
+   * @param path File path
+   */
+  isIgnore(path) {
+    const { ignore } = this.options;
+    return (typeof ignore === 'function' ? ignore(path) : false) === true;
+  }
+  /**
+   * @private
+   * @method parseRange
+   * @description Parse range
+   * @param context Koa context
+   * @param stats File stats
+   */
+  parseRange(context, stats) {
+    const { size } = stats;
+    const { request } = context;
+    // Content-Length
+    let contentLength = size;
+    // Ranges
+    const ranges = [];
+    // Range support
+    if (this.options.acceptRanges !== false) {
+      const range = request.get('Range');
+      // Range fresh
+      if (range && this.isRangeFresh(context)) {
+        // Parse range -1 -2 or []
+        const parsed = parseRange__default.default(size, range, { combine: true });
+        // -1 signals an unsatisfiable range
+        // -2 signals a malformed header string
+        if (parsed === -1 || parsed === -2) {
+          return parsed;
+        }
+        // Ranges ok, support multiple ranges
+        if (parsed.type === 'bytes') {
+          // Set 206 status
+          context.status = 206;
+          // Multiple ranges
+          if (parsed.length > 1) {
+            // Reset content-length
+            contentLength = 0;
+            // Range boundary
+            const boundary = `<${utils.boundaryGenerator()}>`;
+            const suffix = `\r\n--${boundary}--\r\n`;
+            const contentType = `Content-Type: ${context.type}`;
+            context.type = `multipart/byteranges; boundary=${boundary}`;
+            // Map ranges
+            parsed.forEach(({ start, end }, index) => {
+              // The first prefix boundary no \r\n
+              const prefixHead = index > 0 ? '\r\n' : '';
+              const contentRange = `Content-Range: bytes ${start}-${end}/${size}`;
+              const prefix = `${prefixHead}--${boundary}\r\n${contentType}\r\n${contentRange}\r\n\r\n`;
+              // Compute content-length
+              contentLength += end - start + 1 + Buffer.byteLength(prefix);
+              // Cache range
+              ranges.push({ start, end, prefix });
+            });
+            // The last add suffix boundary
+            ranges[ranges.length - 1].suffix = suffix;
+            // Compute content-length
+            contentLength += Buffer.byteLength(suffix);
+          } else {
+            const { start, end } = parsed[0];
+            context.set('Content-Range', `bytes ${start}-${end}/${size}`);
+            // Compute content-length
+            contentLength = end - start + 1;
+            // Cache range
+            ranges.push({ start, end });
+          }
+        }
+      }
+    }
+    // Set Content-Length
+    context.length = contentLength;
+    return ranges.length ? ranges : [{ start: 0 }];
+  }
+  /**
+   * @private
+   * @method setupHeaders
+   * @description Setup headers
+   * @param context Koa context
+   * @param path File path
+   * @param stats File stats
+   */
+  setupHeaders(context, path$1, stats) {
+    const { options } = this;
+    const { toString } = Object.prototype;
+    const { acceptRanges, cacheControl, lastModified } = options;
+    // Set status
+    context.status = 200;
+    // Set Content-Type
+    context.type = path.extname(path$1);
+    // ETag
+    if (options.etag !== false) {
+      // Set ETag
+      context.set('ETag', etag__default.default(stats));
+    }
+    // Accept-Ranges
+    if (acceptRanges !== false) {
+      // Set Accept-Ranges
+      context.set('Accept-Ranges', 'bytes');
+    }
+    // Last-Modified
+    if (lastModified !== false) {
+      // Set mtime utc string
+      context.set('Last-Modified', stats.mtime.toUTCString());
+    }
+    // Cache-Control
+    if (cacheControl && toString.call(cacheControl) === '[object String]') {
+      // Set Cache-Control
+      context.set('Cache-Control', cacheControl);
+    }
+  }
+  /**
+   * @private
+   * @method read
+   * @description Read file
+   * @param path File path
+   * @param range Read range
+   * @param buffer Destination stream
+   * @param end Is destory destination stream after read
+   */
+  read(path, range, buffer, end) {
+    return new Promise((resolve, reject) => {
+      // Create file stream
+      const file = fs__default.default.createReadStream(path, range);
+      // File read stream open
+      if (range.prefix) {
+        file.once('open', () => {
+          // Write prefix boundary
+          buffer.write(range.prefix);
+        });
+      }
+      // File read stream error
+      file.once('error', error => {
+        // Unpipe
+        file.unpipe(buffer);
+        // Destroy file stream
+        destroy__default.default(file);
+        // Reject
+        reject(error);
+      });
+      // File read stream end
+      if (range.suffix) {
+        file.once('end', () => {
+          // Push suffix boundary
+          buffer.write(range.suffix);
+        });
+      }
+      // File read stream close
+      file.once('close', () => {
+        // Unpipe
+        file.unpipe(buffer);
+        // Destroy file stream
+        destroy__default.default(file);
+        // Resolve
+        resolve(true);
+      });
+      // Write data to buffer
+      file.pipe(buffer, { end });
+    });
+  }
+  /**
+   * @private
+   * @method send
+   * @description Send file
+   * @param context Koa context
+   * @param path File path
+   * @param ranges Read ranges
+   */
+  async send(context, path, ranges) {
+    // Ranges length
+    let { length } = ranges;
+    // Set stream body, highWaterMark 64kb
+    const stream$1 = new stream.PassThrough({ highWaterMark: 65536 });
+    // Set response body
+    context.body = stream$1;
+    // Read file ranges
+    try {
+      for (const range of ranges) {
+        await this.read(path, range, stream$1, --length === 0);
+      }
+    } catch (error) {
+      // End stream when read exception
+      stream$1.end();
+    }
+  }
+  /**
+   * @public
+   * @method response
+   * @description Response to koa context
+   * @param context Koa context
+   */
+  async response(context) {
+    const { root } = this;
+    // Only support GET and HEAD (405)
+    if (context.method !== 'GET' && context.method !== 'HEAD') {
+      return false;
+    }
+    // Get path of file
+    const pathname = utils.decodeURI(context.path);
+    const path$1 = pathname === -1 ? pathname : utils.unixify(path.join(root, pathname));
+    // Path -1 or null byte(s)
+    if (path$1 === -1 || path$1.includes('\0')) {
+      return context.throw(400);
+    }
+    // Malicious path (403)
+    if (utils.isOutRoot(path$1, root)) {
+      return false;
+    }
+    // Is ignore path or file (403)
+    if (this.isIgnore(path$1)) {
+      return false;
+    }
+    // File stats
+    let stats;
+    // Get file stats
+    try {
+      stats = await utils.fstat(path$1);
+    } catch (error) {
+      // 404 | 500
+      return false;
+    }
+    // File not exist (404 | 500)
+    if (!stats) {
+      return false;
+    }
+    // Is directory (403)
+    if (stats.isDirectory()) {
+      return false;
+    }
+    // Not a directory but has trailing slash (404)
+    if (utils.hasTrailingSlash(path$1)) {
+      return false;
+    }
+    // Setup headers
+    this.setupHeaders(context, path$1, stats);
+    // Conditional get support
+    if (this.isConditionalGET(context)) {
+      // Request precondition failure
+      if (this.isPreconditionFailure(context)) {
+        return context.throw(412);
+      }
+      // Request fresh (304)
+      if (context.fresh) {
+        // Set status
+        context.status = 304;
+        // Set body null
+        context.body = null;
+        return true;
+      }
+    }
+    // Head request
+    if (context.method === 'HEAD') {
+      // Set content-length
+      context.length = stats.size;
+      // Set body null
+      context.body = null;
+      return true;
+    }
+    // Parsed ranges
+    const ranges = this.parseRange(context, stats);
+    // 416
+    if (ranges === -1) {
+      // Set content-range
+      context.set('Content-Range', `bytes */${stats.size}`);
+      // Unsatisfiable 416
+      return context.throw(416);
+    }
+    // 400
+    if (ranges === -2) {
+      return context.throw(400);
+    }
+    // Send file
+    this.send(context, path$1, ranges);
+    return true;
+  }
+}
+
+module.exports = Files;

package/cjs/index.cjs

@@ -1,7 +1,7 @@
 /**
  * @package koa-files
  * @license MIT
- * @version 2.3.7
+ * @version 2.3.8
  * @author nuintun <nuintun@qq.com>
  * @description A static files serving middleware for koa.
  * @see https://github.com/nuintun/koa-files#readme
@@ -9,7 +9,7 @@
 
 'use strict';
 
-const Send = require('./Send.cjs');
+const Files = require('./Files.cjs');
 
 /**
  * @module index
@@ -22,18 +22,18 @@ const Send = require('./Send.cjs');
  * @param {Options} options
  */
 function server(root, options) {
-    const send = new Send(root, options);
-    if (options && options.defer) {
-        return async (context, next) => {
-            await next();
-            await send.response(context);
-        };
-    }
+  const files = new Files(root, options);
+  if (options && options.defer) {
     return async (context, next) => {
-        if (!(await send.response(context))) {
-            await next();
-        }
+      await next();
+      await files.response(context);
     };
+  }
+  return async (context, next) => {
+    if (!(await files.response(context))) {
+      await next();
+    }
+  };
 }
 
 module.exports = server;