register

1import t from "ava";
2import fs from "fs-extra";
3import path from "path";
4 
5import internalDomains from "../util/internal.json" with { type: "json" };
6import reservedDomains from "../util/reserved.json" with { type: "json" };
7 
8const ignoredRootJSONFiles = ["package-lock.json", "package.json"];
9 
10const requiredFields = {
11    owner: "object",
12    records: "object"
13};
14 
15const optionalFields = {
16    proxied: "boolean",
17    redirect_config: "object"
18};
19 
20const requiredOwnerFields = {
21    username: "string"
22};
23 
24const optionalOwnerFields = {
25    email: "string"
26};
27 
28const optionalRedirectConfigFields = {
29    custom_paths: "object",
30    redirect_paths: "boolean"
31};
32 
33const blockedFields = ["domain", "internal", "proxy", "reserved", "services", "subdomain", "nested", "record"];
34 
35const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
36const hostnameRegex = /^(?=.{1,253}$)(?:(?:[_a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)\.)+[a-zA-Z]{2,63}$/;
37 
38const domainsPath = path.resolve("domains");
39const files = fs.readdirSync(domainsPath);
40 
41function findDuplicateKeys(jsonString) {
42    const duplicateKeys = new Set();
43    const keyStack = [];
44 
45    const keyRegex = /"(.*?)"\s*:/g;
46 
47    let i = 0;
48    while (i < jsonString.length) {
49        const char = jsonString[i];
50 
51        if (char === "{") {
52            keyStack.push({});
53            i++;
54            continue;
55        }
56 
57        if (char === "}") {
58            keyStack.pop();
59            i++;
60            continue;
61        }
62 
63        keyRegex.lastIndex = i;
64        const match = keyRegex.exec(jsonString);
65        if (match && match.index === i && keyStack.length > 0) {
66            const key = match[1];
67            const currentScope = keyStack[keyStack.length - 1];
68 
69            if (currentScope[key]) {
70                duplicateKeys.add(key);
71            } else {
72                currentScope[key] = true;
73            }
74 
75            i = keyRegex.lastIndex;
76        } else {
77            i++;
78        }
79    }
80 
81    return [...duplicateKeys];
82}
83 
84async function validateFields(t, obj, fields, file, prefix = "") {
85    for (const key of Object.keys(fields)) {
86        const fieldPath = prefix ? `${prefix}.${key}` : key;
87 
88        if (obj.hasOwnProperty(key)) {
89            t.is(typeof obj[key], fields[key], `${file}: Field ${fieldPath} should be of type ${fields[key]}`);
90        } else if (fields === requiredFields || fields === requiredOwnerFields) {
91            t.true(false, `${file}: Missing required field: ${fieldPath}`);
92        }
93    }
94}
95 
96async function validateFileName(t, file) {
97    t.true(file.endsWith(".json"), `${file}: File does not have .json extension`);
98    t.false(file.includes(".is-a.dev"), `${file}: File name should not contain .is-a.dev`);
99    t.true(file === file.toLowerCase(), `${file}: File name should be all lowercase`);
100    t.false(file.includes("--"), `${file}: File name should not contain consecutive hyphens`);
101 
102    const subdomain = file.replace(/\.json$/, "");
103 
104    t.regex(
105        subdomain + ".is-a.dev",
106        hostnameRegex,
107        `${file}: FQDN must be 1-253 characters, can use letters, numbers, dots, and non-consecutive hyphens.`
108    );
109    t.false(internalDomains.includes(subdomain), `${file}: Subdomain name is registered internally`);
110    t.false(reservedDomains.includes(subdomain), `${file}: Subdomain name is reserved`);
111    t.true(
112        !internalDomains.some((i) => subdomain.endsWith(`.${i}`)),
113        `${file}: Subdomain name is registered internally`
114    );
115    t.true(!reservedDomains.some((r) => subdomain.endsWith(`.${r}`)), `${file}: Subdomain name is reserved`);
116 
117    const rootSubdomain = subdomain.split(".").pop();
118    t.false(rootSubdomain.startsWith("_"), `${file}: Root subdomains should not start with an underscore`);
119}
120 
121async function processFile(file, t) {
122    const filePath = path.join(domainsPath, file);
123    const data = await fs.readJson(filePath);
124 
125    validateFileName(t, file);
126 
127    // Check for duplicate keys
128    const rawData = await fs.readFile(filePath, "utf8");
129    const duplicateKeys = findDuplicateKeys(rawData);
130    t.true(!duplicateKeys.length, `${file}: Duplicate keys found: ${duplicateKeys.join(", ")}`);
131 
132    // Validate fields
133    validateFields(t, data, requiredFields, file);
134    validateFields(t, data.owner, requiredOwnerFields, file, "owner");
135    validateFields(t, data.owner, optionalOwnerFields, file, "owner");
136    validateFields(t, data, optionalFields, file);
137 
138    if (data.owner.email) {
139        t.regex(data.owner.email, emailRegex, `${file}: Owner email should be a valid email address`);
140        t.false(
141            data.owner.email.endsWith("@users.noreply.github.com"),
142            `${file}: Owner email should not be a GitHub no-reply email`
143        );
144    }
145 
146    t.true(Object.keys(data.records).length > 0, `${file}: Missing DNS records`);
147 
148    if (data.redirect_config) {
149        validateFields(t, data.redirect_config, optionalRedirectConfigFields, file, "redirect_config");
150    }
151 
152    for (const field of blockedFields) {
153        t.true(!data.hasOwnProperty(field), `${file}: Disallowed field: ${field}`);
154    }
155}
156 
157t("JSON files should not be in the root directory", (t) => {
158    const rootFiles = fs
159        .readdirSync(path.resolve())
160        .filter((file) => file.endsWith(".json") && !ignoredRootJSONFiles.includes(file));
161    t.is(rootFiles.length, 0, "JSON files should not be in the root directory");
162});
163 
164t("All files should be valid JSON", async (t) => {
165    await Promise.all(
166        files.map((file) => {
167            return t.notThrows(() => fs.readJson(path.join(domainsPath, file)), `${file}: Invalid JSON file`);
168        })
169    );
170});
171 
172t("All files should have valid file names", async (t) => {
173    await Promise.all(files.map((file) => validateFileName(t, file)));
174});
175 
176t("All files should have valid required and optional fields", async (t) => {
177    await Promise.all(files.map((file) => processFile(file, t)));
178});
179