@server/next 0.14.0 → 0.15.0

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"],
+    });
+  });
+});