@oneuptime/common 10.0.70 → 10.0.71

package/Models/DatabaseModels/KubernetesCluster.ts

@@ -73,10 +73,12 @@ import {
 })
 @CrudApiEndpoint(new Route("/kubernetes-cluster"))
 @SlugifyColumn("name", "slug")
-// Enforce one cluster row per (projectId, clusterIdentifier) at the DB level.
-// Without this, two pods emitting OTel telemetry for a new cluster at the
-// same time (e.g. when the agent is first installed or during a rolling
-// update) race in findOrCreateByClusterIdentifier and create duplicate rows.
+/*
+ * Enforce one cluster row per (projectId, clusterIdentifier) at the DB level.
+ * Without this, two pods emitting OTel telemetry for a new cluster at the
+ * same time (e.g. when the agent is first installed or during a rolling
+ * update) race in findOrCreateByClusterIdentifier and create duplicate rows.
+ */
 @Index(["projectId", "clusterIdentifier"], { unique: true })
 @TableMetadata({
   tableName: "KubernetesCluster",

package/Models/DatabaseModels/Project.ts

@@ -342,15 +342,15 @@ export default class Project extends TenantModel {
     update: [Permission.ProjectOwner, Permission.ManageProjectBilling],
   })
   @TableColumn({
-    type: TableColumnType.Email,
+    type: TableColumnType.LongText,
     title: "Finance / Accounting Email",
     description:
-      "Invoices, receipts and billing related notifications will be sent to this email in addition to project owner.",
-    example: "accounting@example.com",
+      "Invoices, receipts and billing related notifications will be sent to these emails in addition to project owner. Separate multiple emails with a comma.",
+    example: "accounting@example.com, finance@example.com",
   })
   @Column({
-    type: ColumnType.Email,
-    length: ColumnLength.Email,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
     nullable: true,
     unique: false,
   })

package/Server/Infrastructure/Postgres/SchemaMigrations/1776881254913-DedupeKubernetesClustersAndAddUniqueIndex.ts

@@ -26,7 +26,8 @@ import { MigrationInterface, QueryRunner } from "typeorm";
 export class DedupeKubernetesClustersAndAddUniqueIndex1776881254913
   implements MigrationInterface
 {
-  public name: string = "DedupeKubernetesClustersAndAddUniqueIndex1776881254913";
+  public name: string =
+    "DedupeKubernetesClustersAndAddUniqueIndex1776881254913";
 
   public async up(queryRunner: QueryRunner): Promise<void> {
     // 1: reparent KubernetesResource FKs from duplicates -> survivor.
@@ -128,7 +129,9 @@ export class DedupeKubernetesClustersAndAddUniqueIndex1776881254913
     await queryRunner.query(
       `DROP INDEX "public"."IDX_9756988b48848f4f7532a2af0d"`,
     );
-    // Duplicate rows dropped in up() are lost — a down-migration cannot
-    // resurrect them (and reinstating duplicates is not desirable anyway).
+    /*
+     * Duplicate rows dropped in up() are lost — a down-migration cannot
+     * resurrect them (and reinstating duplicates is not desirable anyway).
+     */
   }
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1776886248361-MigrationName.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1776886248361 implements MigrationInterface {
+  public name = "MigrationName1776886248361";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ALTER COLUMN "financeAccountingEmail" TYPE character varying(500)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ALTER COLUMN "financeAccountingEmail" TYPE character varying(100)`,
+    );
+  }
+}

package/Server/Services/AIBillingService.ts

@@ -94,8 +94,8 @@ export class AIBillingService extends BaseService {
         amountInUSD,
         {
           sendInvoiceByEmail: project.sendInvoicesByEmail || false,
-          recipientEmail: project.financeAccountingEmail
-            ? new Email(project.financeAccountingEmail)
+          recipientEmails: project.financeAccountingEmail
+            ? Email.parseList(project.financeAccountingEmail)
             : undefined,
           projectId: project.id || undefined,
         },

package/Server/Services/BillingService.ts

@@ -138,13 +138,37 @@ export class BillingService extends BaseService {
       line2 = rest.substring(0, 200);
     }
 
+    /*
+     * financeAccountingEmail may be a comma/semicolon-separated list. Parse the first
+     * valid address for Stripe (which stores a single email), and keep the full list
+     * in metadata so OneUptime can fan out invoice emails to every recipient.
+     */
+    const parsedEmails: Array<Email> = financeAccountingEmail
+      ? (() => {
+          try {
+            return Email.parseList(financeAccountingEmail);
+          } catch (err) {
+            logger.error(
+              `[Invoice Email] Failed to parse financeAccountingEmail for customer ${id}: ${err}`,
+            );
+            return [];
+          }
+        })()
+      : [];
+
+    const normalizedEmailList: string = parsedEmails
+      .map((e: Email): string => {
+        return e.toString();
+      })
+      .join(", ");
+
     const metadata: Record<string, string> = {
       business_details_full: businessDetails.substring(0, 5000),
     };
-    if (financeAccountingEmail) {
-      metadata["finance_accounting_email"] = financeAccountingEmail.substring(
+    if (normalizedEmailList) {
+      metadata["finance_accounting_email"] = normalizedEmailList.substring(
         0,
-        200,
+        500,
       );
     } else {
       // Remove if cleared
@@ -165,11 +189,11 @@ export class BillingService extends BaseService {
     };
 
     /*
-     * If finance / accounting email provided, set it as the customer email so Stripe sends
-     * invoices / receipts there. (Stripe only supports a single email via API currently.)
+     * Stripe's customer.email only accepts one address. Use the first parsed email;
+     * the rest are delivered by OneUptime's own webhook-driven invoice email path.
      */
-    if (financeAccountingEmail && financeAccountingEmail.trim().length > 0) {
-      updateParams.email = financeAccountingEmail.trim();
+    if (parsedEmails.length > 0) {
+      updateParams.email = parsedEmails[0]!.toString();
     }
 
     if (line1) {
@@ -956,11 +980,16 @@ export class BillingService extends BaseService {
   @CaptureSpan()
   public async sendInvoiceByEmail(
     invoiceId: string,
-    recipientEmail?: Email,
+    recipientEmails?: Array<Email>,
     projectId?: ObjectID,
   ): Promise<void> {
+    const recipientsForLog: string = (recipientEmails || [])
+      .map((e: Email): string => {
+        return e.toString();
+      })
+      .join(", ");
     logger.debug(
-      `[Invoice Email] sendInvoiceByEmail called for invoice: ${invoiceId}, recipientEmail: ${recipientEmail?.toString()}`,
+      `[Invoice Email] sendInvoiceByEmail called for invoice: ${invoiceId}, recipients: ${recipientsForLog}`,
     );
 
     if (!this.isBillingEnabled()) {
@@ -986,13 +1015,22 @@ export class BillingService extends BaseService {
         return;
       }
 
-      // Determine recipient email
-      let toEmail: Email | undefined = recipientEmail;
-      if (!toEmail && stripeInvoice.customer_email) {
-        toEmail = new Email(stripeInvoice.customer_email);
+      /*
+       * Determine recipient list. Fall back to the invoice's customer email when no
+       * explicit recipients were supplied by the caller.
+       */
+      let toEmails: Array<Email> = recipientEmails || [];
+      if (toEmails.length === 0 && stripeInvoice.customer_email) {
+        try {
+          toEmails = Email.parseList(stripeInvoice.customer_email);
+        } catch (err) {
+          logger.error(
+            `[Invoice Email] Failed to parse Stripe customer_email "${stripeInvoice.customer_email}" for invoice ${invoiceId}: ${err}`,
+          );
+        }
       }
 
-      if (!toEmail) {
+      if (toEmails.length === 0) {
         logger.error(
           `[Invoice Email] No recipient email found for invoice ${invoiceId}`,
           { projectId: projectId?.toString() } as LogAttributes,
@@ -1021,33 +1059,41 @@ export class BillingService extends BaseService {
         dashboardLink = `${DashboardClientUrl.toString()}/dashboard/${projectId.toString()}/settings/billing`;
       }
 
-      logger.debug(
-        `[Invoice Email] Sending invoice email to ${toEmail.toString()} - Invoice #${invoiceNumber}, Amount: ${amount}`,
-      );
-
-      // Send email via OneUptime MailService
-      await MailService.sendMail(
-        {
-          toEmail: toEmail,
-          templateType: EmailTemplateType.Invoice,
-          vars: {
-            invoiceNumber: invoiceNumber,
-            invoiceDate: invoiceDate,
-            amount: amount,
-            description: description || "",
-            invoicePdfUrl: invoicePdfUrl || "",
-            dashboardLink: dashboardLink || "",
-          },
-          subject: `Invoice #${invoiceNumber} from OneUptime`,
-        },
-        {
-          projectId: projectId,
-        },
-      );
+      for (const toEmail of toEmails) {
+        logger.debug(
+          `[Invoice Email] Sending invoice email to ${toEmail.toString()} - Invoice #${invoiceNumber}, Amount: ${amount}`,
+        );
+        try {
+          await MailService.sendMail(
+            {
+              toEmail: toEmail,
+              templateType: EmailTemplateType.Invoice,
+              vars: {
+                invoiceNumber: invoiceNumber,
+                invoiceDate: invoiceDate,
+                amount: amount,
+                description: description || "",
+                invoicePdfUrl: invoicePdfUrl || "",
+                dashboardLink: dashboardLink || "",
+              },
+              subject: `Invoice #${invoiceNumber} from OneUptime`,
+            },
+            {
+              projectId: projectId,
+            },
+          );
 
-      logger.debug(
-        `[Invoice Email] Successfully sent invoice ${invoiceId} email to ${toEmail.toString()}`,
-      );
+          logger.debug(
+            `[Invoice Email] Successfully sent invoice ${invoiceId} email to ${toEmail.toString()}`,
+          );
+        } catch (perRecipientErr) {
+          // Keep going for the remaining recipients if one fails.
+          logger.error(
+            `[Invoice Email] Failed to send invoice ${invoiceId} to ${toEmail.toString()}: ${perRecipientErr}`,
+            { projectId: projectId?.toString() } as LogAttributes,
+          );
+        }
+      }
     } catch (err) {
       logger.error(
         `[Invoice Email] Failed to send invoice ${invoiceId} by email: ${err}`,
@@ -1108,16 +1154,21 @@ export class BillingService extends BaseService {
     amountInUsd: number,
     options?: {
       sendInvoiceByEmail?: boolean | undefined;
-      recipientEmail?: Email | undefined;
+      recipientEmails?: Array<Email> | undefined;
       projectId?: ObjectID | undefined;
     },
   ): Promise<void> {
     const sendInvoiceByEmail: boolean = options?.sendInvoiceByEmail || false;
-    const recipientEmail: Email | undefined = options?.recipientEmail;
+    const recipientEmails: Array<Email> | undefined = options?.recipientEmails;
     const projectId: ObjectID | undefined = options?.projectId;
 
+    const recipientsForLog: string = (recipientEmails || [])
+      .map((e: Email): string => {
+        return e.toString();
+      })
+      .join(", ");
     logger.debug(
-      `[Invoice Email] generateInvoiceAndChargeCustomer called - customer: ${customerId}, amount: $${amountInUsd}, sendInvoiceByEmail: ${sendInvoiceByEmail}, recipientEmail: ${recipientEmail?.toString()}, projectId: ${projectId?.toString()}`,
+      `[Invoice Email] generateInvoiceAndChargeCustomer called - customer: ${customerId}, amount: $${amountInUsd}, sendInvoiceByEmail: ${sendInvoiceByEmail}, recipients: ${recipientsForLog}, projectId: ${projectId?.toString()}`,
     );
 
     const invoice: Stripe.Invoice = await this.stripe.invoices.create({
@@ -1161,7 +1212,7 @@ export class BillingService extends BaseService {
         logger.debug(
           `[Invoice Email] sendInvoiceByEmail is true, sending invoice ${invoice.id} by email`,
         );
-        await this.sendInvoiceByEmail(invoice.id!, recipientEmail, projectId);
+        await this.sendInvoiceByEmail(invoice.id!, recipientEmails, projectId);
       } else {
         logger.debug(
           `[Invoice Email] sendInvoiceByEmail is false, skipping email for invoice ${invoice.id}`,
@@ -1356,16 +1407,33 @@ export class BillingService extends BaseService {
             },
           });
 
-          let recipientEmail: Email | undefined = undefined;
+          let recipientEmails: Array<Email> | undefined = undefined;
           let projectId: ObjectID | undefined = undefined;
 
           if (project) {
             projectId = project.id || undefined;
             if (project.financeAccountingEmail) {
-              recipientEmail = new Email(project.financeAccountingEmail);
+              try {
+                recipientEmails = Email.parseList(
+                  project.financeAccountingEmail,
+                );
+              } catch (parseErr) {
+                /*
+                 * Log and fall back to Stripe customer email rather than dropping
+                 * the invoice delivery entirely due to a malformed address.
+                 */
+                logger.error(
+                  `[Invoice Email] Failed to parse financeAccountingEmail for project ${projectId?.toString()}: ${parseErr}`,
+                );
+              }
             }
+            const parsedForLog: string = (recipientEmails || [])
+              .map((e: Email): string => {
+                return e.toString();
+              })
+              .join(", ");
             logger.debug(
-              `[Invoice Email] Found project ${projectId?.toString()}, financeAccountingEmail: ${recipientEmail?.toString()}`,
+              `[Invoice Email] Found project ${projectId?.toString()}, financeAccountingEmail recipients: ${parsedForLog}`,
             );
           } else {
             logger.debug(
@@ -1376,7 +1444,7 @@ export class BillingService extends BaseService {
           logger.debug(
             `[Invoice Email] Sending invoice ${invoice.id} by email`,
           );
-          await this.sendInvoiceByEmail(invoice.id, recipientEmail, projectId);
+          await this.sendInvoiceByEmail(invoice.id, recipientEmails, projectId);
           logger.debug(
             `[Invoice Email] Successfully processed invoice.finalized - sent invoice ${invoice.id} by email`,
           );

package/Server/Services/NotificationService.ts

@@ -90,8 +90,8 @@ export class NotificationService extends BaseService {
         amountInUSD,
         {
           sendInvoiceByEmail: project.sendInvoicesByEmail || false,
-          recipientEmail: project.financeAccountingEmail
-            ? new Email(project.financeAccountingEmail)
+          recipientEmails: project.financeAccountingEmail
+            ? Email.parseList(project.financeAccountingEmail)
             : undefined,
           projectId: project.id || undefined,
         },

package/Server/Types/Database/QueryUtil.ts

@@ -212,8 +212,10 @@ export default class QueryUtil {
               relationColumnName: manyToManyMeta.relationColumnName,
             });
 
-            // Remove the relation-based filter so TypeORM does not create a
-            // JOIN that would yield OR semantics.
+            /*
+             * Remove the relation-based filter so TypeORM does not create a
+             * JOIN that would yield OR semantics.
+             */
             delete query[key];
 
             const existingIdFilter: any = (query as any)._id;
@@ -445,11 +447,13 @@ export default class QueryUtil {
       return null;
     }
 
-    // Only the owning side of a many-to-many has join/inverse columns. Follow
-    // the inverse relation when needed.
+    /*
+     * Only the owning side of a many-to-many has join/inverse columns. Follow
+     * the inverse relation when needed.
+     */
     const owningRelation: RelationMetadata = relation.isOwning
       ? relation
-      : (relation.inverseRelation ?? relation);
+      : relation.inverseRelation ?? relation;
 
     const joinTableName: string | undefined =
       owningRelation.junctionEntityMetadata?.tableName;
@@ -458,8 +462,10 @@ export default class QueryUtil {
       return null;
     }
 
-    // When `modelType` is the owning side, its id lives on joinColumns. When
-    // it is the inverse side, its id lives on inverseJoinColumns.
+    /*
+     * When `modelType` is the owning side, its id lives on joinColumns. When
+     * it is the inverse side, its id lives on inverseJoinColumns.
+     */
     const ownerColumns: Array<any> = relation.isOwning
       ? owningRelation.joinColumns
       : owningRelation.inverseJoinColumns;

package/Server/Utils/Monitor/MonitorAlert.ts

@@ -16,7 +16,9 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticAlertCreation } from "../../EnvironmentConfig";
 import AlertService from "../../Services/AlertService";
 import AlertSeverityService from "../../Services/AlertSeverityService";
+import AlertStateService from "../../Services/AlertStateService";
 import AlertStateTimelineService from "../../Services/AlertStateTimelineService";
+import AlertState from "../../../Models/DatabaseModels/AlertState";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -51,6 +53,7 @@ export default class MonitorAlert {
         projectId: true,
         alertNumber: true,
         alertNumberWithPrefix: true,
+        currentAlertStateId: true,
       },
       props: {
         isRoot: true,
@@ -328,6 +331,82 @@ export default class MonitorAlert {
         input.openAlert.projectId!,
       );
 
+    /*
+     * Skip the Resolved insert if the alert's timeline is already at or past
+     * the Resolved state in the project's workflow order. Two cases:
+     *  1. Latest timeline state is Resolved but Alert.currentAlertStateId is
+     *     stuck on an earlier state (partial-failure from a prior resolve).
+     *     Re-inserting Resolved would throw "Alert state cannot be same as
+     *     previous state" from AlertStateTimelineService.onBeforeCreate.
+     *  2. The project defines a custom state after Resolved (e.g. Closed) and
+     *     the alert has moved into it. Inserting Resolved would throw
+     *     "cannot transition to Resolved from Closed because Resolved is
+     *     before Closed in the order of alert states."
+     * Either failure bubbles up through ingest workers and causes monitors to
+     * flap. Reconcile Alert.currentAlertStateId if out of sync with the
+     * timeline, then return.
+     */
+    const [resolvedState, latestTimeline]: [
+      AlertState | null,
+      AlertStateTimeline | null,
+    ] = await Promise.all([
+      AlertStateService.findOneBy({
+        query: {
+          _id: resolvedStateId.toString(),
+        },
+        select: {
+          order: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      }),
+      AlertStateTimelineService.findOneBy({
+        query: {
+          alertId: input.openAlert.id!,
+        },
+        sort: {
+          startsAt: SortOrder.Descending,
+        },
+        select: {
+          alertStateId: true,
+          alertState: {
+            order: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      }),
+    ]);
+
+    const latestOrder: number | undefined | null =
+      latestTimeline?.alertState?.order;
+    const resolvedOrder: number | undefined | null = resolvedState?.order;
+
+    if (
+      latestTimeline?.alertStateId &&
+      typeof latestOrder === "number" &&
+      typeof resolvedOrder === "number" &&
+      latestOrder >= resolvedOrder
+    ) {
+      if (
+        input.openAlert.currentAlertStateId?.toString() !==
+        latestTimeline.alertStateId.toString()
+      ) {
+        await AlertService.updateOneById({
+          id: input.openAlert.id!,
+          data: {
+            currentAlertStateId: latestTimeline.alertStateId,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+      return;
+    }
+
     const alertStateTimeline: AlertStateTimeline = new AlertStateTimeline();
     alertStateTimeline.alertId = input.openAlert.id!;
     alertStateTimeline.alertStateId = resolvedStateId;

package/Server/Utils/Monitor/MonitorIncident.ts

@@ -17,8 +17,10 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import { DisableAutomaticIncidentCreation } from "../../EnvironmentConfig";
 import IncidentService from "../../Services/IncidentService";
 import IncidentSeverityService from "../../Services/IncidentSeverityService";
+import IncidentStateService from "../../Services/IncidentStateService";
 import IncidentStateTimelineService from "../../Services/IncidentStateTimelineService";
 import IncidentMemberService from "../../Services/IncidentMemberService";
+import IncidentState from "../../../Models/DatabaseModels/IncidentState";
 import logger, { LogAttributes } from "../Logger";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import DataToProcess from "./DataToProcess";
@@ -57,6 +59,7 @@ export default class MonitorIncident {
         projectId: true,
         incidentNumber: true,
         incidentNumberWithPrefix: true,
+        currentIncidentStateId: true,
       },
       props: {
         isRoot: true,
@@ -393,6 +396,82 @@ export default class MonitorIncident {
         input.openIncident.projectId!,
       );
 
+    /*
+     * Skip the Resolved insert if the incident's timeline is already at or
+     * past the Resolved state in the project's workflow order. Two cases:
+     *  1. Latest timeline state is Resolved but Incident.currentIncidentStateId
+     *     is stuck on an earlier state (partial-failure from a prior resolve).
+     *     Re-inserting Resolved would throw "state cannot be same as previous"
+     *     from IncidentStateTimelineService.onBeforeCreate.
+     *  2. The project defines a custom state after Resolved (e.g. Closed) and
+     *     the incident has moved into it. Inserting Resolved would throw
+     *     "cannot transition to Resolved from Closed because Resolved is
+     *     before Closed in the order of incident states."
+     * Either failure bubbles up through ingest workers and causes monitors to
+     * flap. Reconcile Incident.currentIncidentStateId if out of sync with the
+     * timeline, then return.
+     */
+    const [resolvedState, latestTimeline]: [
+      IncidentState | null,
+      IncidentStateTimeline | null,
+    ] = await Promise.all([
+      IncidentStateService.findOneBy({
+        query: {
+          _id: resolvedStateId.toString(),
+        },
+        select: {
+          order: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      }),
+      IncidentStateTimelineService.findOneBy({
+        query: {
+          incidentId: input.openIncident.id!,
+        },
+        sort: {
+          startsAt: SortOrder.Descending,
+        },
+        select: {
+          incidentStateId: true,
+          incidentState: {
+            order: true,
+          },
+        },
+        props: {
+          isRoot: true,
+        },
+      }),
+    ]);
+
+    const latestOrder: number | undefined | null =
+      latestTimeline?.incidentState?.order;
+    const resolvedOrder: number | undefined | null = resolvedState?.order;
+
+    if (
+      latestTimeline?.incidentStateId &&
+      typeof latestOrder === "number" &&
+      typeof resolvedOrder === "number" &&
+      latestOrder >= resolvedOrder
+    ) {
+      if (
+        input.openIncident.currentIncidentStateId?.toString() !==
+        latestTimeline.incidentStateId.toString()
+      ) {
+        await IncidentService.updateOneById({
+          id: input.openIncident.id!,
+          data: {
+            currentIncidentStateId: latestTimeline.incidentStateId,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+      return;
+    }
+
     const incidentStateTimeline: IncidentStateTimeline =
       new IncidentStateTimeline();
     incidentStateTimeline.incidentId = input.openIncident.id!;

package/Types/BaseDatabase/IncludesNone.ts

@@ -4,10 +4,7 @@ import JSONFunctions from "../JSONFunctions";
 import ObjectID from "../ObjectID";
 import QueryOperator from "./QueryOperator";
 
-export type IncludesNoneType =
-  | Array<string>
-  | Array<ObjectID>
-  | Array<number>;
+export type IncludesNoneType = Array<string> | Array<ObjectID> | Array<number>;
 
 export default class IncludesNone extends QueryOperator<IncludesNoneType> {
   private _values: IncludesNoneType = [];

package/Types/Email.ts

@@ -75,6 +75,56 @@ export default class Email extends DatabaseProperty {
     return new Email(value);
   }
 
+  public static parseList(value: string | null | undefined): Array<Email> {
+    if (!value) {
+      return [];
+    }
+
+    const seen: Set<string> = new Set<string>();
+    const emails: Array<Email> = [];
+
+    for (const part of value.split(/[,;\s]+/)) {
+      const trimmed: string = part.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const email: Email = new Email(trimmed);
+      const key: string = email.toString();
+      if (!seen.has(key)) {
+        seen.add(key);
+        emails.push(email);
+      }
+    }
+
+    return emails;
+  }
+
+  public static isValidList(value: string | null | undefined): boolean {
+    if (!value) {
+      return true;
+    }
+
+    const parts: Array<string> = value
+      .split(/[,;\s]+/)
+      .map((p: string): string => {
+        return p.trim();
+      })
+      .filter((p: string): boolean => {
+        return p.length > 0;
+      });
+
+    if (parts.length === 0) {
+      return false;
+    }
+
+    for (const part of parts) {
+      if (!Email.isValid(part)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   public static override fromJSON(json: JSONObject): Email {
     if (json["_type"] === ObjectType.Email) {
       return new Email((json["value"] as string) || "");