expediate 0.0.1 → 0.0.3

package/.gitignore

@@ -0,0 +1,14 @@
+# Git ignore
+# ------------------------
+*
+!*/
+# ------------------------
+
+node_modules/
+!*.js
+!*.html
+!package.json
+!.git*
+!.npm*
+!dist/**/*
+

package/.npmignore

@@ -0,0 +1,14 @@
+# Npm ignore
+# ------------------------
+*
+!*/
+# ------------------------
+
+node_modules/
+!*.js
+!*.html
+!package.json
+!.git*
+!.npm*
+!dist/**/*
+

package/README.md

@@ -6,10 +6,11 @@ however it doesn't intent to provide all the features.
 
   [![NPM Version][npm-image]][npm-url]
   [![NPM Downloads][downloads-image]][downloads-url]
+<!--
   [![Linux Build][travis-image]][travis-url]
   [![Windows Build][appveyor-image]][appveyor-url]
   [![Test Coverage][coveralls-image]][coveralls-url]
-
+ -->
 ```js
 const expediate = require('expediate')
 const app = expediate()
@@ -21,6 +22,10 @@ app.get('/', function (req, res) {
 app.listen(3000)
 ```
 
+The main reason for this package is that expressjs grow to become extra
+complicated with tons of dependencies. Expediate aims to keep thing simple
+while retaining the most widely used features.
+
 ## Installation
 
 This is a [Node.js](https://nodejs.org/en/) module available through the
@@ -38,6 +43,29 @@ Installation is done using the
 $ npm install expediate
 ```
 
+## Usage
+
+
+### Middleware
+
+ json => Parse Json body
+ static => Serve static files
+ urlencdeded => Parse url encoded
+
+```js
+var apiApp = expediate()
+apiApp.use('/myEndpoint', ...)
+
+var app = expediate();
+var app.use('/api', apiApp);
+
+app.listen(80)
+app.listen(443, { key: 'xx', cert: 'xx' })
+apiApp.listen(8900) // Only api
+```
+
+
+
 ## License
 
   [MIT](LICENSE)

package/index.js

@@ -20,9 +20,9 @@
  */
 'use strict';
 
-const http = require('http'), https = require('https');
-
-const Router = {};
+const http = require('http'),
+  https = require('https'),
+  serv = require('./static.js');
 
 /**
  * Prepare an layer object to define a new route
@@ -32,14 +32,18 @@ const Router = {};
  * @param {Listener} listener
  * @return {Layer}
  */
-Router.buildLayer = function (method, path, listener) {
+function buildRouteLayer(method, path, listener) {
   if (method)
     method = method.toUpperCase();
-  if (typeof path === 'function') {
+  if (typeof path !== 'string' && !(path instanceof RegExp)) {
     listener = path;
     path = '/';
   }
-  let parts = path.split('/').filter(x => x.length > 0);
+  let parts = path instanceof RegExp ? null : path.split('/').filter(x => x.length > 0);
+  if (listener && typeof listener !== 'function')
+    listener = listener.listener // Route object
+  if (typeof listener !== 'function')
+    throw new TypeError('Incorrect listener type');
   return { method, path, parts, listener };
 };
 
@@ -54,14 +58,28 @@ Router.buildLayer = function (method, path, listener) {
  * @param {String[]} parts
  * @return {Bool}
  */
-Router.matchLayer = function (layer, req, parts) {
+function matchRouteLayer(layer, req, parts, path) {
   if (layer.method && layer.method != req.method)
     return false;
   let params = {}
   for (let i = 0; ; ++i) {
+    if (layer.parts == null) {
+      var m = layer.path.exec(path);
+      if (m == null)
+        return false;
+      for (let i = 1; i < m.length; ++i)
+        params[i] = m[i];
+      req.path = m.index == 0 ? path.replace(m[0], '') : path;
+      req.queries.route = params;
+      for (var k in params)
+        req.params[k] = params[k];
+      return true;
+    }
     if (layer.parts.length <= i) {
       req.path = '/' + parts.slice(i).join('/');
       req.queries.route = params;
+      for (var k in params)
+        req.params[k] = params[k];
       return true;
     } else if (parts.length <= i)
       return false;
@@ -79,12 +97,13 @@ Router.matchLayer = function (layer, req, parts) {
  * @param {http.ClientRequest} req
  * @param {http.ServerResponse} res
  */
-Router.updateReq = function (req, res) {
+function updateHttpObject(req, res) {
   if (req.queries)
     return
   req.queries = {};
 
   let qry = new URL(`http://${req.headers.host}${req.url}`)
+  req.originalUrl = req.url;
   req.path = qry.pathname
 
   // Parse URL-encoded data
@@ -92,21 +111,19 @@ Router.updateReq = function (req, res) {
   for(var pair of qry.searchParams.entries())
     params[pair[0]] = pair[1];
   req.queries.url = params;
+  req.params = params;
 
   // Parse cookies
   if (req.cookies == null) {
     req.cookies = {};
-    var cookies = req.headers.cookie;
-    if (cookies) {
-      cookies = cookies.split(';')
+    if (req.headers.cookie) {
+      const dico = req.headers.cookie.split(';')
         .map(x => x.replace(/^\s+|\s+$/g, '').split('='));
-      for (var k in cookies) {
-        let key = cookies[k][0]
-        let val = cookies[k][1]
+      for (var k in dico) {
+        let key = dico[k][0]
+        let val = dico[k][1]
         req.cookies[key] = val;
-        if (typeof val == 'string') {
-          // TODO s: Cookie is signed, j: Cookie is a JSON
-        }
+        // TODO s: Cookie is signed, j: Cookie is a JSON
       }
     }
   }
@@ -115,15 +132,16 @@ Router.updateReq = function (req, res) {
   res.setHeader('X-Powered-By', 'Expediate');
 
   res.send = (data) => {
-    res.write(data);
+    if (data)
+      res.write(data);
     res.end();
   }
 
   res.status = (code, headers) => {
+    res.statusCode = code;
     if (headers)
       for (var k in headers)
         res.setHeader(k, headers[k])
-    res.writeHead(code)
     return res;
   };
 
@@ -157,62 +175,22 @@ Router.updateReq = function (req, res) {
 
     if (opts.path == null)
       opts.path = '/';
+    txt += `; Path=${opts.path}`
 
     res.setHeader('Set-Cookie', txt);
     return res;
   };
 
-  res.sendFile = function sendFile(path, options, callback) {
-    var done = callback;
-    var req = this.req;
-    var res = this;
-    var next = req.next;
-    var opts = options || {};
-
-    if (!path) {
-      throw new TypeError('path argument is required to res.sendFile');
-    }
-
-    if (typeof path !== 'string') {
-      throw new TypeError('path must be a string to res.sendFile')
-    }
-
-    // support function as second arg
-    if (typeof options === 'function') {
-      done = options;
-      opts = {};
-    }
-
-    if (!opts.root && !isAbsolute(path)) {
-      throw new TypeError('path must be absolute or specify root to res.sendFile');
-    }
-
-    // create file stream
-    var pathname = encodeURI(path);
-    var file = send(req, pathname, opts);
-
-    // transfer
-    sendfile(res, file, opts, function (err) {
-      if (done) return done(err);
-      if (err && err.code === 'EISDIR') return next();
-
-      // next() all but write errors
-      if (err && err.code !== 'ECONNABORTED' && err.syscall !== 'write') {
-        next(err);
-      }
-    });
-  };
-
 };
 
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
-module.exports = NewRouter;
+module.exports = Router;
 
 /**
  * This function create a new router function as a web listener.
  */
-function NewRouter() {
+function Router() {
 
   const routes = [];
 
@@ -220,13 +198,13 @@ function NewRouter() {
     const method = req.method;
     const url = req.url;
     let idx = 0;
-    Router.updateReq(req, res);
+    updateHttpObject(req, res);
     const parts = req.path.split('/').filter(x => x.length > 0);
 
     const next = () => {
       while (idx < routes.length) {
         let layer = routes[idx++];
-        if (Router.matchLayer(layer, req, parts))
+        if (matchRouteLayer(layer, req, parts, req.path))
           return layer.listener(req, res, next);
       }
 
@@ -243,19 +221,23 @@ function NewRouter() {
     }
   };
 
-  listener.use = (p, l) => routes.push(Router.buildLayer(null, p, l));
-  listener.all = (p, l) => routes.push(Router.buildLayer(null, p, l));
-  listener.get = (p, l) => routes.push(Router.buildLayer('GET', p, l));
-  listener.put = (p, l) => routes.push(Router.buildLayer('PUT', p, l));
-  listener.post = (p, l) => routes.push(Router.buildLayer('POST', p, l));
-  listener.delete = (p, l) => routes.push(Router.buildLayer('DELETE', p, l));
-  listener.patch = (p, l) => routes.push(Router.buildLayer('PATCH', p, l));
-
-  listener.listen = (port, opts) => {
+  listener.use = (p, l) => routes.push(buildRouteLayer(null, p, l));
+  listener.all = (p, l) => routes.push(buildRouteLayer(null, p, l));
+  listener.get = (p, l) => routes.push(buildRouteLayer('GET', p, l));
+  listener.put = (p, l) => routes.push(buildRouteLayer('PUT', p, l));
+  listener.post = (p, l) => routes.push(buildRouteLayer('POST', p, l));
+  listener.delete = (p, l) => routes.push(buildRouteLayer('DELETE', p, l));
+  listener.patch = (p, l) => routes.push(buildRouteLayer('PATCH', p, l));
+
+  listener.listen = (port, opts, cb) => {
+    if (typeof opts === 'function') {
+      cb = opts;
+      opts = null;
+    }
     if (opts && opts.key && opts.cert)
-      https.createServer(opts, listener).listen(port);
+      https.createServer(opts, listener).listen(port, cb);
     else
-      http.createServer(listener).listen(port);
+      http.createServer(listener).listen(port, cb);
   };
 
   return listener;
@@ -263,7 +245,7 @@ function NewRouter() {
 
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 
-NewRouter.logger = () => {
+Router.logger = () => {
   return (req, res, next) => {
     const nclr = '\x1b[0m';
     const colors = [
@@ -282,18 +264,37 @@ NewRouter.logger = () => {
       const user = req.session ? `${req.session.username}/${req.session.ssid}` : '-'
       const status = `${clr}${res.statusCode}${nclr}`
       const elp = `${req.elapsed} ms`
-      console.log(`${rec} ${status} ${req.method} ${path} ${ip} <${user}> ${elp}`);
+      const len = res.getHeader('content-length') ? res.getHeader('content-length') : '-';
+      console.log(`${rec} ${status} ${req.method} ${path} ${ip} <${user}> ${elp} (${len})`);
     })
     next();
   };
 };
 
-// NewRouter.static = (root) => {
-//   return (req, res, next) => {
-//   };
-// };
+Router.parseBody = () => {
+  return (req, res, next) => {
+    let data = '';
+    req.on('data', chunk => {
+        data += chunk;
+    });
+    req.on('end', () => {
+        try {
+            req.body = JSON.parse(data);
+        } catch {
+            req.body = data;
+        }
+        next();
+    });
+  }
+}
+
+Router.static = serv.serveStatic;
+Router.file = serv.serveFile;
+Router.sendFile = serv.sendFile;
+Router.sendIndex = serv.sendIndex;
+
 
-NewRouter.session = (opts) => {
+Router.session = (opts) => {
   return (req, res, next) => {
     let ssid = req.cookies.ssid;
     req.session = opts.openSession(ssid);

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "expediate",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Fast and simple, minimalist web framework",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "Fabien Bavent <fabien.bavet@gmail.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "mime": "^1.6.0"
+  }
 }

package/sample.js

@@ -0,0 +1,9 @@
+
+const expediate = require('./index.js')
+    app = expediate();
+
+
+app.use('/', expediate.logger())
+app.use('/', expediate.static('.'))
+app.listen(80)
+

package/static.js

@@ -0,0 +1,416 @@
+/* Copyright 2021 Fabien Bavent
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+
+const fs = require('fs'),
+    path = require('path');
+const mime = require('mime');
+
+// Regular expression to match a path with a directory up component.
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/
+
+const HTTP = {
+  NOT_MODIFIED: res => httpSend(res, 304),
+  FORBIDDEN: res => httpSend(res, 403, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Forbidden'),
+  NOT_FOUND: res => httpSend(res, 404, {
+        // 'Content-Type': 'text/html; charset=UTF-8',
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Not Found'),
+  NOT_ALLOWED: res => httpSend(res, 405, { 'Allow': 'GET, HEAD' }),
+  PRECONDITION_FAILS: res => httpSend(res, 412, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Precondition Failed'),
+  INTERNAL_ERROR: (res, err) => httpSend(res, 500, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, `Internal error: ${err}`),
+};
+
+// Destroy a read stream properly
+function destroyReadStream(stream) {
+  stream.destroy()
+  if (typeof stream.close === 'function') {
+    // node.js core bug work-around
+    stream.on('open', _ => {
+      if (typeof stream.fd === 'number')
+        stream.close()
+    })
+  }
+}
+
+function removeContentHeaders(res) {
+  var keys = Object.keys(res.getHeaders() || {});
+  for (let key of keys) {
+    if (key.substr(0, 8) === 'content-' && key != 'content-location')
+      res.removeHeader(key)
+  }
+}
+
+// Create a simple ETag based on file metadata
+function createETag(stat) {
+  var mtime = stat.mtime.getTime().toString(16)
+  var size = stat.size.toString(16)
+  return 'W/"' + size + '-' + mtime + '"'
+}
+
+// Basic utility for default answers
+function httpSend (res, code, headers, body) {
+  headers = headers || {}
+  body = body || ''
+  res.statusCode = code;
+  for (let k in headers)
+    res.setHeader(k.toString(), headers[k].toString())
+  res.setHeader('Content-Length', Buffer.byteLength(body))
+  if (body)
+    res.write(body);
+  res.end();
+}
+
+// Parse a HTTP token list.
+function parseTokenList (str) {
+  var end = 0
+  var list = []
+  var start = 0
+
+  // gather tokens
+  for (var i = 0, len = str.length; i < len; i++) {
+    switch (str.charCodeAt(i)) {
+      case 0x20: /*   */
+        if (start === end) {
+          start = end = i + 1
+        }
+        break
+      case 0x2c: /* , */
+        list.push(str.substring(start, end))
+        start = end = i + 1
+        break
+      default:
+        end = i + 1
+        break
+    }
+  }
+
+  // final token
+  list.push(str.substring(start, end))
+
+  return list
+}
+
+// Parse an HTTP Date into a number.
+function parseHttpDate (date) {
+  var timestamp = date && Date.parse(date)
+
+  return typeof timestamp === 'number'
+    ? timestamp
+    : NaN
+}
+
+function hasCondition(req) {
+  return req['if-match'] ||
+    req['if-unmodified-since'] ||
+    req['if-none-match'] ||
+    req['if-modified-since']
+}
+
+function conditionMatch(req, res) {
+
+  // if-match
+  const match = req['if-match']
+  if (match) {
+    const etag = res['etag']
+    if (match === etag || match === '*')
+      return true;
+    for (let tag of parseTokenList(match))
+      if (match === tag || match === 'W/' + tag || 'W/' + match === tag)
+        return true;
+  }
+
+  // if-unmodified-since
+  const lastModified = parseHttpDate(res['last-modified'])
+  const unmodifiedSince = parseHttpDate(req['if-modified-since'])
+  if (!isNaN(unmodifiedSince) && !isNaN(lastModified))
+    return lastModified <= unmodifiedSince
+
+
+  return false
+}
+
+// Check freshness of the response using request and response headers.
+function isCacheFresh (req, res) {
+  const CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/
+  // fields
+  var modifiedSince = req['if-modified-since']
+  var noneMatch = req['if-none-match']
+
+  // unconditional request
+  if (!modifiedSince && !noneMatch) {
+    return false
+  }
+
+  // Always return stale when Cache-Control: no-cache
+  // to support end-to-end reload requests
+  // https://tools.ietf.org/html/rfc2616#section-14.9.4
+  var cacheControl = req['cache-control']
+  if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) {
+    return false
+  }
+
+  // if-none-match
+  if (noneMatch && noneMatch !== '*') {
+    var etag = res['etag']
+
+    if (!etag) {
+      return false
+    }
+
+    var etagStale = true
+    var matches = parseTokenList(noneMatch)
+    for (var i = 0; i < matches.length; i++) {
+      var match = matches[i]
+      if (match === etag || match === 'W/' + etag || 'W/' + match === etag) {
+        etagStale = false
+        break
+      }
+    }
+
+    if (etagStale) {
+      return false
+    }
+  }
+
+  // if-modified-since
+  if (modifiedSince) {
+    var lastModified = res['last-modified']
+    var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince))
+
+    if (modifiedStale) {
+      return false
+    }
+  }
+
+  return true
+}
+
+function sendFile(req, res, pathname, stat, opts) {
+  const len = stat.size
+  const etag = createETag(stat)
+
+  if (opts.setHeaders)
+    opts.setHeaders(res);
+
+  // set cache-control
+  if (!res.getHeader('Cache-Control') && opts.maxage) {
+    var cacheControl = 'public, max-age=' + Math.floor(opts.maxage / 1000)
+    if (opts.immutable === true)
+      cacheControl += ', immutable'
+    res.setHeader('Cache-Control', cacheControl)
+  }
+
+  if (!res.getHeader('Last-Modified') && opts.lastModified !== false)
+    res.setHeader('Last-Modified', stat.mtime.toUTCString())
+
+  if (!res.getHeader('ETag') && opts.etag !== false)
+    res.setHeader('ETag', etag)
+
+  // set content-type
+  if (!res.getHeader('Content-Type')) {
+    if (opts.contentType) {
+      res.setHeader('Content-Type', opts.contentType)
+    } else {
+      var type = mime.lookup(pathname)
+      if (type) {
+        var charset = mime.charsets.lookup(type)
+        if (charset)
+          res.setHeader('Content-Type', type + '; charset=' + charset)
+        else
+          res.setHeader('Content-Type', type)
+      }
+    }
+  }
+
+  // Conditionnal GET
+  if (hasCondition(req.headers)) {
+    if (conditionMatch(req.headers, res.getHeaders())) {
+
+      if (isCacheFresh(req.headers, res.getHeaders())) {
+        removeContentHeaders(res);
+        return HTTP.NOT_MODIFIED(res);
+      }
+    }
+    // return HTTP.PRECONDITION_FAILS(res)
+  }
+
+
+  // Send data
+  res.setHeader('Content-Length', len)
+  if (req.method === 'HEAD')
+    return res.end()
+
+  let finished = false
+  const stream = fs.createReadStream(pathname);
+  res.on('finish', _ => {
+    finished = true;
+    destroyReadStream(stream);
+  });
+  stream.on('error', err => {
+    if (finished) return;
+    console.warn('static error', pathname, err)
+    HTTP.INTERNAL_ERROR(res, err.code);
+    finished = true;
+    destroyReadStream(stream);
+  });
+  stream.on('end', _ => {
+    res.end();
+  });
+  stream.pipe(res);
+}
+
+function sendIndex(req, res, pathname, stat, opts) {
+
+  var p = path.join(pathname, 'index.html')
+  fs.stat(p, function (err, stat) {
+    if (err) {
+      if (err.code == 'ENOENT' || err.code == 'ENAMETOOLONG' || err.code == 'ENOTDIR') {
+        if (opts.fallthrough)
+          return next();
+        return HTTP.NOT_FOUND(res)
+      }
+      return HTTP.INTERNAL_ERROR(res, err.code);
+    }
+
+    // index file support
+    if (stat.isDirectory()) {
+      return HTTP.NOT_FOUND(res);
+    }
+
+    sendFile(req, res, p, stat, opts)
+  })
+}
+
+function serveOptions(root, options) {
+
+  if (!root)
+    throw new TypeError('root path required')
+  else if (typeof root !== 'string')
+    throw new TypeError('root path must be a string')
+
+  // copy options
+  var opts = options || {
+    fallthrough: true,
+    redirect: false,
+  };
+  opts.fallthrough = opts.fallthrough !== false
+  opts.redirect = opts.redirect !== false
+  opts.maxage = opts.maxage || opts.maxAge || 0
+  opts.root = path.resolve(root)
+  if (opts.setHeaders && typeof opts.setHeaders !== 'function')
+    throw new TypeError('option setHeaders must be function')
+
+  return opts;
+}
+
+function serveStatic (root, options) {
+
+  var opts = serveOptions(root, options);
+  return function (req, res, next) {
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      if (opts.fallthrough)
+        return next()
+      return HTTP.NOT_ALLOWED(res);
+    }
+
+    var originalUrl = decodeURIComponent(/*req.originalUrl || */req.path || req.url)
+    var pathname = originalUrl
+
+    // make sure redirect occurs at mount
+    if (pathname === '/' && originalUrl.substr(-1) !== '/') {
+      pathname = ''
+    }
+
+    if (UP_PATH_REGEXP.test(pathname))
+      return HTTP.FORBIDDEN(res);
+
+    // resolve the path
+    pathname = path.resolve(path.normalize(opts.root + '/' + pathname));
+
+    // dotfile handling
+    if (opts.dotfiles != 'allow' && pathname.indexOf('/.') >= 0) {
+      if (opts.dotfiles == 'deny')
+        return HTTP.FORBIDDEN(res);
+      return HTTP.NOT_FOUND(res);
+    }
+
+    fs.stat(pathname, function onstat (err, stat) {
+      if (err) {
+        // console.log('DBG', pathname, err.code, req.originalUrl, req.url, req.path)
+        if (err.code == 'ENOENT' || err.code == 'ENAMETOOLONG' || err.code == 'ENOTDIR') {
+          if (opts.fallthrough)
+            return next();
+          console.warn('static error:', err)
+          return HTTP.NOT_FOUND(res)
+        }
+        return HTTP.INTERNAL_ERROR(res, err.code);
+      }
+
+      // index file support
+      if (stat.isDirectory()) {
+        // if (!opts.redirect)
+        //   return HTTP.NOT_FOUND(res);
+        return sendIndex(req, res, pathname, stat, opts)
+      }
+
+
+      sendFile(req, res, pathname, stat, opts)
+    });
+  }
+}
+
+function serveFile (root, options) {
+
+  var opts = serveOptions(root, options);
+  return function (req, res, next) {
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      if (opts.fallthrough)
+        return next()
+      return HTTP.NOT_ALLOWED(res);
+    }
+
+    const pathname = opts.root;
+    fs.stat(pathname, function onstat (err, stat) {
+      if (err)
+        return HTTP.INTERNAL_ERROR(res, err.code);
+      if (stat.isDirectory())
+        return HTTP.INTERNAL_ERROR(res, err.code);
+
+      sendFile(req, res, pathname, stat, opts)
+    });
+  }
+}
+
+
+module.exports = { serveStatic, serveFile, sendFile, sendIndex };