@oneuptime/common 12.0.33 → 13.0.0

package/Server/Types/Database/Permissions/ReadPermission.ts

@@ -1,6 +1,7 @@
 import DatabaseRequestType from "../../BaseDatabase/DatabaseRequestType";
 import Query from "../Query";
 import QueryHelper from "../QueryHelper";
+import QueryUtil from "../QueryUtil";
 import RelationSelect from "../RelationSelect";
 import Select from "../Select";
 import SelectUtil from "../SelectUtil";
@@ -12,8 +13,11 @@ import DatabaseCommonInteractionPropsUtil, {
   PermissionType,
 } from "../../../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
 import ObjectID from "../../../../Types/ObjectID";
+import BadDataException from "../../../../Types/Exception/BadDataException";
 import Permission, { UserPermission } from "../../../../Types/Permission";
 import CaptureSpan from "../../../Utils/Telemetry/CaptureSpan";
+import { combineWithPrivacyClause } from "../../../Utils/PrivacyFilterUtil";
+import { FindOperator } from "typeorm";
 
 export interface CheckReadPermissionType<TBaseModel extends BaseModel>
   extends CheckPermissionBaseInterface<TBaseModel> {
@@ -119,13 +123,49 @@ export default class ReadPermission {
       }
     }
 
-    // now add these to query
-
     const model: TBaseModel = new modelType();
+    const accessControlColumn: string | null = model.getAccessControlColumn();
+    const manyToManyMeta: ReturnType<
+      typeof QueryUtil.getManyToManyRelationMetadata
+    > = accessControlColumn
+      ? QueryUtil.getManyToManyRelationMetadata(modelType, accessControlColumn)
+      : null;
+
+    if (!manyToManyMeta) {
+      throw new BadDataException(
+        "Cannot apply read label restrictions without access-control relation metadata.",
+      );
+    }
 
-    (query as any)[model.getAccessControlColumn() as string] = {
-      _id: QueryHelper.notInOrNull(labelIds),
-    };
+    const idQuery: Query<TBaseModel> = QueryUtil.serializeQuery(modelType, {
+      _id: query._id,
+    } as Query<TBaseModel>);
+    const existingIdFilter: unknown = idQuery._id;
+    if (
+      existingIdFilter !== undefined &&
+      typeof existingIdFilter !== "string" &&
+      !(existingIdFilter instanceof FindOperator)
+    ) {
+      throw new BadDataException(
+        "Cannot combine read label restrictions with an unsupported ID filter.",
+      );
+    }
+
+    /*
+     * Keep the caller's label selection intact. Blocking labels is a separate
+     * condition on the owner: it must have none of the blocked label links.
+     * Applying that condition to _id also lets grouped dashboard label filters
+     * and existing record selectors reach QueryUtil without being replaced.
+     * Serialize the ID condition first because QueryUtil does not descend into
+     * the database AND operator to convert application query operators later.
+     */
+    (query as any)._id = combineWithPrivacyClause(
+      existingIdFilter,
+      QueryHelper.noneEntitiesInManyToMany({
+        values: labelIds,
+        ...manyToManyMeta,
+      }),
+    );
 
     return { query };
   }

package/Server/Types/Database/QueryHelper.ts

@@ -10,6 +10,8 @@ import { toLikePattern } from "../../../Types/BaseDatabase/WildcardPattern";
 import CaptureSpan from "../../Utils/Telemetry/CaptureSpan";
 import buildJSONColumnQuery, { JSONColumnQuery } from "./JSONColumnQuery";
 
