feat: add querystring stringify

Author: anonrig

benchmark/stringify.mjs

@@ -0,0 +1,34 @@
+import benchmark from "cronometro";
+import qs from "qs";
+import fastQueryString from "../lib/index.js";
+import native from "node:querystring";
+import queryString from "query-string";
+
+const value = {
+  frappucino: "muffin",
+  goat: "scone",
+  pond: "moose",
+  foo: ["bar", "baz"],
+};
+
+await benchmark(
+  {
+    qs() {
+      return qs.stringify(value);
+    },
+    "fast-querystring"() {
+      return fastQueryString.stringify(value);
+    },
+    "node:querystring"() {
+      return native.stringify(value);
+    },
+    "query-string"() {
+      return queryString.stringify(value);
+    },
+    URLSearchParams() {
+      const urlParams = new URLSearchParams(value);
+      return urlParams.toString();
+    },
+  },
+  { warmup: true, print: { compare: true, compareMode: "previous" } },
+);

lib/index.js

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

lib/internals/querystring.js

@@ -0,0 +1,94 @@
+// This file is taken from Node.js project.
+// Full implementation can be found from https://github.com/nodejs/node/blob/main/lib/internal/querystring.js
+
+const hexTable = Array.from(
+  { length: 256 },
+  (_, i) => "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase(),
+);
+
+// These characters do not need escaping when generating query strings:
+// ! - . _ ~
+// ' ( ) *
+// digits
+// alpha (uppercase)
+// alpha (lowercase)
+// rome-ignore format: the array should not be formatted
+const noEscape = new Int8Array([
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 80 - 95
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,  // 112 - 127
+]);
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function encodeString(str) {
+  const len = str.length;
+  if (len === 0) return "";
+
+  let out = "";
+  let lastPos = 0;
+  let i = 0;
+
+  outer: for (; i < len; i++) {
+    let c = str.charCodeAt(i);
+
+    // ASCII
+    while (c < 0x80) {
+      if (noEscape[c] !== 1) {
+        if (lastPos < i) out += str.slice(lastPos, i);
+        lastPos = i + 1;
+        out += hexTable[c];
+      }
+
+      if (++i === len) break outer;
+
+      c = str.charCodeAt(i);
+    }
+
+    if (lastPos < i) out += str.slice(lastPos, i);
+
+    // Multi-byte characters ...
+    if (c < 0x800) {
+      lastPos = i + 1;
+      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    if (c < 0xD800 || c >= 0xE000) {
+      lastPos = i + 1;
+      out +=
+        hexTable[0xE0 | (c >> 12)] +
+          hexTable[0x80 | ((c >> 6) & 0x3F)] +
+          hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    // Surrogate pair
+    ++i;
+
+    // This branch should never happen because all URLSearchParams entries
+    // should already be converted to USVString. But, included for
+    // completion's sake anyway.
+    if (i >= len) throw new Error("Invalid URI");
+
+    const c2 = str.charCodeAt(i) & 0x3FF;
+
+    lastPos = i + 1;
+    c = 0x10000 + (((c & 0x3FF) << 10) | c2);
+    out +=
+      hexTable[0xF0 | (c >> 18)] +
+        hexTable[0x80 | ((c >> 12) & 0x3F)] +
+        hexTable[0x80 | ((c >> 6) & 0x3F)] +
+        hexTable[0x80 | (c & 0x3F)];
+  }
+  if (lastPos === 0) return str;
+  if (lastPos < len) return out + str.slice(lastPos);
+  return out;
+}
+
+module.exports = { encodeString };

lib/stringify.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const { encodeString } = require("./internals/querystring");
+
+function getAsPrimitive(value) {
+  const type = typeof value;
+
+  if (type === "string") {
+    // Length check is handled inside encodeString function
+    return encodeString(value);
+  } else if (type === "number" && Number.isFinite(value)) {
+    if (Math.abs(value) < 1e21) return value + "";
+    return encodeString(value);
+  } else if (type === "bigint") {
+    return value + "";
+  } else if (type === "boolean") {
+    return value ? "true" : "false";
+  }
+
+  return "";
+}
+
+/**
+ * @callback
+ * @param {any} input
+ * @return {string}
+ */
+function stringify(input) {
+  let result = "";
+
+  const keys = Object.keys(input);
+  const keyLength = keys.length;
+
+  for (let i = 0; i < keyLength; i++) {
+    const key = keys[i];
+    const value = input[key];
+    const encodedKey = encodeString(key);
+
+    if (i) {
+      result += "&";
+    }
+
+    if (value.pop) {
+      const valueLength = value.length;
+      for (let j = 0; j < valueLength; j++) {
+        if (j) {
+          result += "&";
+        }
+
+        result += encodedKey + "=" + getAsPrimitive(value[j]);
+      }
+    } else {
+      result += encodedKey + "=" + getAsPrimitive(value);
+    }
+  }
+
+  return result;
+}
+
+module.exports = stringify;

package.json

@@ -13,7 +13,8 @@
     "test": "vitest",
     "test:watch": "vitest --watch",
     "coverage": "vitest run --coverage",
-    "benchmark": "node benchmark/parse.mjs"
+    "benchmark:parse": "node benchmark/parse.mjs",
+    "benchmark:stringify": "node benchmark/stringify.mjs"
   },
   "keywords": [
     "querystring",

test/basics.test.ts test/node.tstest/basics.test.ts renamed to test/node.ts

@@ -1,5 +1,3 @@
-import qs from "../lib";
-import { test, assert } from "vitest";
 import vm from "node:vm";
 
 function createWithNoPrototype(properties) {
@@ -9,9 +7,8 @@ function createWithNoPrototype(properties) {
   });
   return noProto;
 }
-
-const foreignObject = vm.runInNewContext('({"foo": ["bar", "baz"]})');
-const qsNoMungeTestCases = [
+export const foreignObject = vm.runInNewContext('({"foo": ["bar", "baz"]})');
+export const qsNoMungeTestCases = [
   ["", {}],
   ["foo=bar&foo=baz", { foo: ["bar", "baz"] }],
   ["foo=bar&foo=baz", foreignObject],
@@ -27,7 +24,7 @@ const qsNoMungeTestCases = [
   ],
   ["trololol=yes&lololo=no", { trololol: "yes", lololo: "no" }],
 ];
-const qsTestCases = [
+export const qsTestCases = [
   [
     "__proto__=1",
     "__proto__=1",
@@ -115,36 +112,3 @@ const qsTestCases = [
   [null, "", {}],
   [undefined, "", {}],
 ];
-
-test("should parse the basics", () => {
-  qsNoMungeTestCases.forEach((t) => {
-    assert.deepEqual(qs.parse(t[0]), t[1]);
-  });
-});
-
-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", () => {
-  assert.deepEqual(qs.parse("&hello=world"), { hello: "world" });
-  assert.deepEqual(qs.parse("hello=world&"), { hello: "world" });
-});
-
-test("handles ? on first character", () => {
-  // This aligns with `node:querystring` functionality
-  assert.deepEqual(qs.parse("?hello=world"), { "?hello": "world" });
-});
-
-test("handles + character", () => {
-  assert.deepEqual(qs.parse("author=Yagiz+Nizipli"), {
-    author: "Yagiz Nizipli",
-  });
-});
-
-test("should accept pairs with missing values", () => {
-  assert.deepEqual(qs.parse("foo=bar&hey"), { foo: "bar", hey: "" });
-  assert.deepEqual(qs.parse("hey"), { hey: "" });
-});

test/parse.test.ts

@@ -0,0 +1,36 @@
+import qs from "../lib";
+import { test, assert } from "vitest";
+import { qsNoMungeTestCases, qsTestCases } from "./node";
+
+test("should parse the basics", () => {
+  qsNoMungeTestCases.forEach((t) => {
+    assert.deepEqual(qs.parse(t[0]), t[1]);
+  });
+});
+
+test("should succeed on node.js tests", () => {
+  qsTestCases.forEach((t) => {
+    assert.deepEqual(qs.parse(t[0]), t[2]);
+  });
+});
+
+test("handles & on first/last character", () => {
+  assert.deepEqual(qs.parse("&hello=world"), { hello: "world" });
+  assert.deepEqual(qs.parse("hello=world&"), { hello: "world" });
+});
+
+test("handles ? on first character", () => {
+  // This aligns with `node:querystring` functionality
+  assert.deepEqual(qs.parse("?hello=world"), { "?hello": "world" });
+});
+
+test("handles + character", () => {
+  assert.deepEqual(qs.parse("author=Yagiz+Nizipli"), {
+    author: "Yagiz Nizipli",
+  });
+});
+
+test("should accept pairs with missing values", () => {
+  assert.deepEqual(qs.parse("foo=bar&hey"), { foo: "bar", hey: "" });
+  assert.deepEqual(qs.parse("hey"), { hey: "" });
+});

test/stringify.test.ts

@@ -0,0 +1,15 @@
+import { qsNoMungeTestCases, qsTestCases } from "./node";
+import qs from "../lib";
+import { test, assert } from "vitest";
+
+test("should stringify the basics", () => {
+  qsNoMungeTestCases.forEach((t) => {
+    assert.deepEqual(qs.stringify(t[1]), t[0]);
+  });
+});
+
+test("should succeed on node.js tests", () => {
+  qsTestCases.forEach((t) => {
+    assert.deepEqual(qs.stringify(t[2]), t[1]);
+  });
+});