@oneuptime/common 10.0.68 → 10.0.70

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,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/Server/Utils/VM/VMRunner.ts

@@ -224,7 +224,7 @@ function createSandboxProxy(
  * Recursively unwraps sandbox proxies in a return value so the host code
  * receives original objects (e.g. Buffers that pass `instanceof` checks).
  */
-function deepUnwrapProxies(
+export function deepUnwrapProxies(
   value: unknown,
   visited?: WeakSet<GenericObject>,
 ): unknown {
@@ -469,33 +469,50 @@ export default class VMRunner {
       })()`;
 
     try {
-      /*
-       * vm timeout only covers synchronous CPU time, so wrap with
-       * Promise.race to also cover async operations (network, timers, etc.)
-       */
-      const vmPromise: Promise<unknown> = vm.runInContext(script, sandbox, {
-        timeout: timeout,
-      });
-
-      const overallTimeout: Promise<never> = new Promise(
-        (_resolve: (value: never) => void, reject: (reason: Error) => void) => {
-          const handle: NodeJS.Timeout = global.setTimeout(() => {
-            reject(new Error("Script execution timed out"));
-          }, timeout + 5000);
-          // Don't let this timer keep the process alive
-          handle.unref();
-        },
-      );
+      let returnVal: unknown;
+      let scriptError: Error | undefined;
+
+      try {
+        /*
+         * vm timeout only covers synchronous CPU time, so wrap with
+         * Promise.race to also cover async operations (network, timers, etc.)
+         */
+        const vmPromise: Promise<unknown> = vm.runInContext(script, sandbox, {
+          timeout: timeout,
+        });
 
-      const returnVal: unknown = await Promise.race([
-        vmPromise,
-        overallTimeout,
-      ]);
+        const overallTimeout: Promise<never> = new Promise(
+          (
+            _resolve: (value: never) => void,
+            reject: (reason: Error) => void,
+          ) => {
+            const handle: NodeJS.Timeout = global.setTimeout(() => {
+              reject(new Error("Script execution timed out"));
+            }, timeout + 5000);
+            // Don't let this timer keep the process alive
+            handle.unref();
+          },
+        );
+
+        returnVal = await Promise.race([vmPromise, overallTimeout]);
+      } catch (err: unknown) {
+        /*
+         * Capture user-thrown errors (including timeouts) so the caller can
+         * still access side-channel data collected before the throw — e.g.
+         * screenshots assigned to a host-realm object passed via `context`.
+         * Rethrowing here would discard those partial results.
+         */
+        scriptError =
+          err instanceof Error
+            ? err
+            : new Error(typeof err === "string" ? err : String(err));
+      }
 
       return {
         returnValue: deepUnwrapProxies(returnVal),
         logMessages,
         capturedMetrics,
+        scriptError,
       };
     } finally {
       // Clean up any lingering timers to prevent resource leaks

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));
+  }
+}