@server/next 0.13.0 → 0.15.1

package/src/index.js

@@ -0,0 +1,289 @@
+import http from "node:http";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+
+import "dotenv/config";
+
+import ServerUrl from "./ServerUrl.js";
+import RequestLogger from "./RequestLogger.js";
+
+import pathPattern from "./pathPattern.js";
+import parseBody from "./parseBody.js";
+import color from "./color.js";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+// https://stackoverflow.com/a/19524949/938236
+const getIp = (req) =>
+  (req.headers["x-forwarded-for"] || "").split(",").pop() ||
+  req.connection.remoteAddress ||
+  req.socket.remoteAddress ||
+  req.connection.socket.remoteAddress;
+
+const exists = (file) => {
+  return fsp.stat(file, fs.constants.F_OK).then(
+    (stat) => stat.isFile(),
+    () => false
+  );
+};
+
+const api = {
+  get: [],
+  post: [],
+  put: [],
+  patch: [],
+  del: [],
+  options: [],
+  head: [],
+};
+
+const getCtx = (req) => ({
+  url: new ServerUrl(req.protocol + "://" + req.headers["host"] + req.url),
+  method: req.method.toLowerCase(),
+  headers: req.headers,
+  ip: getIp(req),
+  time: { _init: performance.now() },
+  api,
+  req,
+});
+
+const createApp = (server) => {
+  const app = function (...mid) {
+    app.middleware.push(...mid.flat());
+  };
+
+  app.middleware = [
+    async function (ctx) {
+      if (ctx.method === "get") {
+        const file = path.join(process.cwd(), ctx.options.public, ctx.url.path);
+        const size = await fsp.stat(file).then(
+          (stat) => stat.isFile() && stat.size,
+          (err) => false
+        );
+        if (size) {
+          return fs.createReadStream(file);
+        }
+      }
+    },
+  ];
+
+  app.events = {
+    error: [],
+    ready: [],
+  };
+
+  app.on = (name, cb) => app.events[name].push(cb);
+  app.close = () => server.close();
+
+  return app;
+};
+
+const logStart = (port) => {
+  if (isProduction) return;
+  const routes = Object.values(api).flat().length;
+  console.log(
+    color(`Running on {under}http://localhost:${port}/{/} (${routes} routes)`)
+  );
+};
+
+export default function (options = {}, plugins) {
+  if (!options.public) {
+    options.public = "public";
+  }
+
+  const server = http.createServer(async (req, res) => {
+    const logger = new RequestLogger(req);
+    const ctx = { ...getCtx(req), options };
+
+    const parsed = await parseBody(ctx.req, ctx.headers["content-type"]);
+    if (parsed) {
+      ctx.body = parsed.body;
+      ctx.files = parsed.files;
+    }
+
+    let out;
+    ctx.res = { headers: {} };
+    for (let cb of app.middleware) {
+      out = await cb(ctx);
+      if (out) {
+        if (typeof out === "number") {
+          // Plain number
+          ctx.res.status = out;
+          ctx.res.body = "";
+          ctx.res.headers["content-type"] = "text/plain";
+        } else if (typeof out === "string") {
+          // Plain string
+          ctx.res.status = 200;
+          ctx.res.body = out;
+          const isHtml = out.trim().startsWith("<");
+          ctx.res.headers["content-type"] = isHtml ? "text/html" : "text/plain";
+          ctx.res.headers["content-length"] = Buffer.byteLength(out);
+        } else {
+          if (out.pipe) {
+            ctx.res.body = out;
+            ctx.res.status = 200;
+          } else {
+            // Plain object
+            if (out.type) ctx.res.headers["content-type"] = out.type;
+            if (out.length) ctx.res.headers["content-length"] = out.length;
+            ctx.res.headers = { ...ctx.res.headers, ...(out.headers || {}) };
+            ctx.res.body = out.body || "";
+            ctx.res.status = out.status || 200;
+          }
+        }
+        break;
+      }
+    }
+
+    ctx.time._total = performance.now();
+    ctx.res.headers["server-timing"] = ctx.res.headers["server-timing"] || "";
+    Object.entries(ctx.time).forEach(([name, value], i, times) => {
+      if (name === "_init") return; // Index = 0
+      ctx.res.headers["server-timing"] +=
+        name + ";dur=" + Math.round(value - times[i - 1][1]);
+      if (i !== times.length - 1) {
+        ctx.res.headers["server-timing"] += ", ";
+      }
+    });
+    res.writeHead(ctx.res.status, ctx.res.headers);
+    if (ctx.res.body.pipe) {
+      if (ctx.res.body.path) {
+        ctx.res.type = ctx.res.body.path.split(".").pop();
+        ctx.res.size = await fsp.stat(ctx.res.body.path).then((s) => s.size);
+      } else {
+        ctx.res.size = 0;
+        ctx.res.body.on("data", function (chunk) {
+          ctx.res.size += chunk.length;
+        });
+      }
+      await pipeline(ctx.res.body, res);
+    } else {
+      res.end(ctx.res.body);
+    }
+    // The actual sent headers, as seen by the response
+    ctx.res.headers = Object.fromEntries(
+      res._header
+        .split("\r\n")
+        .filter(Boolean)
+        .slice(1)
+        .map((line) => {
+          const [key, ...vals] = line.split(":");
+          return [key.toLowerCase(), vals.join(":").trim()];
+        })
+    );
+
+    logger.end(ctx);
+  });
+
+  const app = createApp(server);
+
+  server.listen(options.port, (error) => {
+    options.port = server.address().port;
+    if (error) {
+      app.events.error.forEach((cb) => cb(error));
+      if (!isProduction) {
+        console.error("Error:", error);
+      }
+    } else {
+      app.events.ready.forEach((cb) => cb({ options }));
+      logStart(options.port);
+    }
+  });
+
+  return app;
+}
+
+export const get = (pattern, callback) => {
+  api.get.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "get") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const post = (pattern, callback) => {
+  api.post.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "post") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const put = (pattern, callback) => {
+  api.put.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "put") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const patch = (pattern, callback) => {
+  api.patch.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "patch") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const del = (pattern, callback) => {
+  api.del.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "delete") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const options = (pattern, callback) => {
+  api.options.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "options") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const head = (pattern, callback) => {
+  api.head.push([pattern, callback]);
+
+  return (ctx) => {
+    if (ctx.method !== "head") return;
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};
+
+export const use = (pattern, callback) => {
+  return (ctx) => {
+    const match = pathPattern(pattern, ctx.url.path);
+    if (!match) return null;
+    ctx.url.params = match;
+    return callback(ctx);
+  };
+};

package/src/parseBody.js

@@ -0,0 +1,96 @@
+function getBoundary(header) {
+  if (!header) return null;
+  var items = header.split(";");
+  if (items)
+    for (var j = 0; j < items.length; j++) {
+      var item = new String(items[j]).trim();
+      if (item.indexOf("boundary") >= 0) {
+        var k = item.split("=");
+        return new String(k[1]).trim();
+      }
+    }
+  return null;
+}
+
+function getMatching(string, regex) {
+  // Helper function when using non-matching groups
+  const matches = string.match(regex);
+  if (!matches || matches.length < 2) {
+    return "";
+  }
+  return matches[1];
+}
+
+const getBody = async (req) => {
+  return await new Promise((done) => {
+    let data = "";
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+    req.on("end", () => {
+      done(data);
+    });
+  });
+};
+
+export default async function Parse(req, contentType) {
+  const rawData = await (typeof req === "string" ? req : getBody(req));
+  if (!rawData) return null;
+
+  if (/application\/json/.test(contentType)) {
+    return { body: JSON.parse(rawData), files: {} };
+  }
+
+  const boundary = getBoundary(contentType);
+  if (!boundary) return null;
+
+  let result = {};
+
+  const body = {};
+  const files = {};
+
+  const rawDataArray = rawData.split(boundary);
+  for (let item of rawDataArray) {
+    // Use non-matching groups to exclude part of the result
+    const name = getMatching(item, /(?:name=")(.+?)(?:")/)
+      .trim()
+      .replace(/\[\]$/, "");
+    if (!name) continue;
+    const value = getMatching(item, /(?:\r\n\r\n)([\S\s]*)(?:\r\n--$)/);
+    if (!value) continue;
+
+    const filename = getMatching(item, /(?:filename=")(.*?)(?:")/).trim();
+    // It's a file!
+    if (filename) {
+      const file = { name: filename };
+      const type = getMatching(item, /(?:Content-Type:)(.*?)(?:\r\n)/).trim();
+      if (type) {
+        file.type = type;
+      }
+      file.value = value;
+
+      // Already exists, so (maybe convert to an array) and push the item in it
+      if (files[name]) {
+        if (!Array.isArray(files.name)) {
+          files[name] = [files[name]];
+        }
+        files[name].push(file);
+      } else {
+        files[name] = file;
+      }
+
+      // It's a body
+    } else {
+      if (body[name]) {
+        if (!Array.isArray(body[name])) {
+          body[name] = [body[name]];
+        }
+        body[name].push(value);
+      } else {
+        body[name] = value;
+      }
+    }
+  }
+
+  return { body, files };
+}

package/src/parseBody.test.js

@@ -0,0 +1,69 @@
+import parseBody from "./parseBody.js";
+
+const getBody = () => {
+  let body = "trash1\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body += 'Content-Disposition: form-data; name="hello";\r\n\r\n';
+  body += "world\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body +=
+    'Content-Disposition: form-data; name="profile"; filename="profile.md"\r\n';
+  body += "Content-Type: text/plain\r\n\r\n";
+  body += "@11X";
+  body += "111Y\r\n";
+  body += "111Z\rCCCC\nCCCC\r\nCCCCC@\r\n\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body +=
+    'Content-Disposition: form-data; name="gallery[]"; filename="A.txt"\r\n';
+  body += "Content-Type: text/plain\r\n\r\n";
+  body += "@11X";
+  body += "111Y\r\n";
+  body += "111Z\rCCCC\nCCCC\r\nCCCCC@\r\n\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body += 'Content-Disposition: form-data; name="test";\r\n\r\n';
+  body += "test message 123456\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body += 'Content-Disposition: form-data; name="test";\r\n\r\n';
+  body += "test message number two\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp\r\n";
+  body +=
+    'Content-Disposition: form-data; name="gallery[]"; filename="C.txt"\r\n';
+  body += "Content-Type: text/plain\r\n\r\n";
+  body += "@CCC";
+  body += "CCCY\r\n";
+  body += "CCCZ\rCCCW\nCCC0\r\n666@\r\n";
+  body += "------WebKitFormBoundaryvef1fLxmoUdYZWXp--\r\n";
+  return body;
+};
+
+describe("parseBody", () => {
+  it("can parse the example body", async () => {
+    const parsed = await parseBody(
+      getBody(),
+      "multipart/form-data; boundary=----WebKitFormBoundaryvef1fLxmoUdYZWXp"
+    );
+    expect(parsed.body).toEqual({
+      hello: "world",
+      test: ["test message 123456", "test message number two"],
+    });
+    expect(parsed.files).toEqual({
+      profile: {
+        name: "profile.md",
+        type: "text/plain",
+        value: "@11X111Y\r\n111Z\rCCCC\nCCCC\r\nCCCCC@\r\n",
+      },
+      gallery: [
+        {
+          name: "A.txt",
+          type: "text/plain",
+          value: "@11X111Y\r\n111Z\rCCCC\nCCCC\r\nCCCCC@\r\n",
+        },
+        {
+          name: "C.txt",
+          type: "text/plain",
+          value: "@CCCCCCY\r\nCCCZ\rCCCW\nCCC0\r\n666@",
+        },
+      ],
+    });
+  });
+});

package/src/pathPattern.js

@@ -0,0 +1,24 @@
+import { URLPattern } from "urlpattern-polyfill";
+
+export default function pathPattern(pattern, path) {
+  pattern = pattern.replace(/\/$/, "") || "/";
+  path = path.replace(/\/$/, "") || "/";
+  const origin =
+    typeof location === "object" ? location.origin : "https://example.com/";
+  const patt = new URLPattern(pattern, origin);
+  const match = patt.exec(path, origin);
+  // console.log(match, path, pattern);
+  if (!match) return false;
+  const groups = match.pathname.groups;
+  const rest = Object.keys(groups)
+    .filter((k) => /^\d+$/.test(k))
+    .reduce((all, key) => {
+      const value = groups[key];
+      delete groups[key];
+      if (!value) return all;
+      all = all.concat(...value.split("/"));
+      return all;
+    }, []);
+  if (rest.length) groups["*"] = rest;
+  return groups;
+}

package/src/pathPattern.test.js

@@ -0,0 +1,72 @@
+import pathPattern from "./pathPattern.js";
+
+describe("pathPattern.js", () => {
+  it("matches the same string", () => {
+    expect(pathPattern("/hello", "/hello")).toEqual({});
+    expect(pathPattern("/hello/world", "/hello/world")).toEqual({});
+  });
+
+  it("is trailing slash insensitive both ways", () => {
+    expect(pathPattern("/hello", "/hello")).toEqual({});
+    expect(pathPattern("/hello", "/hello/")).toEqual({});
+    expect(pathPattern("/hello/", "/hello")).toEqual({});
+    expect(pathPattern("/hello/", "/hello/")).toEqual({});
+
+    expect(pathPattern("/hello/world", "/hello/world")).toEqual({});
+    expect(pathPattern("/hello/world", "/hello/world/")).toEqual({});
+    expect(pathPattern("/hello/world/", "/hello/world")).toEqual({});
+    expect(pathPattern("/hello/world/", "/hello/world/")).toEqual({});
+  });
+
+  it("doesn't do partial matches", () => {
+    expect(pathPattern("/hello", "/hello/John")).toEqual(false);
+    expect(pathPattern("/hello/", "/hello/John")).toEqual(false);
+  });
+
+  it("can capture simple groups", () => {
+    expect(pathPattern("/:hello", "/john")).toEqual({ hello: "john" });
+    expect(pathPattern("/hello/:there", "/hello/john")).toEqual({
+      there: "john",
+    });
+  });
+
+  it("requires a part for the asterisk", () => {
+    expect(pathPattern("/hello/:there/*", "/hello/John")).toEqual(false);
+  });
+
+  it("can make a part optional", () => {
+    // expect(pathPattern("/:name?", "/")).toEqual({});
+    expect(pathPattern("/hello/:name?", "/hello/")).toEqual({});
+    expect(pathPattern("/:name?", "/john")).toEqual({ name: "john" });
+    expect(pathPattern("/:name/*?", "/john")).toEqual({ name: "john" });
+  });
+
+  it("correctly matches the asterisk as an array of parts", () => {
+    expect(pathPattern("/*", "/john")).toEqual({ "*": ["john"] });
+    expect(pathPattern("/*", "/john/doe")).toEqual({ "*": ["john", "doe"] });
+    expect(pathPattern("/*/*", "/john/doe")).toEqual({ "*": ["john", "doe"] });
+
+    expect(pathPattern("/hello/*", "/hello/john")).toEqual({ "*": ["john"] });
+    expect(pathPattern("/hello/*", "/hello/john/doe")).toEqual({
+      "*": ["john", "doe"],
+    });
+    expect(pathPattern("/hello/*/*", "/hello/john/doe")).toEqual({
+      "*": ["john", "doe"],
+    });
+
+    expect(pathPattern("/:name/*", "/john/doe")).toEqual({
+      name: "john",
+      "*": ["doe"],
+    });
+
+    expect(pathPattern("/:name/*", "/john/doe/derek")).toEqual({
+      name: "john",
+      "*": ["doe", "derek"],
+    });
+
+    expect(pathPattern("/:name/*/*", "/john/doe/derek")).toEqual({
+      name: "john",
+      "*": ["doe", "derek"],
+    });
+  });
+});