@oneuptime/common 14.0.10 → 14.0.11

package/Server/Enterprise/EnterpriseEdition.ts

@@ -27,27 +27,80 @@ import PaymentRequiredException from "../../Types/Exception/PaymentRequiredExcep
  */
 const ENTERPRISE_FEATURE_BY_TABLE_NAME: ReadonlyMap<string, EnterpriseFeature> =
   new Map<string, EnterpriseFeature>([
-    ["GlobalSSO", EnterpriseFeature.SSO],
-    ["GlobalOIDC", EnterpriseFeature.SSO],
-    ["GlobalSSOProject", EnterpriseFeature.SSO],
-    ["GlobalOIDCProject", EnterpriseFeature.SSO],
-    ["ProjectSSO", EnterpriseFeature.SSO],
-    ["ProjectOIDC", EnterpriseFeature.SSO],
-    ["StatusPageSSO", EnterpriseFeature.SSO],
-    ["StatusPageOIDC", EnterpriseFeature.SSO],
     ["ProjectSCIM", EnterpriseFeature.SCIM],
     ["StatusPageSCIM", EnterpriseFeature.SCIM],
     ["TeamComplianceSetting", EnterpriseFeature.TeamCompliance],
   ]);
 
+/*
+ * The resource tables whose telemetry retention can be overridden: every
+ * table with both a retainTelemetryDataForDays and a telemetryRetentionConfig
+ * column (a guard test keeps this list complete).
+ */
+export const TELEMETRY_RETENTION_RESOURCE_TABLE_NAMES: ReadonlyArray<string> = [
+  "Service",
+  "Host",
+  "DockerHost",
+  "PodmanHost",
+  "DockerSwarmCluster",
+  "KubernetesCluster",
+  "ProxmoxCluster",
+  "CephCluster",
+  "VMwareVCenter",
+  "IoTFleet",
+  "CloudResource",
+  "ServerlessFunction",
+  "DatabaseServer",
+  "RumApplication",
+];
+
+/*
+ * Enterprise configuration kept in COLUMNS of core models rather than in a
+ * model of its own, keyed by table name and then column. Writing a value to
+ * one of these columns needs the column's feature, exactly as creating or
+ * updating an enterprise model does (see EditionPermissions); clearing it
+ * does not.
+ *
+ *   Project.telemetryRetentionConfig       retention by telemetry type,
+ *                                          project-wide. The project's
+ *                                          default retention
+ *                                          (defaultTelemetryRetentionInDays)
+ *                                          is not listed: every edition has it.
+ *   <resource>.retainTelemetryDataForDays  per-service and per-resource
+ *   <resource>.telemetryRetentionConfig    retention, and their retention by
+ *                                          telemetry type.
+ */
+const ENTERPRISE_FEATURE_BY_TABLE_COLUMN: ReadonlyMap<
+  string,
+  Readonly<Record<string, EnterpriseFeature>>
+> = new Map<string, Readonly<Record<string, EnterpriseFeature>>>([
+  [
+    "Project",
+    { telemetryRetentionConfig: EnterpriseFeature.TelemetryRetention },
+  ],
+  ...TELEMETRY_RETENTION_RESOURCE_TABLE_NAMES.map(
+    (
+      tableName: string,
+    ): [string, Readonly<Record<string, EnterpriseFeature>>] => {
+      return [
+        tableName,
+        {
+          retainTelemetryDataForDays: EnterpriseFeature.TelemetryRetention,
+          telemetryRetentionConfig: EnterpriseFeature.TelemetryRetention,
+        },
+      ];
+    },
+  ),
+]);
+
 /*
  * The features whose RUNTIME behaviour stops when a self-hosted license
  * lapses (see isFeatureActive), in the order the lapse log names them.
  */
 export const RUNTIME_ENTERPRISE_FEATURES: ReadonlyArray<EnterpriseFeature> = [
-  EnterpriseFeature.SSO,
   EnterpriseFeature.SCIM,
   EnterpriseFeature.AuditLogs,
+  EnterpriseFeature.TelemetryRetention,
 ];
 
 // How the lapse log names each feature.
