fix: improve www detection (#5314)

We detect cloudflare to preserve root domain and add www for everything
else. Now we check official dns registry for top level domains and check
its data for required nameservers.

Author: TrySound

packages/domain/src/rdap.ts

@@ -0,0 +1,105 @@
+interface DNSList {
+  description: string;
+  publication: string;
+  services: [string[], string[]][];
+  version: string;
+}
+
+// Cache map to store TLD (top level domain) → RDAP server URL mappings
+const dnsCache = new Map<string, string>();
+
+/**
+ * Fetch the IANA DNS RDAP bootstrap JSON.
+ */
+const fetchDnsList = async (): Promise<undefined | DNSList> => {
+  try {
+    const response = await fetch("https://data.iana.org/rdap/dns.json", {
+      headers: {
+        accept: "application/json,application/rdap+json",
+      },
+    });
+    if (response.ok) {
+      return response.json();
+    }
+  } catch {
+    // empty block
+  }
+};
+
+/**
+ * Find the RDAP server URL for a given top-level domain (TLD).
+ */
+const findRdapServer = async (topLevelDomain: string) => {
+  if (dnsCache.size === 0) {
+    const dns = await fetchDnsList();
+    if (dns) {
+      for (const [domains, [server]] of dns.services) {
+        for (const domain of domains) {
+          dnsCache.set(domain, server);
+        }
+      }
+    }
+  }
+  return dnsCache.get(topLevelDomain);
+};
+
+/**
+ * Extract the top-level domain from a full domain string.
+ * Unicode is converted to ascii
+ */
+const getTopLevelDomain = (domain: string) => {
+  try {
+    return new URL(`https://${domain}`).hostname.split(".").at(-1);
+  } catch {
+    // invalid domain
+  }
+};
+
+const fetchRdap = async (
+  rdapServer: string,
+  domain: string
+): Promise<undefined | string> => {
+  try {
+    const response = await fetch(`${rdapServer}domain/${domain}`, {
+      headers: {
+        accept: "application/json,application/rdap+json",
+      },
+    });
+    if (response.ok) {
+      return response.text();
+    }
+  } catch {
+    // empty block
+  }
+};
+
+/**
+ * Determine whether a domain is using Cloudflare nameservers.
+ * 1. Parse TLD from domain.
+ * 2. Lookup RDAP server for that TLD.
+ * 3. Fetch RDAP data for the domain.
+ * 4. Search the raw response for ".ns.cloudflare.com".
+ */
+export const isDomainUsingCloudflareNameservers = async (domain: string) => {
+  const topLevelDomain = getTopLevelDomain(domain);
+  if (!topLevelDomain) {
+    throw new Error("Could not parse the top level domain.");
+  }
+
+  const rdapServer = await findRdapServer(topLevelDomain);
+  if (!rdapServer) {
+    throw new Error(
+      "RDAP Server for the given top level domain could not be found."
+    );
+  }
+
+  if (rdapServer) {
+    const data = await fetchRdap(rdapServer, domain);
+    if (data) {
+      // detect by nameservers rather than registrar url
+      // sometimes stored as *.NS.CLOUDFLARE.COM
+      return data.toLowerCase().includes(".ns.cloudflare.com");
+    }
+  }
+  return false;
+};

packages/domain/src/trpc/domain.ts

@@ -5,11 +5,7 @@ import { createProductionBuild } from "@webstudio-is/project-build/index.server"
 import { router, procedure } from "@webstudio-is/trpc-interface/index.server";
 import { Templates } from "@webstudio-is/sdk";
 import { db } from "../db";
-
-const rdap = [
-  "https://rdap.cloudflare.com/rdap/v1/domain/",
-  "https://rdap.namecheap.com/domain/",
-];
+import { isDomainUsingCloudflareNameservers } from "../rdap";
 
 export const domainRouter = router({
   getEntriToken: procedure.query(async ({ ctx }) => {
@@ -32,23 +28,8 @@ export const domainRouter = router({
   findDomainRegistrar: procedure
     .input(z.object({ domain: z.string() }))
     .query(async ({ input }) => {
-      try {
-        for (const rdapEndpoint of rdap) {
-          const response = await fetch(`${rdapEndpoint}${input.domain}`);
-          if (response.ok) {
-            const data = await response.text();
-            return {
-              // detect by nameservers rather than registrar url
-              cnameFlattening: data.includes(".ns.cloudflare.com"),
-            };
-          }
-        }
-      } catch {
-        // empty block
-      }
       return {
-        name: "other",
-        cnameFlattening: false,
+        cnameFlattening: await isDomainUsingCloudflareNameservers(input.domain),
       };
     }),