+export type { FindOperator };
+
 export default class QueryHelper {
   @CaptureSpan()
   public static modulo(

package/Server/Types/Database/QueryUtil.ts

@@ -7,6 +7,7 @@ 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 IncludesAnyOfGroups from "../../../Types/BaseDatabase/IncludesAnyOfGroups";
 import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
 import StartsWith from "../../../Types/BaseDatabase/StartsWith";
 import EndsWith from "../../../Types/BaseDatabase/EndsWith";
@@ -24,6 +25,7 @@ import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
 import TableColumnType from "../../../Types/Database/TableColumnType";
 import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
+import BadDataException from "../../../Types/Exception/BadDataException";
 import Typeof from "../../../Types/Typeof";
 import { And, DataSource } from "typeorm";
 import { FindOperator } from "typeorm/find-options/FindOperator";
@@ -45,6 +47,7 @@ export default class QueryUtil {
     const model: BaseModel = new modelType();
 
     query = query as Query<TBaseModel>;
+    const groupedRelationFilters: Array<FindOperator<unknown>> = [];
 
     /*
      * Multi-field text search:
@@ -126,6 +129,37 @@ export default class QueryUtil {
       const tableColumnMetadata: TableColumnMetadata =
         model.getTableColumnMetadata(key);
 
+      if (query[key] instanceof IncludesAnyOfGroups) {
+        if (tableColumnMetadata?.type !== TableColumnType.EntityArray) {
+          throw new BadDataException(
+            "IncludesAnyOfGroups requires a many-to-many entity relation.",
+          );
+        }
+
+        const relation: {
+          joinTableName: string;
+          ownerColumnName: string;
+          relationColumnName: string;
+        } | null = QueryUtil.getManyToManyRelationMetadata(modelType, key);
+
+        if (!relation) {
+          throw new BadDataException(
+            "IncludesAnyOfGroups requires available many-to-many relation metadata.",
+          );
+        }
+
+        for (const group of (query[key] as IncludesAnyOfGroups).groups) {
+          groupedRelationFilters.push(
+            QueryHelper.anyOfEntitiesInManyToMany({
+              ...relation,
+              values: group,
+            }) as FindOperator<unknown>,
+          );
+        }
+        delete query[key];
+        continue;
+      }
+
       if (tableColumnMetadata && query[key] === null) {
         query[key] = QueryHelper.isNull();
       } else if (
@@ -634,6 +668,28 @@ export default class QueryUtil {
       }
     }
 
+    if (groupedRelationFilters.length > 0) {
+      /*
+       * Apply these only after scalar operators have been serialized, so an
+       * existing id condition survives regardless of the query's key order.
+       */
+      const existingIdFilter: unknown = query._id;
+      if (existingIdFilter !== undefined) {
+        if (existingIdFilter instanceof FindOperator) {
+          groupedRelationFilters.unshift(existingIdFilter);
+        } else if (typeof existingIdFilter === "string") {
+          groupedRelationFilters.unshift(
+            QueryHelper.equalTo(existingIdFilter) as FindOperator<unknown>,
+          );
+        } else {
+          throw new BadDataException(
+            "IncludesAnyOfGroups cannot combine an unsupported id filter.",
+          );
+        }
+      }
+      query._id = And(...groupedRelationFilters) as any;
+    }
+
     return query;
   }
 

package/Server/Types/Markdown.ts

@@ -119,7 +119,15 @@ export default class Markdown {
     return htmlBody;
   }
 
-  private static escapeHtml(text: string): string {
+  /**
+   * Escape the five characters that can break out of HTML text or an
+   * attribute value.
+   *
+   * Public because it is not only marked's business: code that hand-builds
+   * an email fragment by string interpolation needs the same escaping, and
+   * a second implementation is a second thing to get wrong.
+   */
+  public static escapeHtml(text: string): string {
     return text
       .replace(/&/g, "&")
       .replace(/</g, "&lt;")
@@ -128,6 +136,31 @@ export default class Markdown {
       .replace(/'/g, "&#39;");
   }
 
+  /*
+   * The email renderer.
+   *
+   * Everything here is an INLINE style, and that is not a preference.
+   * MailService compiles the Handlebars template and sends it — there is no
+   * CSS inlining step anywhere in the pipeline — and Gmail strips <style>
+   * blocks from the document head, so a class name emitted here reaches the
+   * reader as nothing at all. That is why the Docs/Blog renderers' Tailwind
+   * classes cannot be copied even though the override shape can.
+   *
+   * Until this existed the renderer was a bare `new Renderer()`. Alert and
+   * incident root causes carry a GitHub-flavoured table of breaching
+   * samples, and marked emitted it as a naked <table> with no borders, no
+   * padding and no alignment: every row ran into the next, which is
+   * precisely the part of the email an on-call engineer reads first.
+   *
+   * Outlook renders through Word, which ignores border-radius, box-shadow
+   * and — importantly — overflow, so the scrolling wrapper the Docs and
+   * Blog renderers use does not transfer. The table has to FIT instead:
+   * the DetailBox card is 472px wide with 28px of padding either side,
+   * leaving roughly 416px for a root-cause table that routinely runs to
+   * four or more columns. Hence `width:100%` with `table-layout:auto` and
+   * `word-break:break-word` on the cells — a long metric name wraps inside
+   * its column rather than pushing the table past the body width.
+   */
   private static getEmailRenderer(): Renderer {
     if (this.emailRenderer !== null) {
       return this.emailRenderer;
@@ -135,6 +168,65 @@ export default class Markdown {
 
     const renderer: Renderer = new Renderer();
 
+    const cellFont: string =
+      "font-family:'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', sans-serif;font-size:13px;line-height:20px;";
+
+    renderer.table = function (header: string, body: string): string {
+      return (
+        `<table cellpadding="0" cellspacing="0" border="0" width="100%" ` +
+        `style="border-collapse:collapse;width:100%;table-layout:auto;` +
+        `margin:12px 0;border:1px solid #e2e8f0;">` +
+        `<thead>${header}</thead><tbody>${body}</tbody></table>`
+      );
+    };
+
+    renderer.tablerow = function (content: string): string {
+      return `<tr>${content}</tr>`;
+    };
+
+    renderer.tablecell = function (
+      content: string,
+      flags: { header?: boolean; align?: string | null },
+    ): string {
+      const tag: string = flags.header ? "th" : "td";
+      const align: string = flags.align ? `text-align:${flags.align};` : "";
+
+      /*
+       * A header cell gets the tinted band and the heavier bottom rule; a
+       * body cell gets a hairline so consecutive rows stay separable. Both
+       * keep the same padding so the columns line up.
+       */
+      const tone: string = flags.header
+        ? "background-color:#f8fafc;color:#475569;font-weight:600;border-bottom:1px solid #cbd5e1;"
+        : "color:#1e293b;font-weight:400;border-bottom:1px solid #f1f5f9;";
+
+      return (
+        `<${tag} style="padding:8px 10px;${cellFont}${tone}` +
+        `word-break:break-word;${align || "text-align:left;"}">` +
+        `${content}</${tag}>`
+      );
+    };
+
+    /*
+     * The root cause backticks metric names, aliases and timestamps. Left
+     * bare they were indistinguishable from the prose around them.
+     *
+     * `code` arrives ALREADY escaped — marked escapes codespan text before
+     * it reaches the renderer — so escaping again here would turn a typed
+     * "<img>" into the literal "&lt;img&gt;" on screen rather than the
+     * "<img>" the author wrote. (The Docs and BlogValidation renderers do
+     * escape a second time; that is a separate defect in those surfaces,
+     * not a pattern to copy.)
+     */
+    renderer.codespan = function (code: string): string {
+      return (
+        `<code style="background-color:#f1f5f9;color:#0f172a;` +
+        `padding:1px 5px;border-radius:4px;` +
+        `font-family:'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;` +
+        `font-size:12px;">${code}</code>`
+      );
+    };
+
     this.emailRenderer = renderer;
 
     return renderer;

package/Server/Utils/APIKey/AccessPermission.ts

@@ -91,9 +91,12 @@ export default class APIKeyAccessPermission {
     projectId: ObjectID,
     apiKeyId: ObjectID,
   ): Promise<UserTenantAccessPermission> {
-    // get team permissions (cached — see ApiKeyPermissionService).
+    // Get only this key's permissions in this project (cached by both ids).
     const apiKeyPermissionRows: Array<ApiKeyPermissionRow> =
-      await ApiKeyPermissionService.findPermissionsByApiKeyId(apiKeyId);
+      await ApiKeyPermissionService.findPermissionsByApiKeyId(
+        apiKeyId,
+        projectId,
+      );
 
     const userPermissions: Array<UserPermission> = apiKeyPermissionRows.map(
       (row: ApiKeyPermissionRow): UserPermission => {

package/Server/Utils/CustomField/CustomFieldDefinitionMappingHooks.ts

@@ -0,0 +1,54 @@
+import ObjectID from "../../../Types/ObjectID";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import CustomFieldMappingService from "../../Services/CustomFieldMappingService";
+import logger from "../Logger";
+
+/*
+ * The half of the custom-field-definition lifecycle that belongs to value
+ * mapping, factored out so the three definition services that can carry a
+ * mapping (Alert, Incident, Scheduled Maintenance) say the same thing.
+ *
+ * Validation lives next door in CustomFieldMappingValidator and runs in the
+ * before-hooks; this file is only the after-effect: a mapping that was just
+ * created or changed should fill in the records that already exist, not just
+ * the ones created from now on.
+ */
+
+export type BackfillMappedCustomFieldValuesFunction = (data: {
+  definitionModelType: { new (): BaseModel };
+  projectId: ObjectID | undefined;
+  definitionName: string;
+}) => void;
+
+/*
+ * Deliberately NOT awaited, and deliberately not returning a promise.
+ *
+ * A project-wide backfill can touch thousands of rows, and both onCreateSuccess
+ * and onUpdateSuccess are awaited by the write that triggered them — awaiting
+ * this would put the whole sweep inside the settings form's HTTP request and
+ * time it out. This is the same fire-and-forget shape every rule engine in
+ * this codebase uses from onCreateSuccess, and it carries the same
+ * consequence: a backfill lost to a pod restart leaves records holding their
+ * previous values until their source changes again. Because mapping never
+ * clears a value, that is always a stale copy and never a lost one.
+ */
+export const backfillMappedCustomFieldValues: BackfillMappedCustomFieldValuesFunction =
+  (data: {
+    definitionModelType: { new (): BaseModel };
+    projectId: ObjectID | undefined;
+    definitionName: string;
+  }): void => {
+    if (!data.projectId) {
+      return;
+    }
+
+    CustomFieldMappingService.backfillProject({
+      definitionModelType: data.definitionModelType,
+      projectId: data.projectId,
+    }).catch((error: Error) => {
+      logger.error(
+        `Custom field value mapping: backfill after a ${data.definitionName} change failed.`,
+      );
+      logger.error(error);
+    });
+  };