@@ -55,11 +108,11 @@ const FEATURE_NAMES: ReadonlyMap<EnterpriseFeature, string> = new Map<
   EnterpriseFeature,
   string
 >([
-  [EnterpriseFeature.SSO, "single sign-on (SSO)"],
   [EnterpriseFeature.SCIM, "SCIM provisioning"],
   [EnterpriseFeature.AuditLogs, "audit logging"],
   [EnterpriseFeature.TeamCompliance, "team compliance"],
   [EnterpriseFeature.InstanceHealth, "the OneUptime Health dashboards"],
+  [EnterpriseFeature.TelemetryRetention, "retention overrides"],
 ]);
 
 /*
@@ -90,8 +143,7 @@ export type EnterpriseFeatureStateListener = (
  *                         jobs exist and which edition operators are told they
  *                         run.
  *   isFeatureActive()     the ee code is present AND the feature is licensed
- *                         right now. Governs RUNTIME behaviour: SSO sign-in
- *                         and "Require SSO for login" enforcement, SCIM
+ *                         right now. Governs RUNTIME behaviour: SCIM
  *                         provisioning and its team locks, audit-log
  *                         recording. When a self-hosted license lapses these
  *                         stop, exactly as on the Community Edition, and they
@@ -181,11 +233,11 @@ export default class EnterpriseEdition {
   }
 
   /*
-   * Whether the feature's runtime behaviour runs right now: SSO sign-in and
-   * "Require SSO for login" enforcement (SSO), SCIM provisioning and its team
-   * locks (SCIM), audit-log recording (AuditLogs). Synchronous, because it is
-   * asked on every request that could need it; the license changes at runtime
-   * and routers are mounted once, so callers ask per request.
+   * Whether the feature's runtime behaviour runs right now: SCIM provisioning
+   * and its team locks (SCIM), audit-log recording (AuditLogs). Synchronous,
+   * because it is asked on every request that could need it; the license
+   * changes at runtime and routers are mounted once, so callers ask per
+   * request.
    *
    *   no enterprise module        false (the Community Edition)
    *   billing on                  true (OneUptime Cloud: plan tiers gate)
@@ -196,8 +248,8 @@ export default class EnterpriseEdition {
    *                               read or written yet, so whether the trial
    *                               is over is not known; see
    *                               EnterpriseLicenseSnapshotUtil.isTrialStartUnknown).
-   *                               An unknown state must never lock anyone out
-   *                               or switch SSO enforcement off. The loader
+   *                               An unknown state must never stop SCIM
+   *                               provisioning or audit logging. The loader
    *                               waits (bounded) for the first snapshot
    *                               before any router is mounted, so the window
    *                               is small. Warned about once per process.
@@ -228,7 +280,7 @@ export default class EnterpriseEdition {
       if (!EnterpriseEdition.hasWarnedAboutUnreadableLicense) {
         EnterpriseEdition.hasWarnedAboutUnreadableLicense = true;
         logger.warn(
-          "EnterpriseEdition: could not read the cached license snapshot. Until it can be read, SSO, SCIM and audit logging keep running as if licensed. This warning is logged once per process.",
+          "EnterpriseEdition: could not read the cached license snapshot. Until it can be read, SCIM and audit logging keep running as if licensed. This warning is logged once per process.",
         );
         logger.warn(err);
       }
@@ -240,7 +292,7 @@ export default class EnterpriseEdition {
       if (!EnterpriseEdition.hasWarnedAboutUnreadLicense) {
         EnterpriseEdition.hasWarnedAboutUnreadLicense = true;
         logger.warn(
-          "EnterpriseEdition: the license has not been read yet. Until it is, SSO, SCIM and audit logging keep running as if licensed. This warning is logged once per process.",
+          "EnterpriseEdition: the license has not been read yet. Until it is, SCIM and audit logging keep running as if licensed. This warning is logged once per process.",
         );
       }
 
@@ -257,7 +309,7 @@ export default class EnterpriseEdition {
            * trial (LicenseToken's classifyUnverifiedWithoutExpiry), so this
            * must not assert that nothing is installed.
            */
