@oneuptime/common 13.0.0 → 13.0.1

package/Tests/Server/Services/TeamMemberInviteRegistrationToken.test.ts

@@ -138,6 +138,9 @@ beforeEach(() => {
 
   // No existing membership - the duplicate-invite guard at the end of the hook.
   jest.spyOn(TeamMemberService, "findOneBy").mockResolvedValue(null);
+  jest
+    .spyOn(TeamMemberService, "getUniqueTeamMemberCountInProject")
+    .mockResolvedValue(0);
 
   jest
     .spyOn(ProjectService, "findOneById")

package/Tests/Server/Services/TelemetryIngestionKeyPolicyResolution.test.ts

@@ -4,6 +4,15 @@ import ObjectID from "../../../Types/ObjectID";
 import TelemetryIngestionKeyPolicy from "../../../Types/Telemetry/TelemetryIngestionKeyPolicy";
 import TelemetryIngestionKeyType from "../../../Types/Telemetry/TelemetryIngestionKeyType";
 import TelemetryIngestionKeyService from "../../../Server/Services/TelemetryIngestionKeyService";
+import PayAsYouGoBillingService from "../../../Server/Services/PayAsYouGoBillingService";
+
+// Payment eligibility is covered by the billing admission suites.
+jest.mock("../../../Server/Services/PayAsYouGoBillingService", () => {
+  return {
+    __esModule: true,
+    default: { requirePayAsYouGo: jest.fn().mockResolvedValue(undefined) },
+  };
+});
 
 /*
  * Every TelemetryIngestionKey in every installation that exists today was
@@ -811,4 +820,67 @@ describe("TelemetryIngestionKeyService policy resolution", () => {
       expect(findOneByMock).toHaveBeenCalledTimes(1);
     });
   });
+
+  /*
+   * This path runs for every ingested batch, and it is the only caller
+   * allowed to answer from a cached denial. Without the flag, an unpaid
+   * project re-reads the payment provider once per batch - which is what held
+   * the whole Stripe account at its rate limit and took the billing page down
+   * with it. Nothing else asserts the flag is passed, so removing it here
+   * would be a silent regression back to that behaviour.
+   */
+  describe("billing admission", () => {
+    test("admits ingest with a denial that may be a few seconds stale", async () => {
+      const requirePayAsYouGo: jest.Mock =
+        PayAsYouGoBillingService.requirePayAsYouGo as unknown as jest.Mock;
+      requirePayAsYouGo.mockClear();
+
+      const token: string = ObjectID.generate().toString();
+      const projectId: ObjectID = ObjectID.generate();
+      installRows({
+        [token]: {
+          _id: ObjectID.generate(),
+          projectId: projectId,
+          isEnabled: true,
+        },
+      });
+
+      await TelemetryIngestionKeyService.getPolicyFromSecretKey(token);
+
+      expect(requirePayAsYouGo).toHaveBeenCalledTimes(1);
+      expect(requirePayAsYouGo).toHaveBeenCalledWith(
+        expect.objectContaining({ value: projectId.value }),
+        expect.objectContaining({ allowStaleDenial: true }),
+      );
+    });
+
+    test("re-checks billing on a policy cache hit, still allowing a stale denial", async () => {
+      const requirePayAsYouGo: jest.Mock =
+        PayAsYouGoBillingService.requirePayAsYouGo as unknown as jest.Mock;
+      requirePayAsYouGo.mockClear();
+
+      const token: string = ObjectID.generate().toString();
+      installRows({
+        [token]: {
+          _id: ObjectID.generate(),
+          projectId: ObjectID.generate(),
+          isEnabled: true,
+        },
+      });
+
+      await TelemetryIngestionKeyService.getPolicyFromSecretKey(token);
+      await TelemetryIngestionKeyService.getPolicyFromSecretKey(token);
+
+      /*
+       * A live key must not outlive billing eligibility, so the check runs on
+       * the cache hit too - which is exactly why it has to be cheap.
+       */
+      expect(requirePayAsYouGo).toHaveBeenCalledTimes(2);
+      for (const call of requirePayAsYouGo.mock.calls) {
+        expect(call[1]).toEqual(
+          expect.objectContaining({ allowStaleDenial: true }),
+        );
+      }
+    });
+  });
 });

