http: add http.createStaticServer

doc/api/http.md

@@ -3565,6 +3565,61 @@ server.on('request', (request, res) => {
 server.listen(8000);
 ```
 
+## `http.createStaticServer([options])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental. The implementation lacks support for partial
+> responses (Ranges) and conditional-GET negotiation (If-Match,
+> If-Unmodified-Since, If-None-Match, If-Modified-Since).
+
+* `options` {Object}
+  * `directory` {string|URL} Root directory from which files would be served.
+    **Default:** `process.cwd()`.
+  * `port` {number}
+  * `host` {string} **Default:** `'localhost'`
+  * `mimeOverrides` {Object} Dictionary linking file extension to a MIME string,
+    to override or extend the built-in ones.
+  * `filter` {Function|null} should be a function that accepts two arguments and
+    returns a value that is coercible to a {boolean} value. When `null`, no
+    files are filtered. **Default:** filters all dot files.
+  * `log` {Function|null} called when sending a response to the client.
+    **Default:** `console.log`.
+    * `statusCode` {integer} The status code that is sent to the client.
+    * `url` {string} the (origin-relative) URL that was requested.
+  * `onStart` {Function} called the server starts listening to requests.
+    **Default:** logs the URL to the console.
+
+* Returns: {http.Server}
+
+Start a TCP server listening for connections on the given `port` and `host`, and
+serve static local files, using `directory` as the root.
+When specifying a `host` other than `localhost`, you are exposing your local
+file system to all the machines that can connect to your computer.
+
+If specified and not `null`, `filter` will be called with two arguments: the
+first one is the request URL string (the URL that is present in the actual HTTP
+request), and the second one is the `file:` `URL` that was generated from the
+base directory and the request URL. If the function returns a falsy value, the
+server will respond with a 403 HTTP error.
+
+If `port` is omitted or is 0, the operating system will assign an arbitrary
+unused port, which it's output will be the standard output.
+
+```bash
+# Starts serving the cwd on a random port:
+node -e 'http.createStaticServer()'
+
+# To start serving on the port 8080 using /path/to/dir as the root:
+node -e 'http.createStaticServer({directory: "/path/to/dir", port: 8080})'
+
+# Same as above, but exposing your local file system to the whole
+# IPv4 network:
+node -e 'http.createStaticServer({directory: "/path/to/dir", port: 8080, host: "0.0.0.0"})'
+```
+
 ## `http.get(options[, callback])`
 
 ## `http.get(url[, options][, callback])`

lib/http.js

@@ -43,6 +43,7 @@ const {
   Server,
   ServerResponse,
 } = require('_http_server');
+const createStaticServer = require('internal/http/static');
 let maxHeaderSize;
 
 /**
@@ -127,6 +128,7 @@ module.exports = {
   Server,
   ServerResponse,
   createServer,
+  createStaticServer,
   validateHeaderName,
   validateHeaderValue,
   get,

lib/internal/http/static.js

@@ -0,0 +1,155 @@
+'use strict';
+
+const {
+  Promise,
+  RegExpPrototypeExec,
+  StringPrototypeEndsWith,
+  StringPrototypeIndexOf,
+  StringPrototypeLastIndexOf,
+  StringPrototypeSlice,
+  StringPrototypeStartsWith,
+  StringPrototypeToLocaleLowerCase,
+} = primordials;
+
+const { cwd } = process;
+const console = require('internal/console/global');
+const { createReadStream } = require('fs');
+const { Server } = require('_http_server');
+const { URL, isURL, pathToFileURL } = require('internal/url');
+const { emitExperimentalWarning, kEmptyObject } = require('internal/util');
+const { validateFunction, validatePort } = require('internal/validators');
+
+const mimeDefault = {
+  '__proto__': null,
+  '.html': 'text/html; charset=UTF-8',
+  '.js': 'text/javascript; charset=UTF-8',
+  '.css': 'text/css; charset=UTF-8',
+  '.avif': 'image/avif',
+  '.svg': 'image/svg+xml',
+  '.json': 'application/json',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.wasm': 'application/wasm',
+  '.webp': 'image/webp',
+  '.woff2': 'font/woff2',
+};
+
+const dot = /\/(\.|%2[eE])/;
+function filterDotFiles(url, fileURL) {
+  return RegExpPrototypeExec(dot, fileURL.pathname) === null;
+}
+
+function createStaticServer(options = kEmptyObject) {
+  emitExperimentalWarning('http/static');
+
+  const {
+    directory = cwd(),
+    port,
+    host = 'localhost',
+    mimeOverrides,
+    filter = filterDotFiles,
+    log = console.log,
+    onStart = (host, port) => console.log(`Server started on http://${host}:${port}`),
+  } = options;
+  const mime = mimeOverrides ? {
+    __proto__: null,
+    ...mimeDefault,
+    ...mimeOverrides,
+  } : mimeDefault;
+
+  const directoryURL = isURL(directory) ? directory : pathToFileURL(directory);
+  // To be used as a base URL, it is necessary that the URL ends with a slash:
+  const baseDirectoryURL = StringPrototypeEndsWith(directoryURL.pathname, '/') ?
+    directoryURL : new URL(`${directoryURL}/`);
+
+  if (port != null) validatePort(port);
+  if (filter != null) validateFunction(filter, 'options.filter');
+
+  const server = new Server(async (req, res) => {
+    const url = new URL(
+      req.url === '/' || StringPrototypeStartsWith(req.url, '/?') ?
+        './index.html' :
+        '.' + StringPrototypeSlice(`${new URL(req.url, 'root://')}`, 6),
+      baseDirectoryURL,
+    );
+
+    if (filter != null && !filter(req.url, url)) {
+      log?.(403, req.url);
+      res.statusCode = 403;
+      res.end('Forbidden\n');
+      return;
+    }
+
+    const ext = StringPrototypeToLocaleLowerCase(
+      StringPrototypeSlice(url.pathname, StringPrototypeLastIndexOf(url.pathname, '.')),
+    );
+    if (ext in mime) res.setHeader('Content-Type', mime[ext]);
+
+    try {
+      try {
+        const stream = createReadStream(url, { emitClose: false });
+        await new Promise((resolve, reject) => {
+          stream.on('error', reject);
+          stream.on('end', resolve);
+          stream.pipe(res);
+        });
+        log?.(200, req.url);
+      } catch (err) {
+        if (err?.code === 'EISDIR') {
+          if (StringPrototypeEndsWith(req.url, '/') || RegExpPrototypeExec(/^[^?]+\/\?/, req.url) !== null) {
+            const stream = createReadStream(new URL('./index.html', url), {
+              emitClose: false,
+            });
+            res.setHeader('Content-Type', mime['.html']);
+            await new Promise((resolve, reject) => {
+              stream.on('error', reject);
+              stream.on('end', resolve);
+              stream.pipe(res);
+            });
+            log?.(200, req.url);
+          } else {
+            log?.(307, req.url);
+            res.statusCode = 307;
+            const index = StringPrototypeIndexOf(req.url, '?');
+            res.setHeader(
+              'Location',
+              index === -1 ?
+                `${req.url}/` :
+                `${StringPrototypeSlice(req.url, 0, index)}/${StringPrototypeSlice(req.url, index)}`,
+            );
+            res.end('Temporary Redirect\n');
+          }
+        } else {
+          throw err;
+        }
+      }
+    } catch (err) {
+      if (err?.code === 'ENOENT') {
+        log?.(404, req.url);
+        res.statusCode = 404;
+        res.end('Not Found\n');
+      } else {
+        log?.(500, req.url, err);
+        res.statusCode = 500;
+        res.end('Internal Error\n');
+      }
+    }
+  });
+  const callback = () => {
+    const { address, family, port } = server.address();
+    const host = family === 'IPv6' ? `[${address}]` : address;
+    onStart?.(host, port);
+  };
+  if (host != null) {
+    server.listen(port, host, callback);
+  } else if (port != null) {
+    server.listen(port, callback);
+  } else {
+    server.listen(callback);
+  }
+
+  return server;
+}
+
+module.exports = createStaticServer;

test/fixtures/static-server/.bar

@@ -0,0 +1 @@
+Content of .bar

test/fixtures/static-server/.foo/bar.js

@@ -0,0 +1 @@
+Content of .foo/bar.js

test/fixtures/static-server/file.unsupported_extension

@@ -0,0 +1 @@
+Dummy file to test mimeOverrides option

test/fixtures/static-server/subfolder/index.html

@@ -0,0 +1 @@
+Content of subfolder/index.html

test/fixtures/static-server/test.html

@@ -0,0 +1 @@
+Content of test.html