@oneuptime/common 12.0.24 → 12.0.26

package/Server/Services/DatabaseService.ts

@@ -1,6 +1,10 @@
 import { EncryptionSecret, WorkflowHostname } from "../EnvironmentConfig";
 import PostgresAppInstance from "../Infrastructure/PostgresDatabase";
 import ClusterKeyAuthorization from "../Middleware/ClusterKeyAuthorization";
+import AggregateBy, {
+  AggregateColumn,
+  AggregateRow,
+} from "../Types/Database/AggregateBy";
 import CountBy from "../Types/Database/CountBy";
 import FindAllBy from "../Types/Database/FindAllBy";
 import CreateBy from "../Types/Database/CreateBy";
@@ -1459,6 +1463,267 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     }
   }
 
+  /*
+   * A plain identifier, because an alias is interpolated into `AS "..."` and
+   * is structure rather than data — there is no parameter form for it.
+   */
+  private static readonly aggregateAliasPattern: RegExp =
+    /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
+  /**
+   * Answers a question ABOUT the matched rows — how many, how much, how many
+   * of each — without loading them.
+   *
+   * Same permission pipeline as `findBy` and `countBy`: the query is run
+   * through `checkReadQueryPermission` first, so tenant scoping and
+   * label-block filtering apply exactly as they do to a list read (a blocked
+   * label produces the same relation join here that it produces there — the
+   * count cannot see rows the list would hide).
+   *
+   * Returns one row per group, or exactly one row when `groupBy` is omitted.
+   * Values come back as the driver produced them; read them through
+   * `AggregateResultUtil` rather than indexing in directly, because Postgres
+   * hands COUNT and SUM back as strings.
+   *
+   * See `AggregateBy` for the trust boundary on `expression`: constants only,
+   * every dynamic value through `parameters`.
+   */
+  @CaptureSpan()
+  public async aggregateBy(
+    aggregateBy: AggregateBy<TBaseModel>,
+  ): Promise<Array<AggregateRow>> {
+    try {
+      this.setTelemetryContextFromProps(aggregateBy.props);
+
+      if (!aggregateBy.select || aggregateBy.select.length === 0) {
+        throw new BadDataException(
+          "aggregateBy needs at least one aggregate column to select.",
+        );
+      }
+
+      const groupByColumns: Array<AggregateColumn> = aggregateBy.groupBy || [];
+
+      /*
+       * Grouped columns are selected as well as grouped on. Doing it here
+       * rather than making callers list them twice is what keeps a group key
+       * and the bucket it labels from ever drifting apart.
+       */
+      const selectColumns: Array<AggregateColumn> = [
+        ...groupByColumns,
+        ...aggregateBy.select,
+      ];
+
+      const seenAliases: Set<string> = new Set<string>();
+
+      for (const column of selectColumns) {
+        DatabaseService.assertSafeAggregateExpression(column.expression);
+
+        if (!DatabaseService.aggregateAliasPattern.test(column.alias)) {
+          throw new BadDataException(
+            `Invalid aggregate alias: ${column.alias}. Aliases must be plain identifiers.`,
+          );
+        }
+
+        if (seenAliases.has(column.alias)) {
+          throw new BadDataException(
+            `Duplicate aggregate alias: ${column.alias}.`,
+          );
+        }
+
+        seenAliases.add(column.alias);
+      }
+
+      /*
+       * Validated here rather than in the loop that applies them, so every
+       * expression in the request is checked BEFORE anything reaches the
+       * database — and so the check is reachable without a live connection,
+       * which is what makes it testable.
+       */
+      for (const order of aggregateBy.orderBy || []) {
+        DatabaseService.assertSafeAggregateExpression(order.expression);
+      }
+
+      const checkReadPermissionType: CheckReadPermissionType<TBaseModel> =
+        await ModelPermission.checkReadQueryPermission(
+          this.modelType,
+          aggregateBy.query,
+          null,
+          aggregateBy.props,
+        );
+
+      const queryBuilder: SelectQueryBuilder<TBaseModel> =
+        this.buildAggregateScope(checkReadPermissionType.query);
+
+      let isFirstColumn: boolean = true;
+
+      for (const column of selectColumns) {
+        if (isFirstColumn) {
+          queryBuilder.select(column.expression, column.alias);
+          isFirstColumn = false;
+        } else {
+          queryBuilder.addSelect(column.expression, column.alias);
+        }
+      }
+
+      for (const column of groupByColumns) {
+        queryBuilder.addGroupBy(column.expression);
+      }
+
+      for (const order of aggregateBy.orderBy || []) {
+        queryBuilder.addOrderBy(
+          order.expression,
+          order.sortOrder === SortOrder.Ascending ? "ASC" : "DESC",
+        );
+      }
+
+      if (aggregateBy.parameters) {
+        queryBuilder.setParameters(aggregateBy.parameters);
+      }
+
+      if (aggregateBy.limit !== undefined) {
+        if (!Number.isInteger(aggregateBy.limit) || aggregateBy.limit < 0) {
+          throw new BadDataException(
+            `Invalid aggregate limit: ${aggregateBy.limit}. It must be a non-negative integer.`,
+          );
+        }
+
+        /*
+         * `.limit`, not `.take`: this is a raw read, and `take` is the
+         * entity-hydrating pagination that would wrap the whole aggregate in
+         * a distinct-id subquery.
+         */
+        queryBuilder.limit(aggregateBy.limit);
+      }
+
+      return (await queryBuilder.getRawMany()) as Array<AggregateRow>;
+    } catch (error) {
+      await this.onCountError(error as Exception);
+      throw this.getException(error as Exception);
+    }
+  }
+
+  /**
+   * A query builder scoped to exactly the rows this read may see, and — this
+   * is the whole point — scoped so that each of them appears ONCE.
+   *
+   * The permission pipeline expresses a label-scoped read as a condition on
+   * the access-control RELATION: `{ labels: [permittedIds] }` for an allow
+   * permission, `{ labels: { _id: NotIn([...]) } }` for a block. Handed to
+   * TypeORM's FindOptions machinery those become a join through the
+   * many-to-many junction table — and a join multiplies rows. A device
+   * carrying two permitted labels comes back twice.
+   *
+   * `findBy` never notices, because entity hydration de-duplicates by primary
+   * key on the way out. An aggregate has no such step: COUNT(*) would report
+   * that device as two devices and SUM("interfacesDown") would double its dark
+   * ports — silently, and only for the label-scoped enterprise users who are
+   * least able to spot it. (Verified against Postgres: one device, two
+   * permitted labels, `COUNT(*) = 2`, `SUM = 2` for a stored value of 1.)
+   *
+   * `COUNT(DISTINCT _id)` would fix the counts and do nothing for the sums, so
+   * the de-duplication happens one level down instead: when the scoped query
+   * touches a relation at all, the aggregate runs over the base table filtered
+   * by a DISTINCT subquery of ids. The joins live inside that subquery, where
+   * duplicate rows collapse before anything is added up.
+   *
+   * The subquery is skipped when the query is flat — which is every read by a
+   * user whose permissions are not label-scoped, i.e. the hot path — so the
+   * ordinary full-fleet aggregate stays a single sequential scan.
+   */
+  private buildAggregateScope(
+    query: Query<TBaseModel>,
+  ): SelectQueryBuilder<TBaseModel> {
+    if (!this.queryTouchesARelation(query)) {
+      const flatBuilder: SelectQueryBuilder<TBaseModel> = this.getQueryBuilder(
+        this.modelName,
+      );
+
+      flatBuilder.setFindOptions({ where: query as any });
+
+      return flatBuilder;
+    }
+
+    /*
+     * A separate alias, so the subquery's joins cannot collide with the outer
+     * statement's table reference.
+     */
+    const scopeAlias: string = `${this.modelName}_aggregate_scope`;
+
+    const scopeBuilder: SelectQueryBuilder<TBaseModel> =
+      this.getQueryBuilder(scopeAlias);
+
+    scopeBuilder.setFindOptions({ where: query as any });
+    scopeBuilder.select(`DISTINCT "${scopeAlias}"."_id"`, "_id");
+
+    const queryBuilder: SelectQueryBuilder<TBaseModel> = this.getQueryBuilder(
+      this.modelName,
+    );
+
+    /*
+     * The alias is QUOTED. TypeORM renders it quoted everywhere else, and an
+     * unquoted `NetworkDevice."_id"` in a raw fragment is folded to lower case
+     * by Postgres — which then does not match the quoted alias at all.
+     */
+    queryBuilder.where(
+      `"${this.modelName}"."_id" IN (${scopeBuilder.getQuery()})`,
+    );
+    /*
+     * The subquery's own bound values. Its placeholders are auto-named
+     * (`orm_param_N`) and the outer builder generates none of its own here —
+     * its only WHERE is the raw string above — so there is nothing to clash
+     * with. Caller-supplied parameters are named and applied later.
+     */
+    queryBuilder.setParameters(scopeBuilder.getParameters());
+
+    return queryBuilder;
+  }
+
+  /*
+   * Whether any top-level key of the query names a RELATION rather than a
+   * column — the shape that turns into a join.
+   *
+   * Deliberately conservative in both directions: a many-to-one relation joins
+   * at most one row and would not actually multiply anything, and metadata
+   * being unavailable is treated as "yes, there might be one". Both err
+   * towards the de-duplicating path, which is always correct and merely
+   * slower.
+   */
+  private queryTouchesARelation(query: Query<TBaseModel>): boolean {
+    let metadata: EntityMetadata;
+
+    try {
+      metadata = this.getRepository().metadata;
+    } catch {
+      return true;
+    }
+
+    for (const key of Object.keys(query as Record<string, unknown>)) {
+      if (metadata.findRelationWithPropertyPath(key)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /*
+   * A tripwire on the constants-only contract, not a sanitizer: an expression
+   * assembled from request data can be perfectly valid SQL and still be an
+   * injection. What this catches is the one shape that turns a leaked value
+   * into a second statement.
+   */
+  private static assertSafeAggregateExpression(expression: string): void {
+    if (!expression || !expression.trim()) {
+      throw new BadDataException("Aggregate expression cannot be empty.");
+    }
+
+    if (expression.includes(";")) {
+      throw new BadDataException(
+        "Aggregate expressions cannot contain statement separators.",
+      );
+    }
+  }
+
   @CaptureSpan()
   public async deleteOneById(deleteById: DeleteById): Promise<number> {
     await ModelPermission.checkDeletePermissionByModel({

package/Server/Services/DockerHostFeedService.ts

@@ -0,0 +1,99 @@
+import { Blue500 } from "../../Types/BrandColors";
+import Color from "../../Types/Color";
+import OneUptimeDate from "../../Types/Date";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { IsBillingEnabled } from "../EnvironmentConfig";
+import logger, { LogAttributes } from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import DockerHostFeed, {
+  DockerHostFeedEventType,
+} from "../../Models/DatabaseModels/DockerHostFeed";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<DockerHostFeed> {
+  public constructor() {
+    super(DockerHostFeed);
+
+    if (IsBillingEnabled) {
+      this.hardDeleteItemsOlderThanInDays("createdAt", 3 * 365); // 3 years
+    }
+  }
+
+  @CaptureSpan()
+  public async createDockerHostFeedItem(data: {
+    dockerHostId: ObjectID;
+    feedInfoInMarkdown: string;
+    dockerHostFeedEventType: DockerHostFeedEventType;
+    projectId: ObjectID;
+    moreInformationInMarkdown?: string | undefined;
+    displayColor?: Color | undefined;
+    userId?: ObjectID | undefined;
+    postedAt?: Date | undefined;
+  }): Promise<void> {
+    /*
+     * A feed item is a side effect of the thing that actually happened. It must
+     * never be able to fail the write it is describing, so everything here is
+     * swallowed and logged rather than thrown - same contract as
+     * MonitorFeedService.
+     */
+    try {
+      const feed: DockerHostFeed = new DockerHostFeed();
+
+      if (!data.dockerHostId) {
+        throw new BadDataException("Docker Host ID is required");
+      }
+
+      if (!data.feedInfoInMarkdown) {
+        throw new BadDataException("Log in markdown is required");
+      }
+
+      if (!data.dockerHostFeedEventType) {
+        throw new BadDataException("Docker Host feed event is required");
+      }
+
+      if (!data.projectId) {
+        throw new BadDataException("Project ID is required");
+      }
+
+      if (!data.displayColor) {
+        data.displayColor = Blue500;
+      }
+
+      feed.displayColor = data.displayColor;
+      feed.dockerHostId = data.dockerHostId;
+      feed.feedInfoInMarkdown = data.feedInfoInMarkdown;
+      feed.dockerHostFeedEventType = data.dockerHostFeedEventType;
+      feed.projectId = data.projectId;
+      feed.postedAt = data.postedAt || OneUptimeDate.getCurrentDate();
+
+      if (data.userId) {
+        feed.userId = data.userId;
+      }
+
+      if (data.moreInformationInMarkdown) {
+        feed.moreInformationInMarkdown = data.moreInformationInMarkdown;
+      }
+
+      await this.create({
+        data: feed,
+        props: {
+          isRoot: true,
+        },
+      });
+    } catch (e) {
+      logger.error("Error in creating Docker host feed", {
+        projectId: data.projectId?.toString(),
+        dockerHostId: data.dockerHostId?.toString(),
+      } as LogAttributes);
+      logger.error(e, {
+        projectId: data.projectId?.toString(),
+        dockerHostId: data.dockerHostId?.toString(),
+      } as LogAttributes);
+
+      // we dont throw this error as it is not a critical error
+    }
+  }
+}
+
+export default new Service();

package/Server/Services/DockerHostLabelRuleEngineService.ts

@@ -3,6 +3,9 @@ import DockerHost from "../../Models/DatabaseModels/DockerHost";
 import DockerHostLabelRule from "../../Models/DatabaseModels/DockerHostLabelRule";
 import DockerHostLabelRuleService from "./DockerHostLabelRuleService";
 import DockerHostService from "./DockerHostService";
+import DockerHostFeedService from "./DockerHostFeedService";
+import { DockerHostFeedEventType } from "../../Models/DatabaseModels/DockerHostFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -59,6 +62,7 @@ class DockerHostLabelRuleEngineServiceClass {
       }
 
       const labelIdsToAdd: Set<string> = new Set();
+      const matchedRuleNames: Array<string> = [];
 
       for (const rule of rules) {
         const matches: boolean = this.doesDockerHostMatchRule(
@@ -68,6 +72,11 @@ class DockerHostLabelRuleEngineServiceClass {
         if (!matches) {
           continue;
         }
+        if ((rule.labelsToAdd || []).length > 0) {
+          matchedRuleNames.push(
+            rule.name || rule.id?.toString() || "Unnamed rule",
+          );
+        }
         for (const label of rule.labelsToAdd || []) {
           if (label.id) {
             labelIdsToAdd.add(label.id.toString());
@@ -122,6 +131,26 @@ class DockerHostLabelRuleEngineServiceClass {
         `DockerHostLabelRuleEngine attached ${newLabelIds.length} labels to Docker host ${dockerHost.id}`,
         { projectId: dockerHost.projectId.toString() } as LogAttributes,
       );
+      /*
+       * Labels arriving from a rule rather than from a person is exactly the
+       * kind of thing the overview page cannot explain, so record which rules
+       * did it.
+       */
+      await DockerHostFeedService.createDockerHostFeedItem({
+        dockerHostId: dockerHost.id,
+        projectId: dockerHost.projectId,
+        dockerHostFeedEventType: DockerHostFeedEventType.LabelRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `🏷️ ${newLabelIds.length} label(s) were attached to ${await DockerHostService.getDockerHostMarkdownLink(
+          dockerHost.projectId,
+          dockerHost.id,
+        )} by label ${matchedRuleNames.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Label rules that matched**: ${matchedRuleNames
+          .map((name: string) => {
+            return `\`${name}\``;
+          })
+          .join(", ")}`,
+      });
     } catch (error) {
       logger.error(`Error applying Docker host label rules: ${error}`, {
         projectId: dockerHost.projectId?.toString(),

package/Server/Services/DockerHostOwnerRuleEngineService.ts

@@ -7,6 +7,9 @@ import DockerHostOwnerRuleService from "./DockerHostOwnerRuleService";
 import DockerHostOwnerUserService from "./DockerHostOwnerUserService";
 import DockerHostOwnerTeamService from "./DockerHostOwnerTeamService";
 import DockerHostService from "./DockerHostService";
+import DockerHostFeedService from "./DockerHostFeedService";
+import { DockerHostFeedEventType } from "../../Models/DatabaseModels/DockerHostFeed";
+import { Purple500 } from "../../Types/BrandColors";
 import ObjectID from "../../Types/ObjectID";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -140,6 +143,26 @@ class DockerHostOwnerRuleEngineServiceClass {
         `DockerHostOwnerRuleEngine added owners to Docker host ${dockerHost.id}`,
         { projectId: dockerHost.projectId.toString() } as LogAttributes,
       );
+      /*
+       * The individual OwnerUserAdded / OwnerTeamAdded items say who was added;
+       * this one says which rule is responsible, which is what somebody asking
+       * "why am I on the hook for this?" actually needs.
+       */
+      await DockerHostFeedService.createDockerHostFeedItem({
+        dockerHostId: dockerHost.id,
+        projectId: dockerHost.projectId,
+        dockerHostFeedEventType: DockerHostFeedEventType.OwnerRuleExecuted,
+        displayColor: Purple500,
+        feedInfoInMarkdown: `👥 Owners were added to ${await DockerHostService.getDockerHostMarkdownLink(
+          dockerHost.projectId,
+          dockerHost.id,
+        )} by ${matchedRules.length} owner ${matchedRules.length === 1 ? "rule" : "rules"}.`,
+        moreInformationInMarkdown: `**Owner rules that matched**: ${matchedRules
+          .map((rule: DockerHostOwnerRule) => {
+            return `\`${rule.name || rule.id?.toString() || "Unnamed rule"}\``;
+          })
+          .join(", ")}`,
+      });
     } catch (error) {
       logger.error(`Error applying Docker host owner rules: ${error}`, {
         projectId: dockerHost.projectId?.toString(),

package/Server/Services/DockerHostOwnerTeamService.ts

@@ -1,10 +1,139 @@
+import ObjectID from "../../Types/ObjectID";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/DockerHostOwnerTeam";
+import DockerHostFeedService from "./DockerHostFeedService";
+import { DockerHostFeedEventType } from "../../Models/DatabaseModels/DockerHostFeed";
+import { Gray500, Red500 } from "../../Types/BrandColors";
+import Team from "../../Models/DatabaseModels/Team";
+import TeamService from "./TeamService";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import DockerHostService from "./DockerHostService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    /*
+     * The rows are gone by the time onDeleteSuccess runs, so the feed item has
+     * to be built from what was read here.
+     */
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      limit: deleteBy.limit,
+      skip: deleteBy.skip,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        dockerHostId: true,
+        projectId: true,
+        teamId: true,
+      },
+    });
+
+    return {
+      carryForward: {
+        itemsToDelete: itemsToDelete,
+      },
+      deleteBy: deleteBy,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedByUserId: ObjectID | undefined =
+      onDelete.deleteBy.deletedByUser?.id || onDelete.deleteBy.props.userId;
+
+    const itemsToDelete: Array<Model> = onDelete.carryForward.itemsToDelete;
+
+    for (const item of itemsToDelete) {
+      const dockerHostId: ObjectID | undefined = item.dockerHostId;
+      const projectId: ObjectID | undefined = item.projectId;
+      const teamId: ObjectID | undefined = item.teamId;
+
+      if (!dockerHostId || !projectId || !teamId) {
+        continue;
+      }
+
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!team || !team.name) {
+        continue;
+      }
+
+      await DockerHostFeedService.createDockerHostFeedItem({
+        dockerHostId: dockerHostId,
+        projectId: projectId,
+        dockerHostFeedEventType: DockerHostFeedEventType.OwnerTeamRemoved,
+        displayColor: Red500,
+        feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** as an owner of ${await DockerHostService.getDockerHostMarkdownLink(
+          projectId,
+          dockerHostId,
+        )}.`,
+        userId: deletedByUserId || undefined,
+      });
+    }
+
+    return onDelete;
+  }
+
+  @CaptureSpan()
+  public override async onCreateSuccess(
+    onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const dockerHostId: ObjectID | undefined = createdItem.dockerHostId;
+    const projectId: ObjectID | undefined = createdItem.projectId;
+    const teamId: ObjectID | undefined = createdItem.teamId;
+    const createdByUserId: ObjectID | undefined =
+      createdItem.createdByUserId || onCreate.createBy.props.userId;
+
+    if (dockerHostId && teamId && projectId) {
+      const team: Team | null = await TeamService.findOneById({
+        id: teamId,
+        select: {
+          name: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (team && team.name) {
+        await DockerHostFeedService.createDockerHostFeedItem({
+          dockerHostId: dockerHostId,
+          projectId: projectId,
+          dockerHostFeedEventType: DockerHostFeedEventType.OwnerTeamAdded,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** as an owner of ${await DockerHostService.getDockerHostMarkdownLink(
+            projectId,
+            dockerHostId,
+          )}.`,
+          userId: createdByUserId || undefined,
+        });
+      }
+    }
+
+    return createdItem;
+  }
 }
 
 export default new Service();