feat: ensure functionality with node.js tests

Author: anonrig

lib/errors.js

@@ -1,9 +1,7 @@
 "use strict";
 
-const errors = require("./errors");
 const parse = require("./parse");
 
 module.exports = {
-  errors,
   parse,
 };

lib/index.js

@@ -1,22 +1,34 @@
 "use strict";
 
-const errors = require("./errors");
+/**
+ * @callback
+ * @param {string} value
+ * @returns {string}
+ */
+function decode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
 
 /**
  * @callback parse
  * @param {string} input
  */
 function parse(input) {
+  const result = Object.create(null);
+
   if (typeof input !== "string") {
-    throw errors.codes.FST_QS_INVALID_INPUT;
+    return result;
   }
-  const result = Object.create(null);
 
   let key = "";
   let value = "";
-  let separatorIndex = 0;
-  let equalityIndex = 0;
-  let shouldEncode = false;
+  let startingIndex = -1;
+  let equalityIndex = -1;
+  let shouldDecode = false;
   let hasPlus = false;
 
   // Have a boundary of input.length + 1 to access last pair inside the loop.
@@ -25,30 +37,34 @@ function parse(input) {
 
     // Handle '&' and end of line to pass the current values to result
     if (c === 38 || isNaN(c)) {
-      const hasOnlyKey = equalityIndex <= separatorIndex;
-      const keySize =
-        hasOnlyKey ? i - separatorIndex : equalityIndex - separatorIndex;
-
-      if (keySize > 0) {
-        // Accept empty values, if key size is positive
-        if (hasOnlyKey) {
-          key = input.slice(separatorIndex, i);
-          value = "";
-        } else {
-          key = input.slice(separatorIndex, equalityIndex);
-          value = input.slice(equalityIndex + 1, i);
-        }
+      // Check if the current range consist of a single key
+      if (equalityIndex <= startingIndex) {
+        key = input.slice(startingIndex + 1, i);
+        value = "";
+      }
+      // Check if the current range consist of only values.
+      else if (equalityIndex === startingIndex) {
+        key = "";
+        value = input.slice(equalityIndex + 1, i);
+      }
+      // Range consist of both key and value
+      else {
+        key = input.slice(startingIndex + 1, equalityIndex);
+        value = input.slice(equalityIndex + 1, i);
+      }
 
+      // Add key/value pair only if the range size is greater than 1; a.k.a. contains at least "="
+      if (i - startingIndex > 1) {
         // Optimization: Replace '+' with space
         if (hasPlus) {
           key = key.replace(/\+/g, " ");
           value = value.replace(/\+/g, " ");
         }
 
         // Optimization: Do not decode if it's not necessary.
-        if (shouldEncode) {
-          key = decodeURIComponent(key);
-          value = decodeURIComponent(value);
+        if (shouldDecode) {
+          key = decode(key);
+          value = decode(value);
         }
 
         if (result[key] === undefined) {
@@ -67,22 +83,27 @@ function parse(input) {
       // Reset reading key value pairs
       key = "";
       value = "";
-      separatorIndex = i + 1;
-      equalityIndex = i + 1;
-      shouldEncode = false;
+      startingIndex = i;
+      equalityIndex = i;
+      shouldDecode = false;
       hasPlus = false;
     }
     // Check '='
     else if (c === 61) {
-      equalityIndex = i;
+      // If '=' character occurs again, we should decode the input.
+      if (equalityIndex > startingIndex) {
+        shouldDecode = true;
+      } else {
+        equalityIndex = i;
+      }
     }
     // Check '+', and replace it with empty space.
     else if (c === 43) {
       hasPlus = true;
     }
     // Check '%' character for encoding
     else if (c === 37) {
-      shouldEncode = true;
+      shouldDecode = true;
     }
   }
 

lib/parse.js

@@ -2,6 +2,14 @@ import qs from "../lib";
 import { test, assert } from "vitest";
 import vm from "node:vm";
 
+function createWithNoPrototype(properties) {
+  const noProto = Object.create(null);
+  properties.forEach((property) => {
+    noProto[property.key] = property.value;
+  });
+  return noProto;
+}
+
 const foreignObject = vm.runInNewContext('({"foo": ["bar", "baz"]})');
 const qsNoMungeTestCases = [
   ["", {}],
@@ -19,15 +27,105 @@ const qsNoMungeTestCases = [
   ],
   ["trololol=yes&lololo=no", { trololol: "yes", lololo: "no" }],
 ];
+const qsTestCases = [
+  [
+    "__proto__=1",
+    "__proto__=1",
+    createWithNoPrototype([{ key: "__proto__", value: "1" }]),
+  ],
+  [
+    "__defineGetter__=asdf",
+    "__defineGetter__=asdf",
+    JSON.parse('{"__defineGetter__":"asdf"}'),
+  ],
+  [
+    "foo=918854443121279438895193",
+    "foo=918854443121279438895193",
+    { foo: "918854443121279438895193" },
+  ],
+  ["foo=bar", "foo=bar", { foo: "bar" }],
+  ["foo=bar&foo=quux", "foo=bar&foo=quux", { foo: ["bar", "quux"] }],
+  ["foo=1&bar=2", "foo=1&bar=2", { foo: "1", bar: "2" }],
+  [
+    "my+weird+field=q1%212%22%27w%245%267%2Fz8%29%3F",
+    "my%20weird%20field=q1!2%22'w%245%267%2Fz8)%3F",
+    { "my weird field": "q1!2\"'w$5&7/z8)?" },
+  ],
+  ["foo%3Dbaz=bar", "foo%3Dbaz=bar", { "foo=baz": "bar" }],
+  ["foo=baz=bar", "foo=baz%3Dbar", { foo: "baz=bar" }],
+  [
+    "str=foo&arr=1&arr=2&arr=3&somenull=&undef=",
+    "str=foo&arr=1&arr=2&arr=3&somenull=&undef=",
+    {
+      str: "foo",
+      arr: ["1", "2", "3"],
+      somenull: "",
+      undef: "",
+    },
+  ],
+  [" foo = bar ", "%20foo%20=%20bar%20", { " foo ": " bar " }],
+  ["foo=%zx", "foo=%25zx", { foo: "%zx" }],
+  ["foo=%EF%BF%BD", "foo=%EF%BF%BD", { foo: "\ufffd" }],
+  // See: https://github.com/joyent/node/issues/1707
+  [
+    "hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz",
+    "hasOwnProperty=x&toString=foo&valueOf=bar&__defineGetter__=baz",
+    {
+      hasOwnProperty: "x",
+      toString: "foo",
+      valueOf: "bar",
+      __defineGetter__: "baz",
+    },
+  ],
+  // See: https://github.com/joyent/node/issues/3058
+  ["foo&bar=baz", "foo=&bar=baz", { foo: "", bar: "baz" }],
+  ["a=b&c&d=e", "a=b&c=&d=e", { a: "b", c: "", d: "e" }],
+  ["a=b&c=&d=e", "a=b&c=&d=e", { a: "b", c: "", d: "e" }],
+  ["a=b&=c&d=e", "a=b&=c&d=e", { a: "b", "": "c", d: "e" }],
+  ["a=b&=&c=d", "a=b&=&c=d", { a: "b", "": "", c: "d" }],
+  ["&&foo=bar&&", "foo=bar", { foo: "bar" }],
+  ["&", "", {}],
+  ["&&&&", "", {}],
+  ["&=&", "=", { "": "" }],
+  ["&=&=", "=&=", { "": ["", ""] }],
+  ["=", "=", { "": "" }],
+  ["+", "%20=", { " ": "" }],
+  ["+=", "%20=", { " ": "" }],
+  ["+&", "%20=", { " ": "" }],
+  ["=+", "=%20", { "": " " }],
+  ["+=&", "%20=", { " ": "" }],
+  ["a&&b", "a=&b=", { a: "", b: "" }],
+  ["a=a&&b=b", "a=a&b=b", { a: "a", b: "b" }],
+  ["&a", "a=", { a: "" }],
+  ["&=", "=", { "": "" }],
+  ["a&a&", "a=&a=", { a: ["", ""] }],
+  ["a&a&a&", "a=&a=&a=", { a: ["", "", ""] }],
+  ["a&a&a&a&", "a=&a=&a=&a=", { a: ["", "", "", ""] }],
+  ["a=&a=value&a=", "a=&a=value&a=", { a: ["", "value", ""] }],
+  ["foo+bar=baz+quux", "foo%20bar=baz%20quux", { "foo bar": "baz quux" }],
+  ["+foo=+bar", "%20foo=%20bar", { " foo": " bar" }],
+  ["a+", "a%20=", { "a ": "" }],
+  ["=a+", "=a%20", { "": "a " }],
+  ["a+&", "a%20=", { "a ": "" }],
+  ["=a+&", "=a%20", { "": "a " }],
+  ["%20+", "%20%20=", { "  ": "" }],
+  ["=%20+", "=%20%20", { "": "  " }],
+  ["%20+&", "%20%20=", { "  ": "" }],
+  ["=%20+&", "=%20%20", { "": "  " }],
+  [null, "", {}],
+  [undefined, "", {}],
+];
 
 test("should parse the basics", () => {
   qsNoMungeTestCases.forEach((t) => {
     assert.deepEqual(qs.parse(t[0]), t[1]);
   });
 });
 
-test("should throw error on invalid type", () => {
-  assert.throws(() => qs.parse(5), "Invalid Input");
+test("should succeed on node.js tests", () => {
+  qsTestCases.forEach((t) => {
+    assert.deepEqual(qs.parse(t[0]), t[2], t[0]);
+  });
 });
 
 test("handles & on first/last character", () => {