@oneuptime/common 13.0.6 → 13.0.7

package/Server/Services/AlertService.ts

@@ -28,7 +28,6 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import { JSONObject } from "../../Types/JSON";
 import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
-import Typeof from "../../Types/Typeof";
 import UserNotificationEventType from "../../Types/UserNotification/UserNotificationEventType";
 import Model from "../../Models/DatabaseModels/Alert";
 import AlertOwnerTeam from "../../Models/DatabaseModels/AlertOwnerTeam";
@@ -82,6 +81,7 @@ import AlertOwnerRuleEngineService from "./AlertOwnerRuleEngineService";
 import RunbookRuleEngineService from "./RunbookRuleEngineService";
 import AutoRemediationRuleEngineService from "./AutoRemediationRuleEngineService";
 import AIAlertInvestigationRunner from "../Utils/AI/SRE/AlertInvestigationRunner";
+import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import AlertPrivacyRuleEngineService from "./AlertPrivacyRuleEngineService";
 import ProjectService from "./ProjectService";
 
@@ -1264,37 +1264,18 @@ ${alert.remediationNotes || "No remediation notes provided."}
     notifyOwners: boolean,
     props: DatabaseCommonInteractionProps,
   ): Promise<void> {
-    for (let teamId of teamIds) {
-      if (typeof teamId === Typeof.String) {
-        teamId = new ObjectID(teamId.toString());
-      }
-
-      const teamOwner: AlertOwnerTeam = new AlertOwnerTeam();
-      teamOwner.alertId = alertId;
-      teamOwner.projectId = projectId;
-      teamOwner.teamId = teamId;
-      teamOwner.isOwnerNotified = !notifyOwners;
-
-      await AlertOwnerTeamService.create({
-        data: teamOwner,
-        props: props,
-      });
-    }
-
-    for (let userId of userIds) {
-      if (typeof userId === Typeof.String) {
-        userId = new ObjectID(userId.toString());
-      }
-      const teamOwner: AlertOwnerUser = new AlertOwnerUser();
-      teamOwner.alertId = alertId;
-      teamOwner.projectId = projectId;
-      teamOwner.userId = userId;
-      teamOwner.isOwnerNotified = !notifyOwners;
-      await AlertOwnerUserService.create({
-        data: teamOwner,
-        props: props,
-      });
-    }
+    // Owners already on the alert are skipped, not added a second time.
+    await OwnerRuleAssignment.addOwners({
+      ownerUserService: AlertOwnerUserService,
+      ownerTeamService: AlertOwnerTeamService,
+      resourceIdColumn: "alertId",
+      resourceId: alertId,
+      projectId: projectId,
+      userIds: userIds,
+      teamIds: teamIds,
+      isOwnerNotified: !notifyOwners,
+      props: props,
+    });
   }
 
   @CaptureSpan()

package/Server/Services/CephClusterOwnerRuleEngineService.ts

@@ -248,11 +248,15 @@ class CephClusterOwnerRuleEngineServiceClass
         owner.projectId = cephCluster.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await CephClusterOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: CephClusterOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -261,11 +265,15 @@ class CephClusterOwnerRuleEngineServiceClass
         owner.projectId = cephCluster.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await CephClusterOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: CephClusterOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/CloudResourceOwnerRuleEngineService.ts

@@ -251,11 +251,15 @@ class CloudResourceOwnerRuleEngineServiceClass
         owner.projectId = cloudResource.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await CloudResourceOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: CloudResourceOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -264,11 +268,15 @@ class CloudResourceOwnerRuleEngineServiceClass
         owner.projectId = cloudResource.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await CloudResourceOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: CloudResourceOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/DashboardOwnerRuleEngineService.ts

@@ -243,11 +243,15 @@ class DashboardOwnerRuleEngineServiceClass
         owner.projectId = dashboard.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await DashboardOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DashboardOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -256,11 +260,15 @@ class DashboardOwnerRuleEngineServiceClass
         owner.projectId = dashboard.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await DashboardOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DashboardOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/DatabaseService.ts

