@oneuptime/common 12.0.1 → 12.0.2

package/Server/Infrastructure/Postgres/SchemaMigrations/1785930000000-WidenInventoryResourceNameColumns.ts

@@ -0,0 +1,131 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class WidenInventoryResourceNameColumns1785930000000
+  implements MigrationInterface
+{
+  public name = "WidenInventoryResourceNameColumns1785930000000";
+
+  /*
+   * Same overflow class as WidenDockerResourceImageColumns1782800000000,
+   * on the Podman and Kubernetes inventory tables. These services build
+   * `INSERT ... ON CONFLICT` strings by hand and flush them in chunks of
+   * 500 rows, so ONE value over varchar(100) raises "value too long for
+   * type character varying(100)" (22001) and aborts the ENTIRE multi-row
+   * INSERT — up to 500 inventory rows silently dropped per flush.
+   *
+   * The offenders, all previously varchar(100):
+   *   - PodmanResource."name" / "imageName": full image references
+   *     (registry host + org + repo + tag) routinely exceed 100 chars.
+   *   - KubernetesResource."name" and KubernetesContainer."podName":
+   *     Kubernetes DNS-subdomain names go up to 253 characters, and
+   *     generated pod names (deployment + replicaset hash + pod hash)
+   *     commonly clear 100.
+   *   - KubernetesResource."controllerDeploymentName": written from the
+   *     `k8s.deployment.name` resource attribute, same bound.
+   *
+   * 500 (ColumnLength.LongText) clears the 253-char Kubernetes ceiling
+   * with room to spare and matches what DockerResource already uses.
+   *
+   * COST: raising a varchar length cap is binary-coercible, so Postgres
+   * skips the table rewrite — but ALTER COLUMN TYPE still rebuilds every
+   * index on the altered column ("any indexes on the affected columns
+   * must still be rebuilt"). Three of these five columns are members of
+   * composite UNIQUE indexes:
+   *   - PodmanResource."name"        -> IDX_772c02b6419beb57fa47ccae1b
+   *   - KubernetesResource."name"    -> IDX_3ae20a0d4346958dff73ba7fda
+   *   - KubernetesContainer."podName" -> IDX_1dcb8fed322a9bddfabb60cbc7
+   * Those three rebuild under ACCESS EXCLUSIVE, so on a large inventory
+   * table this is not free: ingest for the affected tables blocks for
+   * the duration, and TypeORM runs all pending migrations in one
+   * transaction, so the locks are held until the whole batch commits.
+   * "imageName" and "controllerDeploymentName" are in no index and are
+   * genuinely metadata-only.
+   */
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "PodmanResource" ALTER COLUMN "name" TYPE character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "PodmanResource" ALTER COLUMN "imageName" TYPE character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesResource" ALTER COLUMN "name" TYPE character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesResource" ALTER COLUMN "controllerDeploymentName" TYPE character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesContainer" ALTER COLUMN "podName" TYPE character varying(500)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Narrowing back to varchar(100) fails outright if any row written
+     * since up() exceeds 100 chars, so clip first. "name" / "podName"
+     * are part of UNIQUE indexes: clipping two rows onto the same
+     * truncated key would violate them, so the revert deletes rows
+     * whose identity would collide after clipping instead of letting
+     * the ALTER blow up. Inventory rows are a projection of what the
+     * agent is reporting — the next snapshot re-creates them.
+     */
+    await queryRunner.query(
+      `DELETE FROM "PodmanResource" a USING "PodmanResource" b
+       WHERE a."projectId" = b."projectId"
+         AND a."podmanHostId" = b."podmanHostId"
+         AND a."kind" = b."kind"
+         AND LEFT(a."name", 100) = LEFT(b."name", 100)
+         AND a."_id" > b."_id"`,
+    );
+    await queryRunner.query(
+      `DELETE FROM "KubernetesResource" a USING "KubernetesResource" b
+       WHERE a."projectId" = b."projectId"
+         AND a."kubernetesClusterId" = b."kubernetesClusterId"
+         AND a."kind" = b."kind"
+         AND a."namespaceKey" = b."namespaceKey"
+         AND LEFT(a."name", 100) = LEFT(b."name", 100)
+         AND a."_id" > b."_id"`,
+    );
+    await queryRunner.query(
+      `DELETE FROM "KubernetesContainer" a USING "KubernetesContainer" b
+       WHERE a."projectId" = b."projectId"
+         AND a."kubernetesClusterId" = b."kubernetesClusterId"
+         AND a."podNamespaceKey" = b."podNamespaceKey"
+         AND LEFT(a."podName", 100) = LEFT(b."podName", 100)
+         AND a."name" = b."name"
+         AND a."_id" > b."_id"`,
+    );
+
+    await queryRunner.query(
+      `UPDATE "PodmanResource" SET "name" = LEFT("name", 100) WHERE LENGTH("name") > 100`,
+    );
+    await queryRunner.query(
+      `UPDATE "PodmanResource" SET "imageName" = LEFT("imageName", 100) WHERE "imageName" IS NOT NULL AND LENGTH("imageName") > 100`,
+    );
+    await queryRunner.query(
+      `UPDATE "KubernetesResource" SET "name" = LEFT("name", 100) WHERE LENGTH("name") > 100`,
+    );
+    await queryRunner.query(
+      `UPDATE "KubernetesResource" SET "controllerDeploymentName" = LEFT("controllerDeploymentName", 100) WHERE "controllerDeploymentName" IS NOT NULL AND LENGTH("controllerDeploymentName") > 100`,
+    );
+    await queryRunner.query(
+      `UPDATE "KubernetesContainer" SET "podName" = LEFT("podName", 100) WHERE LENGTH("podName") > 100`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "PodmanResource" ALTER COLUMN "name" TYPE character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "PodmanResource" ALTER COLUMN "imageName" TYPE character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesResource" ALTER COLUMN "name" TYPE character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesResource" ALTER COLUMN "controllerDeploymentName" TYPE character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesContainer" ALTER COLUMN "podName" TYPE character varying(100)`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1785930709405-AddStatusPageReportPeriod.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddStatusPageReportPeriod1785930709405
+  implements MigrationInterface
+{
+  public name = "AddStatusPageReportPeriod1785930709405";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "reportPeriodType" character varying DEFAULT 'Rolling'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "reportTimezone" character varying DEFAULT 'UTC'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "reportTimezone"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "reportPeriodType"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -492,6 +492,10 @@ import { SessionReplayDefaultToSensitiveInputMasking1785860000000 } from "./1785
 import { AddAiCommandRemediation1785870000000 } from "./1785870000000-AddAiCommandRemediation";
 import { AlignRunnerSchemaWithEntities1785880000000 } from "./1785880000000-AlignRunnerSchemaWithEntities";
 import { AddFixVerificationAndAutomaticCodeFixes1785890000000 } from "./1785890000000-AddFixVerificationAndAutomaticCodeFixes";
+import { AddSloMonitorLabelRule1785900000000 } from "./1785900000000-AddSloMonitorLabelRule";
+import { IncreaseHostIpAddressesLength1785915638551 } from "./1785915638551-IncreaseHostIpAddressesLength";
+import { WidenInventoryResourceNameColumns1785930000000 } from "./1785930000000-WidenInventoryResourceNameColumns";
+import { AddStatusPageReportPeriod1785930709405 } from "./1785930709405-AddStatusPageReportPeriod";
 import { AddIncidentInvestigationGating1785790000000 } from "./1785790000000-AddIncidentInvestigationGating";
 import { AddRemediationVerification1785768089408 } from "./1785768089408-AddRemediationVerification";
 
@@ -992,4 +996,8 @@ export default [
   AddAiCommandRemediation1785870000000,
   AlignRunnerSchemaWithEntities1785880000000,
   AddFixVerificationAndAutomaticCodeFixes1785890000000,
+  AddSloMonitorLabelRule1785900000000,
+  IncreaseHostIpAddressesLength1785915638551,
+  WidenInventoryResourceNameColumns1785930000000,
+  AddStatusPageReportPeriod1785930709405,
 ];

package/Server/Middleware/ProjectAuthorization.ts

@@ -41,18 +41,69 @@ export default class ProjectMiddleware {
     return projectId;
   }
 
+  /*
+   * The `apikey` header exactly as it arrived, or null when it was never
+   * sent at all. Node lower-cases header names, and a caller that sends the
+   * header twice arrives here as one comma-joined string — never a usable
+   * key, but unmistakably a caller who meant to authenticate by key.
+   *
+   * An empty or whitespace-only value is a header that WAS sent. Keeping that
+   * distinct from "absent" is the whole point of this helper; see hasApiKey.
+   */
+  private static getRawApiKeyHeader(req: ExpressRequest): string | null {
+    const rawHeader: string | Array<string> | undefined =
+      req.headers?.["apikey"];
+
+    if (rawHeader === undefined) {
+      return null;
+    }
+
+    return Array.isArray(rawHeader) ? rawHeader.join(",") : rawHeader;
+  }
+
   @CaptureSpan()
   public static getApiKey(req: ExpressRequest): ObjectID | null {
-    if (req.headers && req.headers["apikey"]) {
-      return new ObjectID(req.headers["apikey"] as string);
+    const rawHeader: string | null = ProjectMiddleware.getRawApiKeyHeader(req);
+
+    if (rawHeader === null) {
+      return null;
     }
 
-    return null;
+    const apiKey: string = rawHeader.trim();
+
+    /*
+     * `ApiKey.apiKey` is a Postgres `uuid` column, so a non-UUID value makes
+     * the lookup raise "invalid input syntax for type uuid" down in the query
+     * layer. A raw QueryFailedError is not a OneUptime Exception, so it slips
+     * past the error translator and answers 500 to what is really a malformed
+     * request. Reject the shape here and let the caller get `Invalid API Key`.
+     */
+    if (!ObjectID.isValidUUID(apiKey)) {
+      return null;
+    }
+
+    return new ObjectID(apiKey);
   }
 
+  /*
+   * Presence, not usability — deliberately NOT `Boolean(this.getApiKey(req))`.
+   *
+   * A request carrying an empty or malformed `ApiKey` header is a caller
+   * trying to authenticate by key and getting it wrong. Answering false here
+   * routed it down the anonymous path, where it failed much later with
+   * "A user should be logged in to <op> record of <Model>." — an error about
+   * session auth, raised against a caller who never attempted session auth,
+   * naming a model as though the model were what went wrong. It reads as an
+   * RBAC bug in whichever resource happened to be asked for, and has been
+   * reported as one more than once (issues #1754, #3004). An unset shell
+   * variable, a client that sends the header blank, and our own CLI's
+   * partial-credential path all land here.
+   *
+   * Claim the request instead, so it fails as `Invalid API Key`.
+   */
   @CaptureSpan()
   public static hasApiKey(req: ExpressRequest): boolean {
-    return Boolean(this.getApiKey(req));
+    return ProjectMiddleware.getRawApiKeyHeader(req) !== null;
   }
 
   @CaptureSpan()
@@ -118,6 +169,17 @@ export default class ProjectMiddleware {
       }
 
       if (!apiKey) {
+        /*
+         * Separate "no header at all" from "header sent, but unusable".
+         * getUserMiddleware only routes here once the header is present, so
+         * in practice it is always the second: an empty value from an unset
+         * variable, a non-UUID string, or duplicate headers that Node joined
+         * into a comma-separated list.
+         */
+        if (ProjectMiddleware.hasApiKey(req)) {
+          throw new BadDataException("Invalid API Key");
+        }
+
         throw new BadDataException(
           "API Key not found in the request header. Please provide a valid API Key in the request header.",
         );