@oneuptime/common 10.0.69 → 10.0.71

package/Server/Types/Database/QueryHelper.ts

@@ -138,6 +138,48 @@ export default class QueryHelper {
     );
   }
 
+  @CaptureSpan()
+  public static notContains(name: string): FindWhereProperty<any> {
+    name = name.toLowerCase().trim();
+    const rid: string = Text.generateRandomText(10);
+    return Raw(
+      (alias: string) => {
+        return `(CAST(${alias} AS TEXT) NOT ILIKE :${rid} OR ${alias} IS NULL)`;
+      },
+      {
+        [rid]: `%${name}%`,
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static startsWith(name: string): FindWhereProperty<any> {
+    name = name.toLowerCase().trim();
+    const rid: string = Text.generateRandomText(10);
+    return Raw(
+      (alias: string) => {
+        return `(CAST(${alias} AS TEXT) ILIKE :${rid})`;
+      },
+      {
+        [rid]: `${name}%`,
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public static endsWith(name: string): FindWhereProperty<any> {
+    name = name.toLowerCase().trim();
+    const rid: string = Text.generateRandomText(10);
+    return Raw(
+      (alias: string) => {
+        return `(CAST(${alias} AS TEXT) ILIKE :${rid})`;
+      },
+      {
+        [rid]: `%${name}`,
+      },
+    );
+  }
+
   @CaptureSpan()
   public static all(values: Array<string | ObjectID>): FindWhereProperty<any> {
     values = values.map((value: string | ObjectID) => {
@@ -168,6 +210,91 @@ export default class QueryHelper {
     return this.in(values); // any and in are the same
   }
 
+  /**
+   * Returns a filter that matches owner rows that are linked to *none* of the
+   * provided related entity ids through a many-to-many join table. The
+   * returned FindOperator is intended to be applied to the primary id column
+   * of the owner entity.
+   */
+  @CaptureSpan()
+  public static noneEntitiesInManyToMany(data: {
+    values: Array<string | ObjectID>;
+    joinTableName: string;
+    ownerColumnName: string;
+    relationColumnName: string;
+  }): FindWhereProperty<any> {
+    const values: Array<string> = data.values.map(
+      (value: string | ObjectID) => {
+        return value.toString();
+      },
+    );
+
+    if (!values || values.length === 0) {
+      return Raw(() => {
+        return `TRUE = TRUE`;
+      }, {});
+    }
+
+    const valuesRid: string = Text.generateRandomText(10);
+
+    const joinTable: string = data.joinTableName.replace(/"/g, '""');
+    const ownerCol: string = data.ownerColumnName.replace(/"/g, '""');
+    const relationCol: string = data.relationColumnName.replace(/"/g, '""');
+
+    return Raw(
+      (alias: string) => {
+        return `(${alias} NOT IN (SELECT "${joinTable}"."${ownerCol}" FROM "${joinTable}" WHERE "${joinTable}"."${relationCol}" IN (:...${valuesRid})))`;
+      },
+      {
+        [valuesRid]: values,
+      },
+    );
+  }
+
+  /**
+   * Returns a filter that matches owner rows that are linked to *all* of the
+   * provided related entity ids through a many-to-many join table. The
+   * returned FindOperator is intended to be applied to the primary id column
+   * of the owner entity.
+   */
+  @CaptureSpan()
+  public static allEntitiesInManyToMany(data: {
+    values: Array<string | ObjectID>;
+    joinTableName: string;
+    ownerColumnName: string;
+    relationColumnName: string;
+  }): FindWhereProperty<any> {
+    const values: Array<string> = data.values.map(
+      (value: string | ObjectID) => {
+        return value.toString();
+      },
+    );
+
+    if (!values || values.length === 0) {
+      return Raw(() => {
+        return `TRUE = FALSE`;
+      }, {});
+    }
+
+    const valuesRid: string = Text.generateRandomText(10);
+    const countRid: string = Text.generateRandomText(10);
+
+    // Escape identifiers so they can safely be embedded in the SQL string.
+    const joinTable: string = data.joinTableName.replace(/"/g, '""');
+    const ownerCol: string = data.ownerColumnName.replace(/"/g, '""');
+    const relationCol: string = data.relationColumnName.replace(/"/g, '""');
+
+    return Raw(
+      (alias: string) => {
+        return `(${alias} IN (SELECT "${joinTable}"."${ownerCol}" FROM "${joinTable}" WHERE "${joinTable}"."${relationCol}" IN (:...${valuesRid}) GROUP BY "${joinTable}"."${ownerCol}" HAVING COUNT(DISTINCT "${joinTable}"."${relationCol}") >= :${countRid}))`;
+      },
+      {
+        [valuesRid]: values,
+        [countRid]: values.length,
+      },
+    );
+  }
+
   private static in(
     values: Array<string | ObjectID | number>,
   ): FindWhereProperty<any> {

package/Server/Types/Database/QueryUtil.ts

@@ -6,6 +6,11 @@ import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesAll from "../../../Types/BaseDatabase/IncludesAll";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
+import StartsWith from "../../../Types/BaseDatabase/StartsWith";
+import EndsWith from "../../../Types/BaseDatabase/EndsWith";
+import NotContains from "../../../Types/BaseDatabase/NotContains";
 import IsNull from "../../../Types/BaseDatabase/IsNull";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
@@ -17,12 +22,16 @@ import TableColumnType from "../../../Types/Database/TableColumnType";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import Typeof from "../../../Types/Typeof";
+import { And, DataSource } from "typeorm";
 import { FindOperator } from "typeorm/find-options/FindOperator";
 import { CompareType } from "../../../Types/Database/CompareBase";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
 import GreaterThanOrNull from "../../../Types/BaseDatabase/GreaterThanOrNull";
 import EqualTo from "../../../Types/BaseDatabase/EqualTo";
+import PostgresAppInstance from "../../Infrastructure/PostgresDatabase";
+import { RelationMetadata } from "typeorm/metadata/RelationMetadata";
+import { EntityMetadata } from "typeorm/metadata/EntityMetadata";
 
 export default class QueryUtil {
   @CaptureSpan()
@@ -111,6 +120,30 @@ export default class QueryUtil {
         query[key] = QueryHelper.search(
           (query[key] as Search<string>).toString() as any,
         ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof NotContains &&
+        tableColumnMetadata
+      ) {
+        query[key] = QueryHelper.notContains(
+          (query[key] as NotContains<string>).toString() as any,
+        ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof StartsWith &&
+        tableColumnMetadata
+      ) {
+        query[key] = QueryHelper.startsWith(
+          (query[key] as StartsWith<string>).toString() as any,
+        ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof EndsWith &&
+        tableColumnMetadata
+      ) {
+        query[key] = QueryHelper.endsWith(
+          (query[key] as EndsWith<string>).toString() as any,
+        ) as any;
       } else if (
         query[key] &&
         query[key] instanceof LessThan &&
@@ -142,6 +175,140 @@ export default class QueryUtil {
         query[key] = QueryHelper.greaterThan(
           (query[key] as GreaterThan<CompareType>).toString() as any,
         ) as any;
+      } else if (
+        query[key] &&
+        query[key] instanceof IncludesAll &&
+        tableColumnMetadata
+      ) {
+        if (tableColumnMetadata.type === TableColumnType.EntityArray) {
+          const includesAll: IncludesAll = query[key] as IncludesAll;
+          const values: Array<string | ObjectID> = (
+            includesAll.values as Array<string | ObjectID | number>
+          ).map((item: string | ObjectID | number) => {
+            if (
+              item !== null &&
+              typeof item === Typeof.Object &&
+              !(item instanceof ObjectID)
+            ) {
+              const itemRecord: JSONObject = item as unknown as JSONObject;
+              if (itemRecord["_id"]) {
+                return itemRecord["_id"] as string;
+              }
+            }
+            return item.toString();
+          });
+
+          const manyToManyMeta: {
+            joinTableName: string;
+            ownerColumnName: string;
+            relationColumnName: string;
+          } | null = QueryUtil.getManyToManyRelationMetadata(modelType, key);
+
+          if (manyToManyMeta && values.length > 0) {
+            const subqueryFilter: any = QueryHelper.allEntitiesInManyToMany({
+              values,
+              joinTableName: manyToManyMeta.joinTableName,
+              ownerColumnName: manyToManyMeta.ownerColumnName,
+              relationColumnName: manyToManyMeta.relationColumnName,
+            });
+
+            /*
+             * 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;
+            if (existingIdFilter instanceof FindOperator) {
+              (query as any)._id = And(existingIdFilter, subqueryFilter);
+            } else if (
+              existingIdFilter &&
+              typeof existingIdFilter === Typeof.String
+            ) {
+              (query as any)._id = And(
+                QueryHelper.equalTo(existingIdFilter as string),
+                subqueryFilter,
+              );
+            } else {
+              (query as any)._id = subqueryFilter;
+            }
+          } else {
+            // Fall back to OR behavior when metadata cannot be resolved.
+            query[key] = values as any;
+          }
+        } else if (tableColumnMetadata.type === TableColumnType.Entity) {
+          // Entity (single) columns treat AND as a single match — same as OR.
+          query[key] = (query[key] as IncludesAll).values as any;
+        } else {
+          query[key] = QueryHelper.any(
+            (query[key] as IncludesAll).values,
+          ) as any;
+        }
+      } else if (
+        query[key] &&
+        query[key] instanceof IncludesNone &&
+        tableColumnMetadata
+      ) {
+        if (tableColumnMetadata.type === TableColumnType.EntityArray) {
+          const includesNone: IncludesNone = query[key] as IncludesNone;
+          const values: Array<string | ObjectID> = (
+            includesNone.values as Array<string | ObjectID | number>
+          ).map((item: string | ObjectID | number) => {
+            if (
+              item !== null &&
+              typeof item === Typeof.Object &&
+              !(item instanceof ObjectID)
+            ) {
+              const itemRecord: JSONObject = item as unknown as JSONObject;
+              if (itemRecord["_id"]) {
+                return itemRecord["_id"] as string;
+              }
+            }
+            return item.toString();
+          });
+
+          const manyToManyMeta: {
+            joinTableName: string;
+            ownerColumnName: string;
+            relationColumnName: string;
+          } | null = QueryUtil.getManyToManyRelationMetadata(modelType, key);
+
+          if (manyToManyMeta && values.length > 0) {
+            const subqueryFilter: any = QueryHelper.noneEntitiesInManyToMany({
+              values,
+              joinTableName: manyToManyMeta.joinTableName,
+              ownerColumnName: manyToManyMeta.ownerColumnName,
+              relationColumnName: manyToManyMeta.relationColumnName,
+            });
+
+            delete query[key];
+
+            const existingIdFilter: any = (query as any)._id;
+            if (existingIdFilter instanceof FindOperator) {
+              (query as any)._id = And(existingIdFilter, subqueryFilter);
+            } else if (
+              existingIdFilter &&
+              typeof existingIdFilter === Typeof.String
+            ) {
+              (query as any)._id = And(
+                QueryHelper.equalTo(existingIdFilter as string),
+                subqueryFilter,
+              );
+            } else {
+              (query as any)._id = subqueryFilter;
+            }
+          } else {
+            delete query[key];
+          }
+        } else if (tableColumnMetadata.type === TableColumnType.Entity) {
+          query[key] = QueryHelper.notIn(
+            (query[key] as IncludesNone).values as Array<string | ObjectID>,
+          ) as any;
+        } else {
+          query[key] = QueryHelper.notIn(
+            (query[key] as IncludesNone).values as Array<string | ObjectID>,
+          ) as any;
+        }
       } else if (
         query[key] &&
         query[key] instanceof Includes &&
@@ -237,4 +404,87 @@ export default class QueryUtil {
 
     return query;
   }
+
+  /**
+   * Resolves the join-table metadata for a many-to-many relation declared on
+   * the provided model. Returns null when the column is not a many-to-many
+   * relation, the database connection is not yet ready, or required metadata
+   * is missing.
+   */
+  public static getManyToManyRelationMetadata<TBaseModel extends BaseModel>(
+    modelType: { new (): TBaseModel },
+    propertyPath: string,
+  ): {
+    joinTableName: string;
+    ownerColumnName: string;
+    relationColumnName: string;
+  } | null {
+    if (!PostgresAppInstance.isConnected()) {
+      return null;
+    }
+
+    const dataSource: DataSource | null = PostgresAppInstance.getDataSource();
+
+    if (!dataSource) {
+      return null;
+    }
+
+    let entityMetadata: EntityMetadata | undefined;
+    try {
+      entityMetadata = dataSource.getMetadata(modelType);
+    } catch {
+      return null;
+    }
+
+    if (!entityMetadata) {
+      return null;
+    }
+
+    const relation: RelationMetadata | undefined =
+      entityMetadata.findRelationWithPropertyPath(propertyPath);
+
+    if (!relation || !relation.isManyToMany) {
+      return null;
+    }
+
+    /*
+     * 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;
+
+    const joinTableName: string | undefined =
+      owningRelation.junctionEntityMetadata?.tableName;
+
+    if (!joinTableName) {
+      return null;
+    }
+
+    /*
+     * 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;
+    const relationColumns: Array<any> = relation.isOwning
+      ? owningRelation.inverseJoinColumns
+      : owningRelation.joinColumns;
+
+    const ownerColumnName: string | undefined = ownerColumns[0]?.databaseName;
+    const relationColumnName: string | undefined =
+      relationColumns[0]?.databaseName;
+
+    if (!ownerColumnName || !relationColumnName) {
+      return null;
+    }
+
+    return {
+      joinTableName,
+      ownerColumnName,
+      relationColumnName,
+    };
+  }
 }

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/EndsWith.ts

@@ -0,0 +1,41 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class EndsWith<T extends string> extends QueryOperator<T> {
+  private _value!: T;
+
+  public get value(): T {
+    return this._value;
+  }
+
+  public set value(v: T) {
+    this._value = v;
+  }
+
+  public constructor(value: T) {
+    super();
+    this.value = value;
+  }
+
+  public override toString(): T {
+    return this.value;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.EndsWith,
+      value: (this as EndsWith<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): EndsWith<T> {
+    if (json["_type"] === ObjectType.EndsWith) {
+      return new EndsWith<T>((json["value"] as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}