package/Tests/Server/Services/TelemetryIngestionKeyValidation.test.ts

@@ -17,6 +17,18 @@ import TelemetryIngestionKeyType from "../../../Types/Telemetry/TelemetryIngesti
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import { beforeEach, describe, expect, jest, test } from "@jest/globals";
 
+// Payment eligibility is covered by the billing admission suites.
+jest.mock("../../../Server/Services/PayAsYouGoBillingService", () => {
+  return {
+    __esModule: true,
+    default: {
+      requirePayAsYouGo: jest
+        .fn<() => Promise<void>>()
+        .mockResolvedValue(undefined),
+    },
+  };
+});
+
 /*
  * WHAT THIS FILE IS DEFENDING
  *
@@ -51,8 +63,9 @@ import { beforeEach, describe, expect, jest, test } from "@jest/globals";
  *      "you may not empty this list" guard.
  *   3. COST. The guard that refuses an empty allowlist has to read the rows
  *      the update matches. That read must happen ONLY when the patch actually
- *      empties the list - the common update (rename, toggle isEnabled, set an
- *      expiry) must not start paying a query for a rule it cannot break.
+ *      empties the list. Renaming, disabling, or setting an expiry must not
+ *      start paying a query for a rule they cannot break. Re-enabling has its
+ *      own billing check, covered by TelemetryPayAsYouGoBilling.test.ts.
  *
  * Nothing here touches Postgres or Redis: the hooks are invoked directly on a
  * fresh service instance whose findBy/findOneBy are stubbed.
@@ -130,7 +143,7 @@ function buildService(): Harness {
 function createByModel(payload: Record<string, unknown>): CreateBy<Model> {
   return {
     data: Object.assign(new Model(), payload) as Model,
-    props: { isRoot: true },
+    props: { isRoot: true, tenantId: PROJECT_ID },
   };
 }
 
@@ -141,7 +154,7 @@ function createByModel(payload: Record<string, unknown>): CreateBy<Model> {
 function createByBag(payload: Record<string, unknown>): CreateBy<Model> {
   return {
     data: payload as unknown as Model,
-    props: { isRoot: true },
+    props: { isRoot: true, tenantId: PROJECT_ID },
   };
 }
 

package/Tests/Server/Services/TelemetryPayAsYouGoBilling.test.ts

@@ -0,0 +1,355 @@
+import TelemetryIngestionKeyService, {
+  Service,
+} from "../../../Server/Services/TelemetryIngestionKeyService";
+import PayAsYouGoBillingService from "../../../Server/Services/PayAsYouGoBillingService";
+import TelemetryIngest, {
+  TelemetryRequest,
+} from "../../../Server/Middleware/TelemetryIngest";
+import TelemetryIngestionKey from "../../../Models/DatabaseModels/TelemetryIngestionKey";
+import CreateBy from "../../../Server/Types/Database/CreateBy";
+import UpdateBy from "../../../Server/Types/Database/UpdateBy";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../../../Server/Utils/Express";
+import TelemetryIngestSurface from "../../../Types/Telemetry/TelemetryIngestSurface";
+import TelemetryIngestionKeyType from "../../../Types/Telemetry/TelemetryIngestionKeyType";
+import PaymentRequiredException from "../../../Types/Exception/PaymentRequiredException";
+import ObjectID from "../../../Types/ObjectID";
+import * as EnvironmentConfig from "../../../Server/EnvironmentConfig";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+jest.mock("../../../Server/EnvironmentConfig", () => {
+  return {
+    __esModule: true,
+    ...(jest.requireActual(
+      "../../../Server/EnvironmentConfig",
+    ) as typeof EnvironmentConfig),
+    IsBillingEnabled: true,
+  };
+});
+
+type KeyHooks = {
+  onBeforeCreate: (input: CreateBy<TelemetryIngestionKey>) => Promise<unknown>;
+  onBeforeUpdate: (input: UpdateBy<TelemetryIngestionKey>) => Promise<unknown>;
+};
+let service: Service;
+let hooks: KeyHooks;
+const projectId: ObjectID = ObjectID.generate();
+const otherProjectId: ObjectID = ObjectID.generate();
+
+function key(project: ObjectID = projectId): TelemetryIngestionKey {
+  return Object.assign(new TelemetryIngestionKey(), {
+    id: ObjectID.generate(),
+    projectId: project,
+    secretKey: ObjectID.generate(),
+    isEnabled: true,
+    keyType: TelemetryIngestionKeyType.Server,
+  });
+}
+
+function createInput(): CreateBy<TelemetryIngestionKey> {
+  return { data: key(), props: { tenantId: projectId } };
+}
+
+function updateInput(
+  data: UpdateBy<TelemetryIngestionKey>["data"],
+): UpdateBy<TelemetryIngestionKey> {
+  return {
+    data,
+    query: { _id: ObjectID.generate().toString() },
+    props: { isRoot: true },
+    limit: 10,
+    skip: 0,
+  };
+}
+
+type PaymentCheck = Parameters<
+  typeof PayAsYouGoBillingService.canUsePayAsYouGo
+>;
+
+/*
+ * requirePayAsYouGo forwards its own options argument straight through to
+ * canUsePayAsYouGo, so a recorded check carries a second argument as well as
+ * the project. Assert the two things that decide the outcome rather than the
+ * exact argument list: whose payment setup was read, and that creating or
+ * enabling a key stays a read-through check. Only ingest admission - which
+ * runs per batch and whose client retries - opts into answering from a cached
+ * denial; a key the user just created must not be refused because of one.
+ */
+function expectPaymentCheckedFor(project: ObjectID): void {
+  const checks: Array<PaymentCheck> = jest.mocked(
+    PayAsYouGoBillingService.canUsePayAsYouGo,
+  ).mock.calls;
+
+  expect(
+    checks.map((check: PaymentCheck): string => {
+      return check[0].toString();
+    }),
+  ).toEqual([project.toString()]);
+
+  for (const check of checks) {
+    expect(check[1]?.allowStaleDenial).toBeFalsy();
+  }
+}
+
+beforeEach(() => {
+  jest.restoreAllMocks();
+  (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled = true;
+  service = new Service();
+  hooks = service as unknown as KeyHooks;
+  jest
+    .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+    .mockResolvedValue(false);
+  jest.spyOn(service, "findBy").mockResolvedValue([]);
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe("telemetry key creation and enablement payment admission", () => {
+  test.each(Object.values(TelemetryIngestionKeyType))(
+    "requires payment setup to create a %s key",
+    async (keyType: TelemetryIngestionKeyType) => {
+      const input: CreateBy<TelemetryIngestionKey> = createInput();
+      input.data.keyType = keyType;
+      input.data.allowedOrigins = ["https://example.com"];
+      await expect(hooks.onBeforeCreate(input)).rejects.toBeInstanceOf(
+        PaymentRequiredException,
+      );
+    },
+  );
+
+  test("also guards legacy create requests without a key type", async () => {
+    const input: CreateBy<TelemetryIngestionKey> = createInput();
+    delete input.data.keyType;
+    await expect(hooks.onBeforeCreate(input)).rejects.toThrow(
+      "Project Settings > Billing",
+    );
+  });
+
+  test("checks the authenticated tenant instead of the payload project", async () => {
+    const input: CreateBy<TelemetryIngestionKey> = createInput();
+    input.data.projectId = otherProjectId;
+    await expect(hooks.onBeforeCreate(input)).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    expectPaymentCheckedFor(projectId);
+  });
+
+  test("uses the project on an internal create without a request tenant", async () => {
+    const input: CreateBy<TelemetryIngestionKey> = createInput();
+    input.props = { isRoot: true };
+    await expect(hooks.onBeforeCreate(input)).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    expectPaymentCheckedFor(projectId);
+  });
+
+  test("does not admit a billed create without a project", async () => {
+    await expect(
+      hooks.onBeforeCreate({
+        data: new TelemetryIngestionKey(),
+        props: { isRoot: true },
+      }),
+    ).rejects.toThrow("ProjectId required");
+  });
+
+  test("allows key creation when payment setup is authorized", async () => {
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    await expect(hooks.onBeforeCreate(createInput())).resolves.toBeDefined();
+  });
+
+  test("preserves self-hosted key creation without consulting billing", async () => {
+    (EnvironmentConfig as { IsBillingEnabled: boolean }).IsBillingEnabled =
+      false;
+    await expect(hooks.onBeforeCreate(createInput())).resolves.toBeDefined();
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+  });
+
+  test("guards re-enabling an existing key using its stored project", async () => {
+    jest.spyOn(service, "findBy").mockResolvedValue([key(otherProjectId)]);
+    const input: UpdateBy<TelemetryIngestionKey> = updateInput({
+      isEnabled: true,
+    });
+    input.props.tenantId = projectId;
+    await expect(hooks.onBeforeUpdate(input)).rejects.toBeInstanceOf(
+      PaymentRequiredException,
+    );
+    expectPaymentCheckedFor(otherProjectId);
+  });
+
+  test("checks every distinct project of a bulk enable operation", async () => {
+    jest
+      .spyOn(service, "findBy")
+      .mockResolvedValue([key(), key(), key(otherProjectId)]);
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockImplementation(async (id: ObjectID): Promise<boolean> => {
+        return id.toString() === projectId.toString();
+      });
+    await expect(
+      hooks.onBeforeUpdate(updateInput({ isEnabled: true })),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).toHaveBeenCalledTimes(2);
+  });
+
+  test("scopes a non-root enable lookup to the request tenant", async () => {
+    const input: UpdateBy<TelemetryIngestionKey> = updateInput({
+      isEnabled: true,
+    });
+    input.props = { tenantId: projectId };
+    await hooks.onBeforeUpdate(input);
+    expect(service.findBy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        query: { ...input.query, projectId },
+        limit: input.limit,
+        skip: input.skip,
+      }),
+    );
+  });
+
+  test.each([{ isEnabled: false }, { name: "Renamed key" }])(
+    "allows a nonbillable update %j without payment setup",
+    async (data: UpdateBy<TelemetryIngestionKey>["data"]) => {
+      await expect(
+        hooks.onBeforeUpdate(updateInput(data)),
+      ).resolves.toBeDefined();
+      expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+      expect(service.findBy).not.toHaveBeenCalled();
+    },
+  );
+});
+
+describe("existing key payment admission", () => {
+  test("rejects existing enabled keys before returning their policy or project", async () => {
+    const existingKey: TelemetryIngestionKey = key();
+    jest.spyOn(service, "findOneBy").mockResolvedValue(existingKey);
+    await expect(
+      service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    await expect(
+      service.getProjectIdFromSecretKey(existingKey.secretKey!.toString()),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+  });
+
+  test("checks cached keys again so removing payment setup cannot leave an admitted key indefinitely", async () => {
+    const existingKey: TelemetryIngestionKey = key();
+    jest.spyOn(service, "findOneBy").mockResolvedValue(existingKey);
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    await expect(
+      service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+    ).resolves.toMatchObject({ projectId });
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(false);
+    await expect(
+      service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    expect(service.findOneBy).toHaveBeenCalledTimes(1);
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).toHaveBeenCalledTimes(2);
+  });
+
+  test("starts accepting an existing key after payment setup succeeds", async () => {
+    const existingKey: TelemetryIngestionKey = key();
+    jest.spyOn(service, "findOneBy").mockResolvedValue(existingKey);
+    await expect(
+      service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+    ).rejects.toBeInstanceOf(PaymentRequiredException);
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    await expect(
+      service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+    ).resolves.toMatchObject({ projectId });
+    expect(service.findOneBy).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([{ isEnabled: false }, { expiresAt: new Date(0) }])(
+    "retains diagnostic policy resolution for unusable keys %j",
+    async (state: Partial<TelemetryIngestionKey>) => {
+      const existingKey: TelemetryIngestionKey = Object.assign(key(), state);
+      jest.spyOn(service, "findOneBy").mockResolvedValue(existingKey);
+      await expect(
+        service.getPolicyFromSecretKey(existingKey.secretKey!.toString()),
+      ).resolves.toMatchObject({ projectId });
+      expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+    },
+  );
+
+  test("does not consult billing when no key resolves", async () => {
+    jest.spyOn(service, "findOneBy").mockResolvedValue(null);
+    await expect(
+      service.getPolicyFromSecretKey(ObjectID.generate().toString()),
+    ).resolves.toBeNull();
+    expect(PayAsYouGoBillingService.canUsePayAsYouGo).not.toHaveBeenCalled();
+  });
+});
+
+describe("HTTP telemetry admission integrates key resolution and billing", () => {
+  test.each(Object.values(TelemetryIngestSurface))(
+    "prevents existing no-card keys reaching the %s handler",
+    async (surface: TelemetryIngestSurface) => {
+      const existingKey: TelemetryIngestionKey = key();
+      jest
+        .spyOn(TelemetryIngestionKeyService, "findOneBy")
+        .mockResolvedValue(existingKey);
+      jest
+        .spyOn(TelemetryIngestionKeyService, "markUsed")
+        .mockResolvedValue(undefined);
+      const request: ExpressRequest = {
+        headers: { "x-oneuptime-token": existingKey.secretKey!.toString() },
+      } as unknown as ExpressRequest;
+      const next: NextFunction = jest.fn() as unknown as NextFunction;
+      await TelemetryIngest.forSurface(surface)(
+        request,
+        {} as ExpressResponse,
+        next as NextFunction,
+      );
+      expect(next).toHaveBeenCalledTimes(1);
+      expect(next).toHaveBeenCalledWith(expect.any(PaymentRequiredException));
+      expect((request as TelemetryRequest).projectId).toBeUndefined();
+      expect(TelemetryIngestionKeyService.markUsed).not.toHaveBeenCalled();
+    },
+  );
+
+  test("continues to the handler after payment setup with the stored key project", async () => {
+    const existingKey: TelemetryIngestionKey = key(otherProjectId);
+    jest
+      .spyOn(TelemetryIngestionKeyService, "findOneBy")
+      .mockResolvedValue(existingKey);
+    jest
+      .spyOn(TelemetryIngestionKeyService, "markUsed")
+      .mockResolvedValue(undefined);
+    jest
+      .spyOn(PayAsYouGoBillingService, "canUsePayAsYouGo")
+      .mockResolvedValue(true);
+    const request: ExpressRequest = {
+      headers: { "x-oneuptime-token": existingKey.secretKey!.toString() },
+    } as unknown as ExpressRequest;
+    const next: NextFunction = jest.fn() as unknown as NextFunction;
+    await TelemetryIngest.isAuthorizedServiceMiddleware(
+      request,
+      {} as ExpressResponse,
+      next as NextFunction,
+    );
+    expect(next).toHaveBeenCalledWith();
+    expect((request as TelemetryRequest).projectId.toString()).toBe(
+      otherProjectId.toString(),
+    );
+    expect(TelemetryIngestionKeyService.markUsed).toHaveBeenCalledTimes(1);
+  });
+});

package/Tests/Server/Services/TraceAnalyticsResourceDisplayNames.test.ts

@@ -34,10 +34,10 @@ import { afterEach, describe, expect, test } from "@jest/globals";
  *   TraceAggregationService.RESOURCE_FACET_KEYS.has(key)
  *     && ResourceFacetResolver.isResourceFacet(key)
  *
- * - `proxmoxClusterId` / `cephClusterId` are resource dimensions in the
- *   aggregation service but have NO branch in ResourceFacetResolver.resolveOne
- *   (it returns [] for them). They must not cost a resolve round-trip, and
- *   their ids stay raw.
+ * - `proxmoxClusterId` / `vmwareVCenterId` / `cephClusterId` are resource
+ *   dimensions in the aggregation service but have NO branch in
+ *   ResourceFacetResolver.resolveOne (it returns [] for them). They must not
+ *   cost a resolve round-trip, and their ids stay raw.
  * - `primaryEntityId` / `serviceId` are resolvable by the resolver but are
  *   deliberately not resource dimensions here — the traces explorer resolves
  *   that service split client-side, so the server leaves them alone.
@@ -52,6 +52,7 @@ const marketingAppId: string = ObjectID.generate().toString();
 const deletedAppId: string = ObjectID.generate().toString();
 const hostId: string = ObjectID.generate().toString();
 const proxmoxClusterId: string = ObjectID.generate().toString();
+const vmwareVCenterId: string = ObjectID.generate().toString();
 const cephClusterId: string = ObjectID.generate().toString();
 const serviceEntityId: string = ObjectID.generate().toString();
 /*
@@ -644,6 +645,42 @@ describe("TraceAggregationService.getAnalyticsTable (resource display names)", (
     expect(resolveSpy).not.toHaveBeenCalled();
   });
 
+  test("vmwareVCenterId is a resource dimension the resolver cannot resolve — no round-trip, id stays raw", async () => {
+    /*
+     * Same contract as the Proxmox / Ceph keys above (the group-by cap is two
+     * dimensions, hence the separate case): vmwareVCenterId is in
+     * RESOURCE_FACET_KEYS but has no ResourceFacetResolver branch.
+     */
+    stubQuery({
+      main: [
+        {
+          vmwareVCenterId: vmwareVCenterId,
+          cephClusterId: cephClusterId,
+          cnt: "4",
+        },
+      ],
+    });
+    const resolveSpy: jest.SpyInstance = stubResolver({
+      vmwareVCenterId: [
+        { value: vmwareVCenterId, count: 1, displayName: "NOPE" },
+      ],
+      cephClusterId: [{ value: cephClusterId, count: 1, displayName: "NOPE" }],
+    });
+
+    const rows: Array<TraceAnalyticsTableRow> =
+      await TraceAggregationService.getAnalyticsTable(
+        analyticsRequest({
+          chartType: "table",
+          groupBy: ["vmwareVCenterId", "cephClusterId"],
+        }),
+      );
+
+    expect(rows).toHaveLength(1);
+    expect(valuesFor(rows, "vmwareVCenterId")).toEqual([vmwareVCenterId]);
+    expect(valuesFor(rows, "cephClusterId")).toEqual([cephClusterId]);
+    expect(resolveSpy).not.toHaveBeenCalled();
+  });
+
   test("primaryEntityId / serviceId are resolvable but are NOT resource dimensions here — left alone", async () => {
     /*
      * The other half of the intersection: the resolver knows both keys, but

package/Tests/Server/Services/UserNotificationEmailRollupModels.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, test } from "@jest/globals";
 import { getMetadataArgsStorage } from "typeorm";
 import { IndexMetadataArgs } from "typeorm/metadata-args/IndexMetadataArgs";
 import { RelationMetadataArgs } from "typeorm/metadata-args/RelationMetadataArgs";
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
 import AllModelTypes from "../../../Models/DatabaseModels/Index";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import UserNotificationEmailRollupBatch from "../../../Models/DatabaseModels/UserNotificationEmailRollupBatch";
@@ -22,6 +23,8 @@ import {
 } from "../../../Server/Utils/EmailRollup/EmailRollupConstants";
 import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
 import Dictionary from "../../../Types/Dictionary";
+import ColumnLength from "../../../Types/Database/ColumnLength";
+import ColumnType from "../../../Types/Database/ColumnType";
 import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
 import GenericFunction from "../../../Types/GenericFunction";
 import ObjectID from "../../../Types/ObjectID";
@@ -454,6 +457,40 @@ describe("the indexes each table cannot work without", () => {
   });
 });
 
+describe("severity and state snapshots remain compatible with pending notifications", () => {
+  test.each(["severity", "currentState"])(
+    "%s is a nullable bounded text column with no default or relation",
+    (name: string) => {
+      const column: ColumnMetadataArgs | undefined =
+        getMetadataArgsStorage().columns.find(
+          (entry: ColumnMetadataArgs): boolean => {
+            return (
+              entry.target === UserNotificationEmailRollupItem &&
+              entry.propertyName === name
+            );
+          },
+        );
+
+      expect(column).toBeDefined();
+      expect(column?.options.type).toBe(ColumnType.ShortText);
+      expect(column?.options.length).toBe(ColumnLength.ShortText);
+      expect(column?.options.nullable).toBe(true);
+      expect(column?.options.default).toBeUndefined();
+      expect(
+        relationArgs(UserNotificationEmailRollupItem, name),
+      ).toBeUndefined();
+    },
+  );
+
+  test("new legacy-shaped queue items have no invented severity or state", () => {
+    const item: UserNotificationEmailRollupItem =
+      new UserNotificationEmailRollupItem();
+
+    expect(item.severity).toBeUndefined();
+    expect(item.currentState).toBeUndefined();
+  });
+});
+
 describe("retention is registered unconditionally, on both services", () => {
   test.each(ROLLUP_SERVICES)(
     "$name prunes on createdAt",