-          `EnterpriseEdition: there is no license this installation can date, and the start of the ${ENTERPRISE_LICENSE_TRIAL_PERIOD_IN_DAYS}-day trial has not been recorded yet, so it is not known whether the trial is over. Until it is recorded, SSO, SCIM and audit logging keep running as if licensed. This warning is logged once per process.`,
+          `EnterpriseEdition: there is no license this installation can date, and the start of the ${ENTERPRISE_LICENSE_TRIAL_PERIOD_IN_DAYS}-day trial has not been recorded yet, so it is not known whether the trial is over. Until it is recorded, SCIM and audit logging keep running as if licensed. This warning is logged once per process.`,
         );
       }
 
@@ -481,6 +533,25 @@ export default class EnterpriseEdition {
     return ENTERPRISE_FEATURE_BY_TABLE_NAME.get(tableName) || null;
   }
 
+  /*
+   * The enterprise columns of a table, as column -> feature, or null when
+   * the table has none (see ENTERPRISE_FEATURE_BY_TABLE_COLUMN).
+   */
+  public static getEnterpriseColumnsForTableName(
+    tableName: string | null | undefined,
+  ): Readonly<Record<string, EnterpriseFeature>> | null {
+    if (!tableName) {
+      return null;
+    }
+
+    return ENTERPRISE_FEATURE_BY_TABLE_COLUMN.get(tableName) || null;
+  }
+
+  // Every table with enterprise columns (for guard tests).
+  public static getTableNamesWithEnterpriseColumns(): Array<string> {
+    return Array.from(ENTERPRISE_FEATURE_BY_TABLE_COLUMN.keys());
+  }
+
   // Every table name the facade maps to a feature (for guard tests).
   public static getMappedTableNames(): Array<string> {
     return Array.from(ENTERPRISE_FEATURE_BY_TABLE_NAME.keys());
@@ -513,12 +584,6 @@ export default class EnterpriseEdition {
         : `The OneUptime Enterprise license has lapsed (status: ${snapshot.status}): ${names} ${verb} stopped until a license is activated.`,
     ];
 
-    if (stopped.includes(EnterpriseFeature.SSO)) {
-      parts.push(
-        '"Require SSO for login" is not enforced meanwhile: users sign in with their password, and users who only ever signed in with SSO can reset their password.',
-      );
-    }
-
     if (snapshot.message) {
       parts.push(`License status: ${snapshot.message}`);
     }

package/Server/Enterprise/EnterpriseFeature.ts

@@ -4,19 +4,40 @@
  * The string values are part of the license format: a signed license carries
  * a `features` claim that is either ["*"] (everything) or a subset of these
  * values. Renaming a value therefore silently revokes that feature from every
- * license already issued, so values are append-only.
+ * license already issued, so values are append-only. A value that stops
+ * naming a feature is retired for good (RETIRED_ENTERPRISE_FEATURE_VALUES)
+ * and never names another one.
  */
 enum EnterpriseFeature {
-  SSO = "sso",
   SCIM = "scim",
   TeamCompliance = "team-compliance",
   AuditLogs = "audit-logs",
   InstanceHealth = "instance-health",
+  /*
+   * Retention overrides: retention by telemetry type (Project, and every
+   * service and resource), and per-service and per-resource retention.
+   * The project-wide default retention is not part of it.
+   */
+  TelemetryRetention = "telemetry-retention",
 }
 
 export const ALL_ENTERPRISE_FEATURES: ReadonlyArray<EnterpriseFeature> =
   Object.values(EnterpriseFeature);
 
+/*
+ * License claim values that once named a feature and must never name one
+ * again. Licenses already issued can still carry them: they parse like any
+ * unknown name (parseEnterpriseFeature returns null) and grant nothing.
+ * Giving one of them to a new feature would silently grant that feature to
+ * every such license.
+ *
+ *   "sso"  single sign-on (SAML, OIDC, global SSO and "Require SSO for
+ *          login"), which is part of the Community Edition and needs no
+ *          license. Releases up to 14.0.10 still gate single sign-on on this
+ *          claim or on "*".
+ */
+export const RETIRED_ENTERPRISE_FEATURE_VALUES: ReadonlyArray<string> = ["sso"];
+
 /*
  * The license claim value that entitles every feature, including ones added
  * after the license was issued.
@@ -27,7 +48,8 @@ export const ENTERPRISE_FEATURE_WILDCARD: string = "*";
  * Narrows an untrusted string (a license claim, a request body) to a feature.
  * Unknown values return null rather than throwing, so a license issued by a
  * newer license server that names a feature this build has never heard of is
- * still readable: the unknown name is simply not granted.
+ * still readable: the unknown name is simply not granted. A retired value
+ * (RETIRED_ENTERPRISE_FEATURE_VALUES) is read the same way.
  */
 export const parseEnterpriseFeature: (
   value: unknown,

package/Server/Enterprise/EnterpriseLicenseSnapshot.ts

@@ -108,7 +108,7 @@ export interface EnterpriseLicenseSnapshot {
  * GlobalConfig.enterpriseEditionFirstSeenAt.
  *
  * Until either ends nothing changes; after it, enterprise configuration
- * becomes read-only and SSO, SCIM and audit logging stop
+ * becomes read-only and SCIM provisioning and audit logging stop
  * (EnterpriseEdition.isFeatureActive) until a license is activated. They are
  * defined in Common/Types so the browser copy derives the same numbers.
  */

package/Server/Enterprise/EnterpriseServerModule.ts

@@ -99,7 +99,10 @@ export default interface EnterpriseServerModule {
   licensing: EnterpriseLicensingProvider;
 
   /*
-   * Mounted at ["/api/identity", "/"] right after core's identity routers.
+   * The enterprise identity routers (today: SCIM provisioning). Mounted at
+   * ["/api/identity", "/"] right after core's identity routers
+   * (authentication, reseller and single sign-on, which core serves in every
+   * edition) and before the status page authentication router.
    * RULE for every router below: no layer without a route (no router.use), because
    * a path-less middleware in a router mounted at "/" or ahead of a core router
    * runs for requests meant for core routes.

package/Server/EnvironmentConfig.ts

@@ -1141,7 +1141,7 @@ export const OneUptimeEnterpriseDirectory: string | undefined =
 
 /*
  * The hosted oneuptime.com (billing enabled) must run the Enterprise image:
- * on the Community image paid SSO and audit logging would silently stop, and
+ * on the Community image paid SCIM and audit logging would silently stop, and
  * the license server self-hosted customers activate against would be gone. The
  * boot refuses that combination unless this development escape hatch is set.
  */

package/Server/Infrastructure/Postgres/SchemaMigrations/1796400000000-AddIncidentForms.ts

@@ -0,0 +1,129 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Generated with npm run generate-postgres-migration, then renumbered after
+ * the last registered migration. Incident forms and the per-template custom
+ * field settings (issue #4114):
+ *
+ *   - IncidentForm: forms anyone with the link can fill in to declare an
+ *     incident. shareKey is the key in the public link, unique across all
+ *     projects (the unique constraint is also the index a visit is looked up
+ *     by). incidentSeverityId is required by the app but nullable here:
+ *     deleting a severity - or a template, for incidentTemplateId - clears
+ *     it on the forms that use it, rather than being blocked by them or
+ *     deleting them;
+ *   - IncidentFormSubmission: one row per submission, deleted with its form
+ *     and kept, with no incident, when its incident is deleted;
+ *   - IncidentTemplate.customFieldSettings: which custom fields the Declare
+ *     Incident form asks for when an incident is declared from a template.
+ *     Nullable with no default, so every existing template keeps asking
+ *     exactly what it asked before.
+ */
+
+export class AddIncidentForms1796400000000 implements MigrationInterface {
+  public name: string = "AddIncidentForms1796400000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "IncidentForm" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(100) NOT NULL, "description" text, "isEnabled" boolean NOT NULL DEFAULT true, "shareKey" uuid NOT NULL, "incidentSeverityId" uuid, "allowReporterToChooseSeverity" boolean NOT NULL DEFAULT false, "incidentTemplateId" uuid, "descriptionSetting" character varying(100) NOT NULL DEFAULT 'Optional', "customFieldSettings" jsonb, "isReporterDetailsRequired" boolean NOT NULL DEFAULT true, "successMessage" text, "ipWhitelist" text, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "UQ_9c11c2b692cea31727c95c28e98" UNIQUE ("shareKey"), CONSTRAINT "PK_21977001f0d4b88fbc0135c7dd0" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c7eb6e8981e8f6e9a2fe53b6bb" ON "IncidentForm" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_473919ea7b451ba0dfc871a4c6" ON "IncidentForm" ("incidentSeverityId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c94880b38a72f9b03328477c48" ON "IncidentForm" ("incidentTemplateId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "IncidentFormSubmission" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "incidentFormId" uuid NOT NULL, "incidentId" uuid, "reporterName" character varying(100), "reporterEmail" character varying(100), CONSTRAINT "PK_1b520515a97ed5403da203f4ab4" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_56fa38b3bc7c97117dac332110" ON "IncidentFormSubmission" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_4fe1421ca5d762a0f1a8f78c68" ON "IncidentFormSubmission" ("incidentFormId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_44b1e21a80ccad4238d803c17d" ON "IncidentFormSubmission" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentTemplate" ADD "customFieldSettings" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" ADD CONSTRAINT "FK_c7eb6e8981e8f6e9a2fe53b6bb8" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" ADD CONSTRAINT "FK_473919ea7b451ba0dfc871a4c6e" FOREIGN KEY ("incidentSeverityId") REFERENCES "IncidentSeverity"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" ADD CONSTRAINT "FK_c94880b38a72f9b03328477c48c" FOREIGN KEY ("incidentTemplateId") REFERENCES "IncidentTemplate"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" ADD CONSTRAINT "FK_850356f3fc192628a97681f9385" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" ADD CONSTRAINT "FK_76e881e65b593b3980158fadf81" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" ADD CONSTRAINT "FK_56fa38b3bc7c97117dac3321103" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" ADD CONSTRAINT "FK_4fe1421ca5d762a0f1a8f78c687" FOREIGN KEY ("incidentFormId") REFERENCES "IncidentForm"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" ADD CONSTRAINT "FK_44b1e21a80ccad4238d803c17da" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" DROP CONSTRAINT "FK_44b1e21a80ccad4238d803c17da"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" DROP CONSTRAINT "FK_4fe1421ca5d762a0f1a8f78c687"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentFormSubmission" DROP CONSTRAINT "FK_56fa38b3bc7c97117dac3321103"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" DROP CONSTRAINT "FK_76e881e65b593b3980158fadf81"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" DROP CONSTRAINT "FK_850356f3fc192628a97681f9385"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" DROP CONSTRAINT "FK_c94880b38a72f9b03328477c48c"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" DROP CONSTRAINT "FK_473919ea7b451ba0dfc871a4c6e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentForm" DROP CONSTRAINT "FK_c7eb6e8981e8f6e9a2fe53b6bb8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "IncidentTemplate" DROP COLUMN "customFieldSettings"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_44b1e21a80ccad4238d803c17d"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_4fe1421ca5d762a0f1a8f78c68"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_56fa38b3bc7c97117dac332110"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentFormSubmission"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c94880b38a72f9b03328477c48"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_473919ea7b451ba0dfc871a4c6"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c7eb6e8981e8f6e9a2fe53b6bb"`,
+    );
+    await queryRunner.query(`DROP TABLE "IncidentForm"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1796500000000-AddTeamComplianceRuleNotificationChannels.ts

@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Generated with npm run generate-postgres-migration, then renumbered after
+ * the last registered migration, and given the backfill below.
+ *
+ * "notificationChannels": the channels an on-call compliance rule insists on,
+ * as a list - a member needs a rule on every one of them. Empty (or NULL) is
+ * "any channel". It replaces "notificationChannel", which could hold only one
+ * channel, as what a rule checks.
+ *
+ * "notificationChannel" is kept, not dropped. Everything that only knows that
+ * column - API clients from before the list, and a replica of the previous
+ * build still serving while this one rolls out - keeps reading and writing
+ * it, and TeamComplianceSettingService keeps it equal to the first channel of
+ * the list. See TeamComplianceSettingService.getStoredChannels for how a row
+ * is read when the two disagree.
+ */
+export class AddTeamComplianceRuleNotificationChannels1796500000000
+  implements MigrationInterface
+{
+  public name: string =
+    "AddTeamComplianceRuleNotificationChannels1796500000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSetting" ADD "notificationChannels" jsonb`,
+    );
+
+    /*
+     * Every rule that insists on a channel gets it as a one-item list, so it
+     * checks exactly what it checked before - and opens in the edit form,
+     * which reads only the list, with its channel still selected. A rule on
+     * any channel is left NULL, which reads as "any channel" too.
+     */
+    await queryRunner.query(
+      `UPDATE "TeamComplianceSetting" SET "notificationChannels" = jsonb_build_array("notificationChannel") WHERE "notificationChannel" IS NOT NULL AND "notificationChannels" IS NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * "notificationChannel" still holds each rule's first channel, so going
+     * back leaves every rule checking that one channel - never widened to
+     * "any channel". A rule on several channels loses the rest, the
+     * unavoidable cost of a schema that cannot hold them.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "TeamComplianceSetting" DROP COLUMN "notificationChannels"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1796600000000-AddAIInvestigationConversationAndTimeLimits.ts

@@ -0,0 +1,75 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Generated with npm run generate-postgres-migration, then renumbered after
+ * the last registered migration.
+ *
+ *   - AIConversation.incidentId / alertId: the one shared conversation in an
+ *     incident's or alert's AI investigation box, where every responder asks
+ *     OneUptime AI questions and asks it to act. Indexed (the box looks its
+ *     thread up by subject) and deleted with its incident or alert. Nullable,
+ *     so every existing (personal) conversation is untouched.
+ *   - Project.incidentAiInvestigationTimeLimitInMinutes /
+ *     alertAiInvestigationTimeLimitInMinutes: an optional time limit per
+ *     lane. Nullable with no default: investigations have no time limit
+ *     unless a project sets one.
+ */
+
+export class AddAIInvestigationConversationAndTimeLimits1796600000000
+  implements MigrationInterface
+{
+  public name: string =
+    "AddAIInvestigationConversationAndTimeLimits1796600000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "incidentAiInvestigationTimeLimitInMinutes" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "alertAiInvestigationTimeLimitInMinutes" integer`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" ADD "incidentId" uuid`,
+    );
+    await queryRunner.query(`ALTER TABLE "AIConversation" ADD "alertId" uuid`);
+    await queryRunner.query(
+      `CREATE INDEX "IDX_3e33d202ee06482ea5bdfae6ec" ON "AIConversation" ("incidentId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_def9bb6def011eb0e7790cd91e" ON "AIConversation" ("alertId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" ADD CONSTRAINT "FK_3e33d202ee06482ea5bdfae6ec8" FOREIGN KEY ("incidentId") REFERENCES "Incident"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" ADD CONSTRAINT "FK_def9bb6def011eb0e7790cd91e3" FOREIGN KEY ("alertId") REFERENCES "Alert"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" DROP CONSTRAINT "FK_def9bb6def011eb0e7790cd91e3"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" DROP CONSTRAINT "FK_3e33d202ee06482ea5bdfae6ec8"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_def9bb6def011eb0e7790cd91e"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_3e33d202ee06482ea5bdfae6ec"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" DROP COLUMN "alertId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIConversation" DROP COLUMN "incidentId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Project" DROP COLUMN "alertAiInvestigationTimeLimitInMinutes"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Project" DROP COLUMN "incidentAiInvestigationTimeLimitInMinutes"`,
+    );
+  }
+}