@oneuptime/common 14.0.2 → 14.0.5

package/Tests/Server/Infrastructure/Postgres/AddIncidentAlertMigration.test.ts

@@ -0,0 +1,341 @@
+import { AddIncidentAlert1794900000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1794900000000-AddIncidentAlert";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import IncidentAlert from "../../../../Models/DatabaseModels/IncidentAlert";
+import { describe, expect, test } from "@jest/globals";
+import {
+  DefaultNamingStrategy,
+  QueryRunner,
+  getMetadataArgsStorage,
+} from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+/*
+ * The schema half of linking alerts to incidents.
+ *
+ * The migration was generated against the models, so its names are TypeORM's
+ * by construction. What this pins is that it STAYS the migration for them:
+ * the link table is created with every column the model persists, a pair is
+ * unique at the database level (the service's @UniqueColumnsTogether check is
+ * not race free on its own), a link goes with its project, incident or alert,
+ * outlives the user who made it, every constraint and index carries
+ * TypeORM's own name - a hand edit that renamed one would pass review and
+ * then fail the Schema Drift job - the two project switches are off for every
+ * existing project, and down() undoes up() in reverse.
+ *
+ * Fake QueryRunner only; IncidentAlertPostgres.test.ts runs the same
+ * guarantees against a migrated database.
+ */
+
+const TABLE: string = "IncidentAlert";
+const UNIQUE_COLUMNS: Array<string> = ["incidentId", "alertId", "projectId"];
+const PROJECT_SWITCHES: Array<string> = [
+  "acknowledgeLinkedAlertsWhenIncidentAcknowledged",
+  "resolveLinkedAlertsWhenIncidentResolved",
+];
+
+const namingStrategy: DefaultNamingStrategy = new DefaultNamingStrategy();
+
+type RecordQueriesFunction = (
+  direction: "up" | "down",
+) => Promise<Array<string>>;
+
+const recordQueries: RecordQueriesFunction = async (
+  direction: "up" | "down",
+): Promise<Array<string>> => {
+  const statements: Array<string> = [];
+
+  const queryRunner: QueryRunner = {
+    query: async (statement: string): Promise<void> => {
+      statements.push(statement);
+    },
+  } as unknown as QueryRunner;
+
+  await new AddIncidentAlert1794900000000()[direction](queryRunner);
+
+  return statements;
+};
+
+// Columns a model persists, inherited ones (_id, version, ...) included.
+function persistedColumns(modelType: unknown): Array<string> {
+  const names: Array<string> = [];
+  let current: unknown = modelType;
+
+  while (typeof current === "function" && current !== Function.prototype) {
+    for (const column of getMetadataArgsStorage().columns) {
+      if (column.target === current) {
+        const args: ColumnMetadataArgs = column;
+        names.push(args.options.name || args.propertyName);
+      }
+    }
+
+    current = Object.getPrototypeOf(current);
+  }
+
+  return names;
+}
+
+function createTableStatement(statements: Array<string>): string {
+  const matches: Array<string> = statements.filter(
+    (statement: string): boolean => {
+      return statement.startsWith(`CREATE TABLE "${TABLE}" (`);
+    },
+  );
+
+  expect(matches).toHaveLength(1);
+
+  return matches[0]!;
+}
+
+function foreignKeyStatement(
+  statements: Array<string>,
+  columnName: string,
+): string {
+  const name: string = namingStrategy.foreignKeyName(TABLE, [columnName]);
+  const matches: Array<string> = statements.filter(
+    (statement: string): boolean => {
+      return statement.startsWith(
+        `ALTER TABLE "${TABLE}" ADD CONSTRAINT "${name}" FOREIGN KEY ("${columnName}")`,
+      );
+    },
+  );
+
+  expect({ columnName, found: matches.length }).toEqual({
+    columnName,
+    found: 1,
+  });
+
+  return matches[0]!;
+}
+
+function captured(statements: Array<string>, pattern: RegExp): Array<string> {
+  return statements
+    .map((statement: string): string | null => {
+      const match: RegExpMatchArray | null = statement.match(pattern);
+      return match ? match[1]! : null;
+    })
+    .filter((value: string | null): value is string => {
+      return value !== null;
+    });
+}
+
+describe("AddIncidentAlert1794900000000", () => {
+  test("is registered under the name its class carries", () => {
+    const migration: AddIncidentAlert1794900000000 =
+      new AddIncidentAlert1794900000000();
+
+    expect(migration.name).toBe("AddIncidentAlert1794900000000");
+    expect(SchemaMigrations).toContain(AddIncidentAlert1794900000000);
+  });
+
+  test("its timestamp keeps it behind every migration registered before it", () => {
+    const names: Array<string> = (
+      SchemaMigrations as unknown as Array<{ name: string }>
+    ).map((registered: { name: string }): string => {
+      return registered.name;
+    });
+
+    const ownIndex: number = names.indexOf("AddIncidentAlert1794900000000");
+
+    expect(ownIndex).toBeGreaterThan(0);
+
+    const notBehind: Array<string> = names
+      .slice(0, ownIndex)
+      .filter((className: string): boolean => {
+        const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+        return match !== null && Number(match[1]) >= 1794900000000;
+      });
+
+    expect(notBehind).toEqual([]);
+  });
+
+  /*
+   * It was registered last. Pinned as "nothing registered after it is older"
+   * rather than "it is last", which the next migration would falsify without
+   * going anywhere near this table.
+   */
+  test("nothing registered after it is older than it", () => {
+    const names: Array<string> = (
+      SchemaMigrations as unknown as Array<{ name: string }>
+    ).map((registered: { name: string }): string => {
+      return registered.name;
+    });
+
+    const ownIndex: number = names.indexOf("AddIncidentAlert1794900000000");
+
+    expect(ownIndex).toBeGreaterThan(0);
+
+    const olderAfter: Array<string> = names
+      .slice(ownIndex + 1)
+      .filter((className: string): boolean => {
+        const match: RegExpMatchArray | null = className.match(/(\d{13})$/);
+        return match === null || Number(match[1]) <= 1794900000000;
+      });
+
+    expect(olderAfter).toEqual([]);
+  });
+
+  test("touches only the IncidentAlert table and the Project switches", async () => {
+    const statements: Array<string> = await recordQueries("up");
+
+    for (const statement of statements) {
+      const table: RegExpMatchArray | null = statement.match(
+        /^(?:CREATE TABLE|ALTER TABLE|CREATE (?:UNIQUE )?INDEX "[^"]+" ON) "([^"]+)"/,
+      );
+
+      expect({ statement, table: table?.[1] }).toEqual({
+        statement,
+        table: expect.stringMatching(/^(IncidentAlert|Project)$/),
+      });
+    }
+
+    const projectStatements: Array<string> = statements.filter(
+      (statement: string): boolean => {
+        return statement.startsWith('ALTER TABLE "Project"');
+      },
+    );
+
+    // Only the two switches are added to Project - nothing dropped, nothing retyped.
+    expect(projectStatements).toHaveLength(PROJECT_SWITCHES.length);
+  });
+
+  test("creates IncidentAlert with every column the model persists", async () => {
+    const statement: string = createTableStatement(await recordQueries("up"));
+    const columns: Array<string> = persistedColumns(IncidentAlert);
+
+    expect(columns).toEqual(
+      expect.arrayContaining([
+        "_id",
+        "projectId",
+        "incidentId",
+        "alertId",
+        "createdByUserId",
+        "deletedByUserId",
+      ]),
+    );
+
+    for (const column of columns) {
+      expect({ column, created: statement.includes(`"${column}"`) }).toEqual({
+        column,
+        created: true,
+      });
+    }
+
+    expect(statement).toContain('"projectId" uuid NOT NULL');
+    expect(statement).toContain('"incidentId" uuid NOT NULL');
+    expect(statement).toContain('"alertId" uuid NOT NULL');
+    expect(statement).toContain('"createdByUserId" uuid,');
+    expect(statement).toContain('"deletedByUserId" uuid,');
+    expect(statement).toContain(
+      `CONSTRAINT "${namingStrategy.primaryKeyName(TABLE, ["_id"])}" PRIMARY KEY ("_id")`,
+    );
+  });
+
+  test("a pair can only be linked once: a unique index on (incident, alert, project)", async () => {
+    const statements: Array<string> = await recordQueries("up");
+    const name: string = namingStrategy.indexName(TABLE, UNIQUE_COLUMNS);
+
+    expect(statements).toContain(
+      `CREATE UNIQUE INDEX "${name}" ON "${TABLE}" (${UNIQUE_COLUMNS.map(
+        (column: string): string => {
+          return `"${column}"`;
+        },
+      ).join(", ")}) `,
+    );
+  });
+
+  test.each(["projectId", "incidentId", "alertId"])(
+    "indexes %s, which the link lists filter on",
+    async (column: string) => {
+      const statements: Array<string> = await recordQueries("up");
+      const name: string = namingStrategy.indexName(TABLE, [column]);
+
+      expect(statements).toContain(
+        `CREATE INDEX "${name}" ON "${TABLE}" ("${column}") `,
+      );
+    },
+  );
+
+  test.each([
+    ["projectId", "Project", "CASCADE"],
+    ["incidentId", "Incident", "CASCADE"],
+    ["alertId", "Alert", "CASCADE"],
+    ["createdByUserId", "User", "SET NULL"],
+    ["deletedByUserId", "User", "SET NULL"],
+  ])(
+    "%s references %s and is %s when it is deleted",
+    async (column: string, referenced: string, onDelete: string) => {
+      expect(foreignKeyStatement(await recordQueries("up"), column)).toContain(
+        `REFERENCES "${referenced}"("_id") ON DELETE ${onDelete} ON UPDATE NO ACTION`,
+      );
+    },
+  );
+
+  test.each(PROJECT_SWITCHES)(
+    "adds Project.%s, off for every existing project",
+    async (column: string) => {
+      expect(await recordQueries("up")).toContain(
+        `ALTER TABLE "Project" ADD "${column}" boolean NOT NULL DEFAULT false`,
+      );
+    },
+  );
+
+  test("down() removes every constraint up() added, in reverse", async () => {
+    const up: Array<string> = await recordQueries("up");
+    const down: Array<string> = await recordQueries("down");
+
+    const added: Array<string> = captured(up, /ADD CONSTRAINT "([^"]+)"/);
+    const dropped: Array<string> = captured(down, /DROP CONSTRAINT "([^"]+)"/);
+
+    expect(added).toHaveLength(5);
+    expect(dropped).toEqual([...added].reverse());
+  });
+
+  test("down() drops every index up() created", async () => {
+    const up: Array<string> = await recordQueries("up");
+    const down: Array<string> = await recordQueries("down");
+
+    const created: Array<string> = captured(
+      up,
+      /^CREATE (?:UNIQUE )?INDEX "([^"]+)"/,
+    );
+    const dropped: Array<string> = captured(
+      down,
+      /^DROP INDEX "public"\."([^"]+)"$/,
+    );
+
+    expect(created).toHaveLength(4);
+    expect([...dropped].sort()).toEqual([...created].sort());
+  });
+
+  test("down() drops the Project switches and then the table, last", async () => {
+    const down: Array<string> = await recordQueries("down");
+
+    for (const column of PROJECT_SWITCHES) {
+      expect(down).toContain(`ALTER TABLE "Project" DROP COLUMN "${column}"`);
+    }
+
+    expect(down[down.length - 1]).toBe(`DROP TABLE "${TABLE}"`);
+    expect(
+      down.filter((statement: string): boolean => {
+        return statement.startsWith("DROP TABLE");
+      }),
+    ).toEqual([`DROP TABLE "${TABLE}"`]);
+  });
+
+  test("down() mirrors up(): every statement kind up() ran has its undo", async () => {
+    const up: Array<string> = await recordQueries("up");
+    const down: Array<string> = await recordQueries("down");
+
+    const addedColumns: Array<string> = captured(
+      up,
+      /^ALTER TABLE "Project" ADD "([^"]+)"/,
+    );
+    const droppedColumns: Array<string> = captured(
+      down,
+      /^ALTER TABLE "Project" DROP COLUMN "([^"]+)"$/,
+    );
+
+    expect(droppedColumns).toEqual([...addedColumns].reverse());
+    expect(down).toHaveLength(up.length);
+  });
+});

