@oneuptime/common 10.0.69 → 10.0.70

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,138 @@ 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 +402,83 @@ 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/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));
+  }
+}

package/Types/BaseDatabase/IncludesAll.ts

@@ -0,0 +1,45 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import JSONFunctions from "../JSONFunctions";
+import ObjectID from "../ObjectID";
+import QueryOperator from "./QueryOperator";
+
+export type IncludesAllType = Array<string> | Array<ObjectID> | Array<number>;
+
+export default class IncludesAll extends QueryOperator<IncludesAllType> {
+  private _values: IncludesAllType = [];
+
+  public get values(): IncludesAllType {
+    return this._values;
+  }
+
+  public set values(v: IncludesAllType) {
+    this._values = v;
+  }
+
+  public constructor(values: IncludesAllType) {
+    super();
+    this.values = values;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.IncludesAll,
+      value: (this as IncludesAll)._values,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): IncludesAll {
+    if (json["_type"] === ObjectType.IncludesAll) {
+      const valuesArray: Array<string> = [];
+
+      for (const value of (json["value"] as Array<string>) || []) {
+        valuesArray.push(JSONFunctions.deserializeValue(value) as string);
+      }
+
+      return new IncludesAll(valuesArray);
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/IncludesNone.ts

@@ -0,0 +1,48 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import JSONFunctions from "../JSONFunctions";
+import ObjectID from "../ObjectID";
+import QueryOperator from "./QueryOperator";
+
+export type IncludesNoneType =
+  | Array<string>
+  | Array<ObjectID>
+  | Array<number>;
+
+export default class IncludesNone extends QueryOperator<IncludesNoneType> {
+  private _values: IncludesNoneType = [];
+
+  public get values(): IncludesNoneType {
+    return this._values;
+  }
+
+  public set values(v: IncludesNoneType) {
+    this._values = v;
+  }
+
+  public constructor(values: IncludesNoneType) {
+    super();
+    this.values = values;
+  }
+
+  public override toJSON(): JSONObject {
+    return {
+      _type: ObjectType.IncludesNone,
+      value: (this as IncludesNone)._values,
+    };
+  }
+
+  public static override fromJSON(json: JSONObject): IncludesNone {
+    if (json["_type"] === ObjectType.IncludesNone) {
+      const valuesArray: Array<string> = [];
+
+      for (const value of (json["value"] as Array<string>) || []) {
+        valuesArray.push(JSONFunctions.deserializeValue(value) as string);
+      }
+
+      return new IncludesNone(valuesArray);
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/NotContains.ts

@@ -0,0 +1,41 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class NotContains<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.NotContains,
+      value: (this as NotContains<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): NotContains<T> {
+    if (json["_type"] === ObjectType.NotContains) {
+      return new NotContains<T>((json["value"] as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/BaseDatabase/StartsWith.ts

@@ -0,0 +1,41 @@
+import BadDataException from "../Exception/BadDataException";
+import { JSONObject, ObjectType } from "../JSON";
+import QueryOperator from "./QueryOperator";
+
+export default class StartsWith<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.StartsWith,
+      value: (this as StartsWith<T>).toString(),
+    };
+  }
+
+  public static override fromJSON<T extends string>(
+    json: JSONObject,
+  ): StartsWith<T> {
+    if (json["_type"] === ObjectType.StartsWith) {
+      return new StartsWith<T>((json["value"] as T) || ("" as T));
+    }
+
+    throw new BadDataException("Invalid JSON: " + JSON.stringify(json));
+  }
+}

package/Types/JSON.ts

@@ -7,6 +7,11 @@ import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
 import InBetween from "./BaseDatabase/InBetween";
 import Includes from "./BaseDatabase/Includes";
+import IncludesAll from "./BaseDatabase/IncludesAll";
+import IncludesNone from "./BaseDatabase/IncludesNone";
+import StartsWith from "./BaseDatabase/StartsWith";
+import EndsWith from "./BaseDatabase/EndsWith";
+import NotContains from "./BaseDatabase/NotContains";
 import LessThan from "./BaseDatabase/LessThan";
 import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
 import NotEqual from "./BaseDatabase/NotEqual";
@@ -71,6 +76,11 @@ export enum ObjectType {
   NotNull = "NotNull",
   IsNull = "IsNull",
   Includes = "Includes",
+  IncludesAll = "IncludesAll",
+  IncludesNone = "IncludesNone",
+  StartsWith = "StartsWith",
+  EndsWith = "EndsWith",
+  NotContains = "NotContains",
   DashboardComponent = "DashboardComponent",
   DashboardViewConfig = "DashboardViewConfig",
 }
@@ -157,6 +167,16 @@ export type JSONValue =
   | Array<StartAndEndTime>
   | Includes
   | Array<Includes>
+  | IncludesAll
+  | Array<IncludesAll>
+  | IncludesNone
+  | Array<IncludesNone>
+  | StartsWith<string>
+  | Array<StartsWith<string>>
+  | EndsWith<string>
+  | Array<EndsWith<string>>
+  | NotContains<string>
+  | Array<NotContains<string>>
   | DashboardViewConfig;
 
 export interface JSONObject {

package/Types/SerializableObjectDictionary.ts

@@ -7,6 +7,11 @@ import GreaterThan from "./BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "./BaseDatabase/GreaterThanOrEqual";
 import InBetween from "./BaseDatabase/InBetween";
 import Includes from "./BaseDatabase/Includes";
+import IncludesAll from "./BaseDatabase/IncludesAll";
+import IncludesNone from "./BaseDatabase/IncludesNone";
+import StartsWith from "./BaseDatabase/StartsWith";
+import EndsWith from "./BaseDatabase/EndsWith";
+import NotContains from "./BaseDatabase/NotContains";
 import IsNull from "./BaseDatabase/IsNull";
 import LessThan from "./BaseDatabase/LessThan";
 import LessThanOrEqual from "./BaseDatabase/LessThanOrEqual";
@@ -65,6 +70,11 @@ const SerializableObjectDictionary: Dictionary<any> = {
   [ObjectType.HashedString]: HashedString,
   [ObjectType.InBetween]: InBetween,
   [ObjectType.Includes]: Includes,
+  [ObjectType.IncludesAll]: IncludesAll,
+  [ObjectType.IncludesNone]: IncludesNone,
+  [ObjectType.StartsWith]: StartsWith,
+  [ObjectType.EndsWith]: EndsWith,
+  [ObjectType.NotContains]: NotContains,
   [ObjectType.NotNull]: NotNull,
   [ObjectType.IsNull]: IsNull,
   [ObjectType.Recurring]: Recurring,

package/UI/Components/Filters/BooleanFilter.tsx

@@ -50,6 +50,7 @@ const BooleanFilter: BooleanFilterFunction = <T extends GenericObject>(
           }
         }}
         placeholder={`Filter by ${filter.title}`}
+        className="relative rounded-md w-full overflow-visible"
       />
     );
   }