@@ -1420,6 +1420,8 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     // check uniqueColumns by:
     createBy = await this.checkUniqueColumnBy(createBy);
 
+    await this.checkUniqueColumnsTogether(createBy.data);
+
     // serialize.
     createBy.data = (await this.sanitizeCreateOrUpdate(
       createBy.data,
@@ -1583,8 +1585,14 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     }
 
     try {
+      /*
+       * A new row every time. getModel() is the owner service's own shared
+       * instance, and a save writes the generated _id back onto whatever it
+       * was handed - so reusing it would turn the next auto-owner insert into
+       * an update of this row.
+       */
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const ownerModel: any = entry.ownerUserService.getModel();
+      const ownerModel: any = new entry.ownerUserService.modelType();
       ownerModel[entry.fkColumn] = resourceId;
       ownerModel.userId = props.userId;
       ownerModel.projectId = projectId;
@@ -1594,6 +1602,14 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
         props: { isRoot: true },
       });
     } catch (err) {
+      /*
+       * The create form can name the creator as an owner too, and that path
+       * may have added them first. They are an owner either way.
+       */
+      if (PostgresErrorTranslator.isUniqueViolation(err)) {
+        return;
+      }
+
       logger.error(
         `auto-owner-on-create failed for ${modelName} ${resourceId.toString()}`,
       );
@@ -1778,6 +1794,90 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     return Promise.resolve(createBy);
   }
 
