@oneuptime/common 9.2.17 → 9.2.20

package/Server/Utils/AI/ScheduledMaintenanceAIContextBuilder.ts

@@ -0,0 +1,345 @@
+import ObjectID from "../../../Types/ObjectID";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
+import ScheduledMaintenanceStateTimeline from "../../../Models/DatabaseModels/ScheduledMaintenanceStateTimeline";
+import ScheduledMaintenanceInternalNote from "../../../Models/DatabaseModels/ScheduledMaintenanceInternalNote";
+import ScheduledMaintenancePublicNote from "../../../Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import ScheduledMaintenanceService from "../../Services/ScheduledMaintenanceService";
+import ScheduledMaintenanceStateTimelineService from "../../Services/ScheduledMaintenanceStateTimelineService";
+import ScheduledMaintenanceInternalNoteService from "../../Services/ScheduledMaintenanceInternalNoteService";
+import ScheduledMaintenancePublicNoteService from "../../Services/ScheduledMaintenancePublicNoteService";
+import CaptureSpan from "../Telemetry/CaptureSpan";
+import OneUptimeDate from "../../../Types/Date";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
+import { LLMMessage } from "../LLM/LLMService";
+
+export interface ScheduledMaintenanceContextData {
+  scheduledMaintenance: ScheduledMaintenance;
+  stateTimeline: Array<ScheduledMaintenanceStateTimeline>;
+  internalNotes: Array<ScheduledMaintenanceInternalNote>;
+  publicNotes: Array<ScheduledMaintenancePublicNote>;
+}
+
+export interface AIGenerationContext {
+  contextText: string;
+  systemPrompt: string;
+  messages: Array<LLMMessage>;
+}
+
+export default class ScheduledMaintenanceAIContextBuilder {
+  @CaptureSpan()
+  public static async buildScheduledMaintenanceContext(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<ScheduledMaintenanceContextData> {
+    const scheduledMaintenance: ScheduledMaintenance | null =
+      await ScheduledMaintenanceService.findOneById({
+        id: data.scheduledMaintenanceId,
+        select: {
+          _id: true,
+          title: true,
+          description: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          customFields: true,
+          projectId: true,
+          currentScheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          monitors: {
+            name: true,
+          },
+          labels: {
+            name: true,
+            color: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenance) {
+      throw new Error("Scheduled Maintenance not found");
+    }
+
+    // Fetch state timeline
+    const stateTimeline: Array<ScheduledMaintenanceStateTimeline> =
+      await ScheduledMaintenanceStateTimelineService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          createdAt: true,
+          startsAt: true,
+          endsAt: true,
+          scheduledMaintenanceState: {
+            name: true,
+            color: true,
+          },
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch internal notes
+    const internalNotes: Array<ScheduledMaintenanceInternalNote> =
+      await ScheduledMaintenanceInternalNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // Fetch public notes
+    const publicNotes: Array<ScheduledMaintenancePublicNote> =
+      await ScheduledMaintenancePublicNoteService.findBy({
+        query: {
+          scheduledMaintenanceId: data.scheduledMaintenanceId,
+        },
+        select: {
+          _id: true,
+          note: true,
+          createdAt: true,
+          postedAt: true,
+          createdByUser: {
+            name: true,
+            email: true,
+          },
+        },
+        sort: {
+          createdAt: SortOrder.Ascending,
+        },
+        limit: 100,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return {
+      scheduledMaintenance,
+      stateTimeline,
+      internalNotes,
+      publicNotes,
+    };
+  }
+
+  @CaptureSpan()
+  public static formatScheduledMaintenanceContextForNote(
+    contextData: ScheduledMaintenanceContextData,
+    noteType: "public" | "internal",
+    template?: string,
+  ): AIGenerationContext {
+    const { scheduledMaintenance, stateTimeline, internalNotes, publicNotes } =
+      contextData;
+
+    let contextText: string = "";
+
+    // Basic scheduled maintenance information
+    contextText += "# Scheduled Maintenance Information\n\n";
+    contextText += `**Title:** ${scheduledMaintenance.title || "N/A"}\n\n`;
+    contextText += `**Description:** ${scheduledMaintenance.description || "N/A"}\n\n`;
+    contextText += `**Current State:** ${scheduledMaintenance.currentScheduledMaintenanceState?.name || "N/A"}\n\n`;
+    contextText += `**Scheduled Start:** ${scheduledMaintenance.startsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.startsAt) : "N/A"}\n\n`;
+    contextText += `**Scheduled End:** ${scheduledMaintenance.endsAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.endsAt) : "N/A"}\n\n`;
+    contextText += `**Created At:** ${scheduledMaintenance.createdAt ? OneUptimeDate.getDateAsFormattedString(scheduledMaintenance.createdAt) : "N/A"}\n\n`;
+
+    // Affected monitors
+    if (
+      scheduledMaintenance.monitors &&
+      scheduledMaintenance.monitors.length > 0
+    ) {
+      contextText += "**Affected Monitors:** ";
+      contextText += scheduledMaintenance.monitors
+        .map((m: { name?: string }) => {
+          return m.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // Labels
+    if (scheduledMaintenance.labels && scheduledMaintenance.labels.length > 0) {
+      contextText += "**Labels:** ";
+      contextText += scheduledMaintenance.labels
+        .map((l: { name?: string }) => {
+          return l.name;
+        })
+        .join(", ");
+      contextText += "\n\n";
+    }
+
+    // State timeline
+    if (stateTimeline.length > 0) {
+      contextText += "# State Timeline\n\n";
+      for (const timeline of stateTimeline) {
+        const startTime: string = timeline.startsAt
+          ? OneUptimeDate.getDateAsFormattedString(timeline.startsAt)
+          : "N/A";
+        const stateName: string =
+          timeline.scheduledMaintenanceState?.name?.toString() || "Unknown";
+        const createdBy: string =
+          timeline.createdByUser?.name?.toString() ||
+          timeline.createdByUser?.email?.toString() ||
+          "System";
+
+        contextText += `- **${startTime}**: State changed to **${stateName}** by ${createdBy}\n`;
+      }
+      contextText += "\n";
+    }
+
+    // Include internal notes for context (for both note types)
+    if (internalNotes.length > 0) {
+      contextText += "# Internal Notes (Private)\n\n";
+      for (const note of internalNotes) {
+        const noteTime: string = note.createdAt
+          ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+          : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // Public notes
+    if (publicNotes.length > 0) {
+      contextText += "# Public Notes\n\n";
+      for (const note of publicNotes) {
+        const noteTime: string = note.postedAt
+          ? OneUptimeDate.getDateAsFormattedString(note.postedAt)
+          : note.createdAt
+            ? OneUptimeDate.getDateAsFormattedString(note.createdAt)
+            : "N/A";
+        const createdBy: string =
+          note.createdByUser?.name?.toString() ||
+          note.createdByUser?.email?.toString() ||
+          "Unknown";
+
+        contextText += `**[${noteTime}] ${createdBy}:**\n`;
+        contextText += `${note.note || "N/A"}\n\n`;
+      }
+    }
+
+    // System prompt for note generation
+    let systemPrompt: string;
+
+    if (noteType === "public") {
+      if (template) {
+        systemPrompt = `You are an expert technical communicator. Your task is to fill in a public scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Write in a professional, clear, and customer-friendly manner
+- Focus on what customers need to know: timing, impact, and what to expect
+- Avoid technical jargon - keep it understandable for non-technical readers
+- Be concise but informative
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+      } else {
+        systemPrompt = `You are an expert technical communicator. Your task is to generate a public scheduled maintenance note that will be visible to customers on the status page.
+
+The note should:
+1. Be written in a professional, customer-friendly tone
+2. Clearly communicate the current status of the maintenance
+3. Explain what work is being done and any impact on users
+4. Provide timing information (when it started, expected completion, etc.)
+5. Set appropriate expectations
+6. Be concise but informative
+
+DO NOT include:
+- Internal technical details that customers don't need
+- Confidential information
+- Excessive jargon
+
+Write in markdown format for better readability.`;
+      }
+    } else if (template) {
+      // Internal note with template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to fill in an internal scheduled maintenance note template based on the provided maintenance event data.
+
+CRITICAL INSTRUCTIONS:
+- You MUST use ONLY the exact template structure provided below
+- Fill in each section of the template with relevant information from the maintenance data
+- Do NOT add any new sections, headers, or content that is not part of the template
+- Do NOT add introductions, conclusions, or any text outside the template structure
+- Be technical and detailed - this is for the internal team
+- Include relevant technical details, progress updates, and observations
+
+TEMPLATE TO FILL (use this exact structure):
+
+${template}`;
+    } else {
+      // Internal note without template
+      systemPrompt = `You are an expert Site Reliability Engineer (SRE). Your task is to generate an internal scheduled maintenance note for the team.
+
+The note should:
+1. Provide technical details about the maintenance progress
+2. Document observations, findings, or actions taken
+3. Include any issues encountered or changes to the plan
+4. Be detailed enough to help team members understand the current status
+5. Use technical language appropriate for the engineering team
+
+Write in markdown format for better readability. Be thorough and technical.`;
+    }
+
+    // Build user message
+    const userMessage: string = template
+      ? `Fill in the template above using ONLY the following scheduled maintenance data. Output only the filled template, nothing else:\n\n${contextText}`
+      : `Based on the following scheduled maintenance data, please generate ${noteType === "public" ? "a customer-facing public" : "an internal technical"} maintenance note:\n\n${contextText}`;
+
+    // Build messages array
+    const messages: Array<LLMMessage> = [
+      {
+        role: "system",
+        content: systemPrompt,
+      },
+      {
+        role: "user",
+        content: userMessage,
+      },
+    ];
+
+    return {
+      contextText,
+      systemPrompt,
+      messages,
+    };
+  }
+}

package/Server/Utils/Workspace/MicrosoftTeams/MicrosoftTeams.ts

@@ -434,12 +434,89 @@ export default class MicrosoftTeamsUtil extends WorkspaceBase {
     return { actionType: actionType as MicrosoftTeamsActionType, actionValue };
   }
 
+  /**
+   * Converts markdown tables to HTML tables for Teams MessageCard.
+   * Teams MessageCard supports HTML in the text field.
+   */
+  private static convertMarkdownTablesToHtml(markdown: string): string {
+    // Regular expression to match markdown tables
+    const tableRegex: RegExp =
+      /(?:^|\n)((?:\|[^\n]+\|\n)+(?:\|[-:\s|]+\|\n)(?:\|[^\n]+\|\n?)+)/g;
+
+    return markdown.replace(
+      tableRegex,
+      (_match: string, table: string): string => {
+        const lines: Array<string> = table.trim().split("\n");
+
+        if (lines.length < 2) {
+          return table;
+        }
+
+        // Parse header row
+        const headerLine: string = lines[0] || "";
+        const headers: Array<string> = headerLine
+          .split("|")
+          .map((cell: string) => {
+            return cell.trim();
+          })
+          .filter((cell: string) => {
+            return cell.length > 0;
+          });
+
+        // Skip separator line (line with dashes) and get data rows
+        const dataRows: Array<string> = lines.slice(2);
+
+        // Build HTML table
+        let html: string =
+          '<table style="border-collapse: collapse; width: 100%;">';
+
+        // Header row
+        html += "<tr>";
+        for (const header of headers) {
+          html += `<th style="border: 1px solid #ddd; padding: 8px; background-color: #f2f2f2; text-align: left;"><strong>${header}</strong></th>`;
+        }
+        html += "</tr>";
+
+        // Data rows
+        for (const row of dataRows) {
+          const cells: Array<string> = row
+            .split("|")
+            .map((cell: string) => {
+              return cell.trim();
+            })
+            .filter((cell: string) => {
+              return cell.length > 0;
+            });
+
+          if (cells.length === 0) {
+            continue;
+          }
+
+          html += "<tr>";
+          for (const cell of cells) {
+            html += `<td style="border: 1px solid #ddd; padding: 8px;">${cell}</td>`;
+          }
+          html += "</tr>";
+        }
+
+        html += "</table>";
+
+        return "\n" + html + "\n";
+      },
+    );
+  }
+
   private static buildMessageCardFromMarkdown(markdown: string): JSONObject {
     /*
      * Teams MessageCard has limited markdown support. Headings like '##' are not supported
      * and single newlines can collapse. Convert common patterns to a structured card.
      */
-    const lines: Array<string> = markdown
+
+    // First, convert markdown tables to HTML
+    const markdownWithHtmlTables: string =
+      this.convertMarkdownTablesToHtml(markdown);
+
+    const lines: Array<string> = markdownWithHtmlTables
       .split("\n")
       .map((l: string) => {
         return l.trim();

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -1892,9 +1892,88 @@ export default class SlackUtil extends WorkspaceBase {
     return apiResult;
   }
 
+  /**
+   * Converts markdown tables to a Slack-friendly format.
+   * Since Slack's mrkdwn doesn't support tables, we convert them to
+   * a row-by-row format with bold headers.
+   */
+  private static convertMarkdownTablesToSlackFormat(markdown: string): string {
+    // Regular expression to match markdown tables
+    const tableRegex: RegExp =
+      /(?:^|\n)((?:\|[^\n]+\|\n)+(?:\|[-:\s|]+\|\n)(?:\|[^\n]+\|\n?)+)/g;
+
+    return markdown.replace(
+      tableRegex,
+      (_match: string, table: string): string => {
+        const lines: Array<string> = table.trim().split("\n");
+
+        if (lines.length < 2) {
+          return table;
+        }
+
+        // Parse header row
+        const headerLine: string = lines[0] || "";
+        const headers: Array<string> = headerLine
+          .split("|")
+          .map((cell: string) => {
+            return cell.trim();
+          })
+          .filter((cell: string) => {
+            return cell.length > 0;
+          });
+
+        /*
+         * Skip separator line (line with dashes)
+         * Find data rows (skip header and separator)
+         */
+        const dataRows: Array<string> = lines.slice(2);
+        const formattedRows: Array<string> = [];
+
+        for (let rowIndex: number = 0; rowIndex < dataRows.length; rowIndex++) {
+          const row: string = dataRows[rowIndex] || "";
+          const cells: Array<string> = row
+            .split("|")
+            .map((cell: string) => {
+              return cell.trim();
+            })
+            .filter((cell: string) => {
+              return cell.length > 0;
+            });
+
+          if (cells.length === 0) {
+            continue;
+          }
+
+          const rowParts: Array<string> = [];
+          for (
+            let cellIndex: number = 0;
+            cellIndex < cells.length;
+            cellIndex++
+          ) {
+            const header: string =
+              headers[cellIndex] || `Column ${cellIndex + 1}`;
+            const value: string = cells[cellIndex] || "";
+            rowParts.push(`*${header}:* ${value}`);
+          }
+
+          if (dataRows.length > 1) {
+            formattedRows.push(`_Row ${rowIndex + 1}_\n${rowParts.join("\n")}`);
+          } else {
+            formattedRows.push(rowParts.join("\n"));
+          }
+        }
+
+        return "\n" + formattedRows.join("\n\n") + "\n";
+      },
+    );
+  }
+
   @CaptureSpan()
   public static convertMarkdownToSlackRichText(markdown: string): string {
-    return SlackifyMarkdown(markdown);
+    // First convert tables to Slack-friendly format
+    const markdownWithConvertedTables: string =
+      this.convertMarkdownTablesToSlackFormat(markdown);
+    return SlackifyMarkdown(markdownWithConvertedTables);
   }
 
   @CaptureSpan()

package/Tests/Types/Domain.test.ts

@@ -13,22 +13,43 @@ describe("class Domain", () => {
     expect(new Domain("example.ac").domain).toBe("example.ac");
   });
   test("new Domain() should throw the BadDataException if domain is invalid", () => {
+    // No dot in domain
     expect(() => {
       return new Domain("example");
     }).toThrowError(BadDataException);
     expect(() => {
       new Domain("example");
     }).toThrowError(BadDataException);
+
+    // Invalid characters
     expect(() => {
       new Domain("example@com");
     }).toThrowError(BadDataException);
 
+    // TLD with numbers (invalid - TLD must be letters only)
+    expect(() => {
+      new Domain("example.c0m");
+    }).toThrowError(BadDataException);
+
+    // Single letter TLD (invalid - TLD must be at least 2 characters)
     expect(() => {
-      new Domain("example.invalid");
+      new Domain("example.c");
     }).toThrowError(BadDataException);
+
+    // Domain starting with hyphen
+    expect(() => {
+      new Domain("-example.com");
+    }).toThrowError(BadDataException);
+
+    // Domain ending with hyphen before TLD
+    expect(() => {
+      new Domain("example-.com");
+    }).toThrowError(BadDataException);
+
+    // Mutation to invalid domain
     expect(() => {
-      const validDomain: Domain = new Domain("example.valid");
-      validDomain.domain = "example.invalid";
+      const validDomain: Domain = new Domain("example.com");
+      validDomain.domain = "invalid";
     }).toThrowError(BadDataException);
   });
   test("Domain.domain should be mutable", () => {

package/Types/Domain.ts

@@ -18,33 +18,30 @@ export default class Domain extends DatabaseProperty {
   }
 
   public static isValidDomain(domain: string): boolean {
-    if (!domain.includes(".")) {
+    /*
+     * Regex-based domain validation
+     * - Each label (part between dots) must be 1-63 characters
+     * - Labels can contain alphanumeric characters and hyphens
+     * - Labels cannot start or end with a hyphen
+     * - TLD must be at least 2 characters and contain only letters
+     * - Total length should not exceed 253 characters
+     */
+
+    if (!domain || domain.length > 253) {
       return false;
     }
 
-    const firstTLDs: Array<string> =
-      "ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|be|bf|bg|bh|bi|bj|bm|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|cl|cm|cn|co|cr|cu|cv|cw|cx|cz|de|dj|dk|dm|do|dz|ec|ee|eg|es|et|eu|fi|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|im|in|io|iq|ir|is|it|je|jo|jp|kg|ki|km|kn|kp|kr|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|na|nc|ne|nf|ng|nl|no|nr|nu|nz|om|pa|pe|pf|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|yt".split(
-        "|",
-      );
-    const secondTLDs: Array<string> =
-      "ac|academy|accountant|accountants|actor|adult|aero|ag|agency|ai|airforce|am|amsterdam|apartments|app|archi|army|art|asia|associates|at|attorney|au|auction|auto|autos|baby|band|bar|barcelona|bargains|basketball|bayern|be|beauty|beer|berlin|best|bet|bid|bike|bingo|bio|biz|biz.pl|black|blog|blue|boats|boston|boutique|broker|build|builders|business|buzz|bz|ca|cab|cafe|camera|camp|capital|car|cards|care|careers|cars|casa|cash|casino|catering|cc|center|ceo|ch|charity|chat|cheap|church|city|cl|claims|cleaning|clinic|clothing|cloud|club|cn|co|co.in|co.jp|co.kr|co.nz|co.uk|co.za|coach|codes|coffee|college|com|com.ag|com.au|com.br|com.bz|com.cn|com.co|com.es|com.ky|com.mx|com.pe|com.ph|com.pl|com.ru|com.tw|community|company|computer|condos|construction|consulting|contact|contractors|cooking|cool|country|coupons|courses|credit|creditcard|cricket|cruises|cymru|cz|dance|date|dating|de|deals|degree|delivery|democrat|dental|dentist|design|dev|diamonds|digital|direct|directory|discount|dk|doctor|dog|domains|download|earth|education|email|energy|engineer|engineering|enterprises|equipment|es|estate|eu|events|exchange|expert|exposed|express|fail|faith|family|fan|fans|farm|fashion|film|finance|financial|firm.in|fish|fishing|fit|fitness|flights|florist|fm|football|forsale|foundation|fr|fun|fund|furniture|futbol|fyi|gallery|games|garden|gay|gen.in|gg|gifts|gives|giving|glass|global|gmbh|gold|golf|graphics|gratis|green|gripe|group|gs|guide|guru|hair|haus|health|healthcare|hockey|holdings|holiday|homes|horse|hospital|host|house|idv.tw|immo|immobilien|in|inc|ind.in|industries|info|info.pl|ink|institute|insure|international|investments|io|irish|ist|istanbul|it|jetzt|jewelry|jobs|jp|kaufen|kids|kim|kitchen|kiwi|kr|ky|la|land|lat|law|lawyer|lease|legal|lgbt|life|lighting|limited|limo|live|llc|llp|loan|loans|london|love|ltd|ltda|luxury|maison|makeup|management|market|marketing|mba|me|me.uk|media|melbourne|memorial|men|menu|miami|mobi|moda|moe|money|monster|mortgage|motorcycles|movie|ms|music|mx|nagoya|name|navy|ne.kr|net|net.ag|net.au|net.br|net.bz|net.cn|net.co|net.in|net.ky|net.nz|net.pe|net.ph|net.pl|net.ru|network|news|ninja|nl|no|nom.co|nom.es|nom.pe|nrw|nyc|okinawa|one|onl|online|org|org.ag|org.au|org.cn|org.es|org.in|org.ky|org.nz|org.pe|org.ph|org.pl|org.ru|org.uk|organic|page|paris|partners|parts|party|pe|pet|ph|photography|photos|pictures|pink|pizza|pl|place|plumbing|plus|poker|porn|press|pro|productions|promo|properties|protection|pub|pw|quebec|quest|racing|re.kr|realestate|recipes|red|rehab|reise|reisen|rent|rentals|repair|report|republican|rest|restaurant|review|reviews|rich|rip|rocks|rodeo|rugby|run|ryukyu|sale|salon|sarl|school|schule|science|se|security|services|sex|sg|sh|shiksha|shoes|shop|shopping|show|singles|site|ski|skin|soccer|social|software|solar|solutions|space|storage|store|stream|studio|study|style|supplies|supply|support|surf|surgery|sydney|systems|tax|taxi|team|tech|technology|tel|tennis|theater|theatre|tickets|tienda|tips|tires|today|tokyo|tools|tours|town|toys|trade|trading|training|travel|tube|tv|tw|uk|university|uno|us|vacations|vc|vegas|ventures|vet|viajes|video|villas|vin|vip|vision|vodka|vote|voto|voyage|wales|watch|web|webcam|website|wedding|wiki|win|wine|work|works|world|ws|wtf|xxx|xyz|yachts|yoga|yokohama|zone|移动|dev|com|edu|gov|net|mil|org|nom|sch|sbs|caa|res|off|gob|int|tur|ip6|uri|urn|asn|act|nsw|qld|tas|vic|pro|biz|adm|adv|agr|arq|art|ato|bio|bmd|cim|cng|cnt|ecn|eco|emp|eng|esp|etc|eti|far|fnd|fot|fst|g12|ggf|imb|ind|inf|jor|jus|leg|lel|mat|med|mus|not|ntr|odo|ppg|psc|psi|qsl|rec|slg|srv|teo|tmp|trd|vet|zlg|web|ltd|sld|pol|fin|k12|lib|pri|aip|fie|eun|sci|prd|cci|pvt|mod|idv|rel|sex|gen|nic|abr|bas|cal|cam|emr|fvg|laz|lig|lom|mar|mol|pmn|pug|sar|sic|taa|tos|umb|vao|vda|ven|mie|北海道|和歌山|神奈川|鹿児島|ass|rep|tra|per|ngo|soc|grp|plc|its|air|and|bus|can|ddr|jfk|mad|nrw|nyc|ski|spy|tcm|ulm|usa|war|fhs|vgs|dep|eid|fet|fla|flå|gol|hof|hol|sel|vik|cri|iwi|ing|abo|fam|gok|gon|gop|gos|aid|atm|gsm|sos|elk|waw|est|aca|bar|cpa|jur|law|sec|plo|www|bir|cbg|jar|khv|msk|nov|nsk|ptz|rnd|spb|stv|tom|tsk|udm|vrn|cmw|kms|nkz|snz|pub|fhv|red|ens|nat|rns|rnu|bbs|tel|bel|kep|nhs|dni|fed|isa|nsn|gub|e12|tec|орг|обр|упр|alt|nis|jpn|mex|ath|iki|nid|gda|inc|za|ovh|lol|africa|top|coop".split(
-        "|",
-      );
-
-    const parts: Array<string> = domain.split(".");
-    const lastItem: string = parts[parts.length - 1] as string;
-    const beforeLastItem: string = parts[parts.length - 2] as string;
-
-    if (firstTLDs.includes(lastItem)) {
-      if (secondTLDs.includes(beforeLastItem)) {
-        return true;
-      }
-      return true;
-    } else if (secondTLDs.includes(lastItem)) {
-      return true;
-    }
-
-    return false;
+    /*
+     * Domain validation regex:
+     * ^                                          - start of string
+     * (?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+  - one or more labels followed by dot
+     * [a-zA-Z]{2,63}                             - TLD: 2-63 letters only
+     * $                                          - end of string
+     */
+    const domainRegex: RegExp =
+      /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
+
+    return domainRegex.test(domain);
   }
 
   public constructor(domain: string) {