Extract functions to get URL params / path

We don't want to accidentially use url.hostname (which might be
localhost)

Author: hansott

library/helpers/buildRouteFromURL.ts

@@ -1,23 +1,18 @@
-import { tryParseURL } from "./tryParseURL";
+import { tryParseURLPath } from "./tryParseURLPath";
 
 const UUID =
   /(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
 const NUMBER = /^\d+$/;
 const DATE = /^\d{4}-\d{2}-\d{2}|\d{2}-\d{2}-\d{4}$/;
 
 export function buildRouteFromURL(url: string) {
-  const parsed = tryParseURL(
-    url.startsWith("/") ? `http://localhost${url}` : url
-  );
+  const path = tryParseURLPath(url);
 
-  if (!parsed || !parsed.pathname) {
+  if (!path) {
     return undefined;
   }
 
-  const route = parsed.pathname
-    .split("/")
-    .map(replaceURLSegmentWithParam)
-    .join("/");
+  const route = path.split("/").map(replaceURLSegmentWithParam).join("/");
 
   if (route === "/") {
     return "/";

library/helpers/matchEndpoint.ts

@@ -1,6 +1,6 @@
 import { Endpoint } from "../agent/Config";
 import { Context } from "../agent/Context";
-import { tryParseURL } from "./tryParseURL";
+import { tryParseURLPath } from "./tryParseURLPath";
 
 export type LimitedContext = Pick<Context, "url" | "method" | "route">;
 
@@ -31,11 +31,9 @@ export function matchEndpoint(context: LimitedContext, endpoints: Endpoint[]) {
 
   // req.url is relative, so we need to prepend a host to make it absolute
   // We just match the pathname, we don't use the host for matching
-  const url = tryParseURL(
-    context.url.startsWith("/") ? `http://localhost${context.url}` : context.url
-  );
+  const path = tryParseURLPath(context.url);
 
-  if (!url) {
+  if (!path) {
     return undefined;
   }
 
@@ -52,7 +50,7 @@ export function matchEndpoint(context: LimitedContext, endpoints: Endpoint[]) {
       "i"
     );
 
-    if (regex.test(url.pathname)) {
+    if (regex.test(path)) {
       return { endpoint: wildcard, route: wildcard.route };
     }
   }

library/helpers/tryParseURLParams.test.ts

@@ -0,0 +1,29 @@
+import * as t from "tap";
+import { tryParseURLParams } from "./tryParseURLParams";
+
+t.test("it returns undefined if invalid URL", async () => {
+  t.same(tryParseURLParams("abc"), new URLSearchParams());
+});
+
+t.test("it returns search params for /", async () => {
+  t.same(tryParseURLParams("/"), new URLSearchParams());
+});
+
+t.test("it returns search params for relative URL", async () => {
+  t.same(tryParseURLParams("/posts"), new URLSearchParams());
+});
+
+t.test("it returns search params for relative URL with query", async () => {
+  t.same(tryParseURLParams("/posts?abc=def"), new URLSearchParams("abc=def"));
+});
+
+t.test("it returns search params", async () => {
+  t.same(tryParseURLParams("http://localhost/posts/3"), new URLSearchParams());
+});
+
+t.test("it returns search params with query", async () => {
+  t.same(
+    tryParseURLParams("http://localhost/posts/3?abc=def"),
+    new URLSearchParams("abc=def")
+  );
+});

library/helpers/tryParseURLParams.ts

@@ -0,0 +1,13 @@
+import { tryParseURL } from "./tryParseURL";
+
+export function tryParseURLParams(url: string) {
+  const parsed = tryParseURL(
+    url.startsWith("/") ? `http://localhost${url}` : url
+  );
+
+  if (!parsed) {
+    return new URLSearchParams();
+  }
+
+  return parsed.searchParams;
+}

library/helpers/tryParseURLPath.test.ts

@@ -0,0 +1,46 @@
+import * as t from "tap";
+import { tryParseURLPath } from "./tryParseURLPath";
+
+t.test("it returns undefined if nothing found", async () => {
+  t.equal(tryParseURLPath("abc"), undefined);
+});
+
+t.test("it returns pathname for /", async () => {
+  t.equal(tryParseURLPath("/"), "/");
+});
+
+t.test("it returns pathname for relative URL", async () => {
+  t.equal(tryParseURLPath("/posts"), "/posts");
+});
+
+t.test("it returns pathname for relative URL with query", async () => {
+  t.equal(tryParseURLPath("/posts?abc=def"), "/posts");
+});
+
+t.test("it returns pathname", async () => {
+  t.equal(tryParseURLPath("http://localhost/posts/3"), "/posts/3");
+});
+
+t.test("it returns pathname with query", async () => {
+  t.equal(tryParseURLPath("http://localhost/posts/3?abc=def"), "/posts/3");
+});
+
+t.test("it returns pathname with hash", async () => {
+  t.equal(tryParseURLPath("http://localhost/posts/3#abc"), "/posts/3");
+});
+
+t.test("it returns pathname with query and hash", async () => {
+  t.equal(tryParseURLPath("http://localhost/posts/3?abc=def#ghi"), "/posts/3");
+});
+
+t.test("it returns pathname with query and hash and no path", async () => {
+  t.equal(tryParseURLPath("http://localhost/?abc=def#ghi"), "/");
+});
+
+t.test("it returns pathname with query and no path", async () => {
+  t.equal(tryParseURLPath("http://localhost?abc=def"), "/");
+});
+
+t.test("it returns pathname with hash and no path", async () => {
+  t.equal(tryParseURLPath("http://localhost#abc"), "/");
+});

library/helpers/tryParseURLPath.ts

@@ -0,0 +1,13 @@
+import { tryParseURL } from "./tryParseURL";
+
+export function tryParseURLPath(url: string) {
+  const parsed = tryParseURL(
+    url.startsWith("/") ? `http://localhost${url}` : url
+  );
+
+  if (!parsed) {
+    return undefined;
+  }
+
+  return parsed.pathname;
+}

library/sources/http-server/contextFromRequest.ts

@@ -3,28 +3,17 @@ import { Context } from "../../agent/Context";
 import { buildRouteFromURL } from "../../helpers/buildRouteFromURL";
 import { getIPAddressFromRequest } from "../../helpers/getIPAddressFromRequest";
 import { parse } from "../../helpers/parseCookies";
+import { tryParseURLParams } from "../../helpers/tryParseURLParams";
 
 export function contextFromRequest(
   req: IncomingMessage,
   body: string | undefined,
   module: string
 ): Context {
-  let parsedURL: URL | undefined = undefined;
-  if (req.url) {
-    try {
-      // req.url is relative, so we need to prepend a host to make it absolute
-      // We just need the searchParams, we don't use the host
-      parsedURL = new URL(
-        req.url.startsWith("/") ? `http://localhost${req.url}` : req.url
-      );
-    } catch (e) {
-      // Ignore
-    }
-  }
-
   const queryObject: Record<string, string> = {};
-  if (parsedURL) {
-    for (const [key, value] of parsedURL.searchParams.entries()) {
+  if (req.url) {
+    const params = tryParseURLParams(req.url);
+    for (const [key, value] of params.entries()) {
       queryObject[key] = value;
     }
   }