+  /*
+   * Enforces @UniqueColumnsTogether before the row is written, so a duplicate
+   * is rejected with the model's own message and never reaches
+   * onCreateSuccess (and whatever feed items or notifications it sends).
+   *
+   * A key column can arrive as its id column (`teamId`) or only as the
+   * relation that fills it (`team`), so both are read. When a value is
+   * missing altogether there is nothing to compare; the unique index decides.
+   */
+  private async checkUniqueColumnsTogether(data: TBaseModel): Promise<void> {
+    for (const constraint of this.model.getUniqueColumnsTogether()) {
+      const query: Dictionary<ObjectID | JSONValue> = {};
+      let isKeyComplete: boolean = true;
+
+      for (const columnName of constraint.columnNames) {
+        const value: ObjectID | JSONValue | null = this.getUniqueKeyValue(
+          data,
+          columnName,
+        );
+
+        if (value === null) {
+          isKeyComplete = false;
+          break;
+        }
+
+        query[columnName] = value;
+      }
+
+      if (!isKeyComplete) {
+        continue;
+      }
+
+      const count: PositiveNumber = await this.countBy({
+        query: query as Query<TBaseModel>,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (count.toNumber() > 0) {
+        throw PostgresErrorTranslator.createUniqueViolationException(
+          constraint.errorMessage,
+        );
+      }
+    }
+  }
+
+  private getUniqueKeyValue(
+    data: TBaseModel,
+    columnName: string,
+  ): ObjectID | JSONValue | null {
+    const metadata: TableColumnMetadata | undefined =
+      this.model.getTableColumnMetadata(columnName);
+
+    if (metadata?.type !== TableColumnType.ObjectID) {
+      const value: JSONValue = (data as any)[columnName];
+      return value === undefined || value === null ? null : value;
+    }
+
+    let id: string | null = RelationValueUtil.getRelationId(
+      (data as any)[columnName],
+    );
+
+    if (!id) {
+      const relationColumnName: string | undefined = this.model
+        .getTableColumns()
+        .columns.find((column: string): boolean => {
+          const relationMetadata: TableColumnMetadata =
+            this.model.getTableColumnMetadata(column);
+
+          return (
+            relationMetadata.type === TableColumnType.Entity &&
+            relationMetadata.manyToOneRelationColumn === columnName
+          );
+        });
+
+      if (relationColumnName) {
+        id = RelationValueUtil.getRelationId((data as any)[relationColumnName]);
+      }
+    }
+
+    return id ? new ObjectID(id) : null;
+  }
+
   @CaptureSpan()
   public async countBy({
     query,

package/Server/Services/DockerHostOwnerRuleEngineService.ts

@@ -246,11 +246,15 @@ class DockerHostOwnerRuleEngineServiceClass
         owner.projectId = dockerHost.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await DockerHostOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DockerHostOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -259,11 +263,15 @@ class DockerHostOwnerRuleEngineServiceClass
         owner.projectId = dockerHost.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await DockerHostOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DockerHostOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/DockerSwarmClusterOwnerRuleEngineService.ts

@@ -256,11 +256,15 @@ class DockerSwarmClusterOwnerRuleEngineServiceClass
         owner.projectId = dockerSwarmCluster.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await DockerSwarmClusterOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DockerSwarmClusterOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -270,11 +274,15 @@ class DockerSwarmClusterOwnerRuleEngineServiceClass
         owner.projectId = dockerSwarmCluster.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await DockerSwarmClusterOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: DockerSwarmClusterOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/HostOwnerRuleEngineService.ts

@@ -241,11 +241,15 @@ class HostOwnerRuleEngineServiceClass
         owner.projectId = host.projectId;
         owner.userId = new ObjectID(userId);
         owner.isOwnerNotified = !notify;
-        await HostOwnerUserService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: HostOwnerUserService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
 
       for (const teamId of teamIds) {
@@ -254,11 +258,15 @@ class HostOwnerRuleEngineServiceClass
         owner.projectId = host.projectId;
         owner.teamId = new ObjectID(teamId);
         owner.isOwnerNotified = !notify;
-        await HostOwnerTeamService.create({
-          data: owner,
-          props: { isRoot: true },
-        });
-        ownersAdded++;
+        if (
+          await OwnerRuleAssignment.createOwner({
+            ownerService: HostOwnerTeamService,
+            owner: owner,
+            props: { isRoot: true },
+          })
+        ) {
+          ownersAdded++;
+        }
       }
     }
 

package/Server/Services/IncidentEpisodeOwnerRuleEngineService.ts

@@ -316,8 +316,9 @@ class IncidentEpisodeOwnerRuleEngineServiceClass
       owner.projectId = data.projectId;
       owner.userId = new ObjectID(userId);
       owner.isOwnerNotified = true;
-      await IncidentEpisodeOwnerUserService.create({
-        data: owner,
+      await OwnerRuleAssignment.createOwner({
+        ownerService: IncidentEpisodeOwnerUserService,
+        owner: owner,
         props: { isRoot: true },
       });
     }
@@ -328,8 +329,9 @@ class IncidentEpisodeOwnerRuleEngineServiceClass
       owner.projectId = data.projectId;
       owner.teamId = new ObjectID(teamId);
       owner.isOwnerNotified = true;
-      await IncidentEpisodeOwnerTeamService.create({
-        data: owner,
+      await OwnerRuleAssignment.createOwner({
+        ownerService: IncidentEpisodeOwnerTeamService,
+        owner: owner,
         props: { isRoot: true },
       });
     }

package/Server/Services/IncidentEpisodeService.ts

@@ -42,6 +42,7 @@ import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import IncidentEpisodeWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/IncidentEpisode";
+import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
 import IncidentService from "./IncidentService";
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
@@ -1147,81 +1148,20 @@ export class Service extends DatabaseService<Model> {
   }): Promise<void> {
     const { episodeId, projectId, userIds, teamIds, createdByUserId } = data;
 
-    // Add user owners
-    if (userIds && userIds.length > 0) {
-      for (const userId of userIds) {
-        // Check if already exists
-        const existing: IncidentEpisodeOwnerUser | null =
-          await IncidentEpisodeOwnerUserService.findOneBy({
-            query: {
-              incidentEpisodeId: episodeId,
-              userId: userId,
-            },
-            props: {
-              isRoot: true,
-            },
-            select: {
-              _id: true,
-            },
-          });
-
-        if (!existing) {
-          const ownerUser: IncidentEpisodeOwnerUser =
-            new IncidentEpisodeOwnerUser();
-          ownerUser.incidentEpisodeId = episodeId;
-          ownerUser.userId = userId;
-          ownerUser.projectId = projectId;
-          if (createdByUserId) {
-            ownerUser.createdByUserId = createdByUserId;
-          }
-
-          await IncidentEpisodeOwnerUserService.create({
-            data: ownerUser,
-            props: {
-              isRoot: true,
-            },
-          });
-        }
-      }
-    }
-
-    // Add team owners
-    if (teamIds && teamIds.length > 0) {
-      for (const teamId of teamIds) {
-        // Check if already exists
-        const existing: IncidentEpisodeOwnerTeam | null =
-          await IncidentEpisodeOwnerTeamService.findOneBy({
-            query: {
-              incidentEpisodeId: episodeId,
-              teamId: teamId,
-            },
-            props: {
-              isRoot: true,
-            },
-            select: {
-              _id: true,
-            },
-          });
-
-        if (!existing) {
-          const ownerTeam: IncidentEpisodeOwnerTeam =
-            new IncidentEpisodeOwnerTeam();
-          ownerTeam.incidentEpisodeId = episodeId;
-          ownerTeam.teamId = teamId;
-          ownerTeam.projectId = projectId;
-          if (createdByUserId) {
-            ownerTeam.createdByUserId = createdByUserId;
-          }
-
-          await IncidentEpisodeOwnerTeamService.create({
-            data: ownerTeam,
-            props: {
-              isRoot: true,
-            },
-          });
-        }
-      }
-    }
+    // Owners already on the episode are skipped, not added a second time.
+    await OwnerRuleAssignment.addOwners({
+      ownerUserService: IncidentEpisodeOwnerUserService,
+      ownerTeamService: IncidentEpisodeOwnerTeamService,
+      resourceIdColumn: "incidentEpisodeId",
+      resourceId: episodeId,
+      projectId: projectId,
+      userIds: userIds || [],
+      teamIds: teamIds || [],
+      createdByUserId: createdByUserId,
+      props: {
+        isRoot: true,
+      },
+    });
   }
 
   @CaptureSpan()

package/Server/Services/IncidentGroupingEngineService.ts

@@ -13,6 +13,7 @@ import Monitor from "../../Models/DatabaseModels/Monitor";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
+import OwnerRuleAssignment from "../Utils/Rules/OwnerRuleAssignment";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import QueryHelper from "../Types/Database/QueryHelper";
@@ -948,8 +949,9 @@ class IncidentGroupingEngineServiceClass {
             ownerUser.projectId = incident.projectId!;
             ownerUser.incidentEpisodeId = createdEpisode.id;
             ownerUser.userId = user.id;
-            await IncidentEpisodeOwnerUserService.create({
-              data: ownerUser,
+            await OwnerRuleAssignment.createOwner({
+              ownerService: IncidentEpisodeOwnerUserService,
+              owner: ownerUser,
               props: {
                 isRoot: true,
               },
@@ -979,8 +981,9 @@ class IncidentGroupingEngineServiceClass {
             ownerTeam.projectId = incident.projectId!;
             ownerTeam.incidentEpisodeId = createdEpisode.id;
             ownerTeam.teamId = team.id;
-            await IncidentEpisodeOwnerTeamService.create({
-              data: ownerTeam,
+            await OwnerRuleAssignment.createOwner({
+              ownerService: IncidentEpisodeOwnerTeamService,
+              owner: ownerTeam,
               props: {
                 isRoot: true,
               },