package/Tests/Server/Infrastructure/Postgres/AddSessionReplaySameOriginTracePropagationMigration.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import {
+  MigrationInterface,
+  QueryRunner,
+  getMetadataArgsStorage,
+} from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import RumApplication from "../../../../Models/DatabaseModels/RumApplication";
+import SchemaMigrations from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/Index";
+import { AddSessionReplaySameOriginTracePropagation1794800000000 } from "../../../../Server/Infrastructure/Postgres/SchemaMigrations/1794800000000-AddSessionReplaySameOriginTracePropagation";
+
+/*
+ * The migration behind RumApplication.sessionReplaySameOriginTracePropagation:
+ * the per-application switch for the browser recorder's automatic
+ * traceparent + session tracestate on requests to the page's own origin.
+ *
+ * The one decision the SQL carries is DEFAULT true on a NOT NULL column:
+ * Postgres fills every EXISTING application with true as the column appears,
+ * so installed recorders start linking on their next page load with no
+ * backfill statement to forget, and the column is the way to turn it off
+ * without a customer redeploy. The statements are executed against a fake
+ * QueryRunner, so up() and down() are told apart.
+ */
+
+const MIGRATION_TIMESTAMP: string = "1794800000000";
+
+const MIGRATION_BASE_NAME: string =
+  "AddSessionReplaySameOriginTracePropagation";
+
+const MIGRATION_FILE_NAME: string = `${MIGRATION_TIMESTAMP}-${MIGRATION_BASE_NAME}.ts`;
+
+const MIGRATION_CLASS_NAME: string = `${MIGRATION_BASE_NAME}${MIGRATION_TIMESTAMP}`;
+
+const MIGRATION_DIRECTORY: string = path.join(
+  __dirname,
+  "../../../../Server/Infrastructure/Postgres/SchemaMigrations",
+);
+
+const ADD_SQL: string = `ALTER TABLE "RumApplication" ADD "sessionReplaySameOriginTracePropagation" boolean NOT NULL DEFAULT true`;
+
+const DROP_SQL: string = `ALTER TABLE "RumApplication" DROP COLUMN "sessionReplaySameOriginTracePropagation"`;
+
+const CLASS_TIMESTAMP: RegExp = /(\d{13})$/;
+
+type MakeQueryRunnerResult = {
+  runner: QueryRunner;
+  statements: Array<string>;
+};
+
+type MakeQueryRunnerFunction = () => MakeQueryRunnerResult;
+
+const makeQueryRunner: MakeQueryRunnerFunction = (): MakeQueryRunnerResult => {
+  const statements: Array<string> = [];
+
+  const query: (...args: Array<unknown>) => Promise<undefined> = (
+    ...args: Array<unknown>
+  ): Promise<undefined> => {
+    statements.push(String(args[0]));
+    return Promise.resolve(undefined);
+  };
+
+  return {
+    runner: { query } as unknown as QueryRunner,
+    statements,
+  };
+};
+
+async function upStatements(): Promise<Array<string>> {
+  const { runner, statements } = makeQueryRunner();
+  await new AddSessionReplaySameOriginTracePropagation1794800000000().up(
+    runner,
+  );
+  return statements;
+}
+
+async function downStatements(): Promise<Array<string>> {
+  const { runner, statements } = makeQueryRunner();
+  await new AddSessionReplaySameOriginTracePropagation1794800000000().down(
+    runner,
+  );
+  return statements;
+}
+
+describe("executing it", () => {
+  test("up() adds exactly the one column and does nothing else", async () => {
+    expect(await upStatements()).toEqual([ADD_SQL]);
+  });
+
+  test("down() drops exactly that column and nothing else", async () => {
+    expect(await downStatements()).toEqual([DROP_SQL]);
+  });
+
+  /*
+   * On for existing applications too: the default IS the rollout. No
+   * UPDATE, because ADD COLUMN ... NOT NULL DEFAULT true already writes true
+   * into every existing row.
+   */
+  test("existing applications get the switch on through the column default, with no backfill", async () => {
+    const statements: Array<string> = await upStatements();
+
+    expect(statements[0]).toContain("boolean NOT NULL DEFAULT true");
+
+    for (const statement of [...statements, ...(await downStatements())]) {
+      expect(statement).not.toContain("UPDATE");
+      expect(statement).not.toContain("INDEX");
+      expect(statement).not.toContain("DEFAULT false");
+    }
+  });
+
+  test("every statement is a complete, single statement", async () => {
+    const statements: Array<string> = [
+      ...(await upStatements()),
+      ...(await downStatements()),
+    ];
+
+    expect(statements).toHaveLength(2);
+
+    for (const statement of statements) {
+      expect(statement).not.toContain(";");
+      expect(statement).not.toContain("\n");
+      expect(statement.trim()).toBe(statement);
+    }
+  });
+
+  test("is a MigrationInterface whose two steps are still named up and down", () => {
+    const migration: MigrationInterface =
+      new AddSessionReplaySameOriginTracePropagation1794800000000();
+
+    expect(typeof migration.up).toBe("function");
+    expect(typeof migration.down).toBe("function");
+    expect(
+      Object.getOwnPropertyNames(
+        AddSessionReplaySameOriginTracePropagation1794800000000.prototype,
+      ).sort(),
+    ).toEqual(["constructor", "down", "up"]);
+  });
+});
+
+describe("the migration runs", () => {
+  test("it is imported and listed in Index.ts", () => {
+    const index: string = fs.readFileSync(
+      path.join(MIGRATION_DIRECTORY, "Index.ts"),
+      "utf8",
+    );
+
+    expect(index).toContain(
+      `import { ${MIGRATION_CLASS_NAME} } from "./${MIGRATION_TIMESTAMP}-${MIGRATION_BASE_NAME}";`,
+    );
+    expect(index).toContain(`  ${MIGRATION_CLASS_NAME},\n`);
+  });
+
+  test("it is in the exported migration list, exactly once", () => {
+    expect(SchemaMigrations).toContain(
+      AddSessionReplaySameOriginTracePropagation1794800000000,
+    );
+    expect(
+      SchemaMigrations.filter((migration: unknown): boolean => {
+        return (
+          migration === AddSessionReplaySameOriginTracePropagation1794800000000
+        );
+      }),
+    ).toHaveLength(1);
+  });
+
+  /*
+   * TypeORM records applied migrations by `name`. A mismatch re-runs the
+   * migration on every boot, and an ADD COLUMN without IF NOT EXISTS fails
+   * the boot the second time.
+   */
+  test("its declared name, its class name and its timestamp agree", () => {
+    expect(
+      new AddSessionReplaySameOriginTracePropagation1794800000000().name,
+    ).toBe(MIGRATION_CLASS_NAME);
+    expect(AddSessionReplaySameOriginTracePropagation1794800000000.name).toBe(
+      MIGRATION_CLASS_NAME,
+    );
+    expect(
+      AddSessionReplaySameOriginTracePropagation1794800000000.name.match(
+        CLASS_TIMESTAMP,
+      )?.[1],
+    ).toBe(MIGRATION_TIMESTAMP);
+  });
+
+  test("exactly one file on disk carries its timestamp, and it is this one", () => {
+    const matching: Array<string> = fs
+      .readdirSync(MIGRATION_DIRECTORY)
+      .filter((file: string): boolean => {
+        return file.startsWith(`${MIGRATION_TIMESTAMP}-`);
+      });
+
+    expect(matching).toEqual([MIGRATION_FILE_NAME]);
+  });
+
+  test("its timestamp sorts after every migration registered before it", () => {
+    const position: number = SchemaMigrations.indexOf(
+      AddSessionReplaySameOriginTracePropagation1794800000000,
+    );
+
+    expect(position).toBeGreaterThan(-1);
+
+    const earlierTimestamps: Array<number> = [];
+
+    for (const migrationClass of SchemaMigrations.slice(0, position)) {
+      const match: RegExpMatchArray | null = (
+        migrationClass as { name: string }
+      ).name.match(CLASS_TIMESTAMP);
+
+      if (match) {
+        earlierTimestamps.push(Number(match[1]));
+      }
+    }
+
+    // Math.max() of an empty list is -Infinity; prove the list was read.
+    expect(earlierTimestamps.length).toBeGreaterThan(100);
+
+    expect(Number(MIGRATION_TIMESTAMP)).toBeGreaterThan(
+      Math.max(...earlierTimestamps),
+    );
+  });
+});
+
+/*
+ * The model side of the same contract. TypeORM generates the schema from
+ * these decorators, so a model column whose type, nullability or default
+ * disagrees with the migration is exactly the drift the Postgres Schema
+ * Drift workflow fails on.
+ */
+describe("the RumApplication model carries the column the migration adds", () => {
+  test("a non-nullable boolean defaulting to true", () => {
+    const args: ColumnMetadataArgs | undefined = getMetadataArgsStorage()
+      .columns.filter((candidate: ColumnMetadataArgs): boolean => {
+        return candidate.target === RumApplication;
+      })
+      .find((candidate: ColumnMetadataArgs): boolean => {
+        return (
+          candidate.propertyName === "sessionReplaySameOriginTracePropagation"
+        );
+      });
+
+    expect(args).toBeDefined();
+    expect(args?.options.type).toBe("boolean");
+    expect(args?.options.nullable).toBe(false);
+    expect(args?.options.default).toBe(true);
+  });
+});