@oneuptime/common 13.0.1 → 13.0.3

package/Tests/Models/DatabaseModels/IncomingCallPolicyPhoneNumber.test.ts

@@ -0,0 +1,362 @@
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import IncomingCallPolicy from "../../../Models/DatabaseModels/IncomingCallPolicy";
+import IncomingCallPolicyPhoneNumber from "../../../Models/DatabaseModels/IncomingCallPolicyPhoneNumber";
+import Project from "../../../Models/DatabaseModels/Project";
+import ProjectCallSMSConfig from "../../../Models/DatabaseModels/ProjectCallSMSConfig";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import { getMetadataArgsStorage } from "typeorm";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+import type { IndexMetadataArgs } from "typeorm/metadata-args/IndexMetadataArgs";
+import type { RelationMetadataArgs } from "typeorm/metadata-args/RelationMetadataArgs";
+
+type ModelType = { new (): BaseModel };
+
+const model: IncomingCallPolicyPhoneNumber =
+  new IncomingCallPolicyPhoneNumber();
+const policy: IncomingCallPolicy = new IncomingCallPolicy();
+
+const MODELS_DIR: string = path.resolve(
+  __dirname,
+  "../../../Models/DatabaseModels",
+);
+const MODEL_INDEX_SOURCE: string = fs.readFileSync(
+  path.join(MODELS_DIR, "Index.ts"),
+  "utf8",
+);
+const SERVICE_INDEX_SOURCE: string = fs.readFileSync(
+  path.resolve(__dirname, "../../../Server/Services/Index.ts"),
+  "utf8",
+);
+const BASE_API_SOURCE: string = fs.readFileSync(
+  path.resolve(__dirname, "../../../../App/FeatureSet/BaseAPI/Index.ts"),
+  "utf8",
+);
+
+const OWN_COLUMNS: Array<string> = [
+  "project",
+  "projectId",
+  "incomingCallPolicy",
+  "incomingCallPolicyId",
+  "projectCallSMSConfig",
+  "projectCallSMSConfigId",
+  "phoneNumber",
+  "callProviderPhoneNumberId",
+  "countryCode",
+  "areaCode",
+  "phoneNumberPurchasedAt",
+];
+
+const REQUIRED_COLUMNS: Array<string> = [
+  "projectId",
+  "incomingCallPolicyId",
+  "projectCallSMSConfigId",
+  "phoneNumber",
+  "callProviderPhoneNumberId",
+];
+
+function columns(): Array<ColumnMetadataArgs> {
+  return getMetadataArgsStorage().columns.filter(
+    (entry: ColumnMetadataArgs): boolean => {
+      return entry.target === IncomingCallPolicyPhoneNumber;
+    },
+  );
+}
+
+function column(propertyName: string): ColumnMetadataArgs {
+  const found: ColumnMetadataArgs | undefined = columns().find(
+    (entry: ColumnMetadataArgs): boolean => {
+      return entry.propertyName === propertyName;
+    },
+  );
+
+  if (!found) {
+    throw new Error(
+      `IncomingCallPolicyPhoneNumber.${propertyName} has no @Column`,
+    );
+  }
+
+  return found;
+}
+
+function indices(): Array<IndexMetadataArgs> {
+  return getMetadataArgsStorage().indices.filter(
+    (entry: IndexMetadataArgs): boolean => {
+      return entry.target === IncomingCallPolicyPhoneNumber;
+    },
+  );
+}
+
+function relation(propertyName: string): RelationMetadataArgs {
+  const found: RelationMetadataArgs | undefined =
+    getMetadataArgsStorage().relations.find(
+      (entry: RelationMetadataArgs): boolean => {
+        return (
+          entry.target === IncomingCallPolicyPhoneNumber &&
+          entry.propertyName === propertyName
+        );
+      },
+    );
+
+  if (!found) {
+    throw new Error(
+      `IncomingCallPolicyPhoneNumber.${propertyName} has no relation`,
+    );
+  }
+
+  return found;
+}
+
+function indexWithName(name: string): IndexMetadataArgs | undefined {
+  return indices().find((entry: IndexMetadataArgs): boolean => {
+    return entry.name === name;
+  });
+}
+
+describe("IncomingCallPolicyPhoneNumber model registration", () => {
+  test("is documented, project-scoped, and has its own CRUD route", () => {
+    expect(model.tableName).toBe("IncomingCallPolicyPhoneNumber");
+    expect(model.getCrudApiPath()?.toString()).toBe(
+      "/incoming-call-policy-phone-number",
+    );
+    expect(model.getTenantColumn()).toBe("projectId");
+    expect(model.enableDocumentation).toBe(true);
+  });
+
+  test("is imported and exported exactly once by the database model registry", () => {
+    expect(MODEL_INDEX_SOURCE).toContain(
+      'import IncomingCallPolicyPhoneNumber from "./IncomingCallPolicyPhoneNumber";',
+    );
+    expect(
+      MODEL_INDEX_SOURCE.match(/^\s*IncomingCallPolicyPhoneNumber,\s*$/gm),
+    ).toHaveLength(1);
+  });
+
+  test("registers its service exactly once in the common service registry", () => {
+    expect(SERVICE_INDEX_SOURCE).toContain(
+      'import IncomingCallPolicyPhoneNumberService from "./IncomingCallPolicyPhoneNumberService";',
+    );
+    expect(
+      SERVICE_INDEX_SOURCE.match(
+        /^\s*IncomingCallPolicyPhoneNumberService,\s*$/gm,
+      ),
+    ).toHaveLength(1);
+  });
+
+  test("mounts the model with its matching service in BaseAPI", () => {
+    expect(BASE_API_SOURCE).toContain(
+      'import IncomingCallPolicyPhoneNumber from "Common/Models/DatabaseModels/IncomingCallPolicyPhoneNumber";',
+    );
+    expect(BASE_API_SOURCE).toContain(
+      "import IncomingCallPolicyPhoneNumberService, {",
+    );
+
+    const registrationStart: number = BASE_API_SOURCE.indexOf(
+      "// IncomingCallPolicyPhoneNumber (read-only through model permissions)",
+    );
+    const registrationEnd: number = BASE_API_SOURCE.indexOf(
+      "// IncomingCallLog",
+      registrationStart,
+    );
+    const registration: string = BASE_API_SOURCE.slice(
+      registrationStart,
+      registrationEnd,
+    );
+    expect(registrationStart).toBeGreaterThan(-1);
+    expect(registration).toContain("new BaseAPI<");
+    expect(registration).toContain("IncomingCallPolicyPhoneNumber,");
+    expect(registration).toContain("IncomingCallPolicyPhoneNumberService,");
+  });
+
+  test("has a CRUD route literal no other database model claims", () => {
+    const owners: Array<string> = fs
+      .readdirSync(MODELS_DIR)
+      .filter((name: string): boolean => {
+        return name.endsWith(".ts") && name !== "Index.ts";
+      })
+      .filter((name: string): boolean => {
+        return fs
+          .readFileSync(path.join(MODELS_DIR, name), "utf8")
+          .includes('new Route("/incoming-call-policy-phone-number")');
+      });
+
+    expect(owners).toEqual(["IncomingCallPolicyPhoneNumber.ts"]);
+  });
+
+  test("declares exactly the provider-number fields in addition to BaseModel", () => {
+    const baseColumns: Array<string> = new BaseModel().getTableColumns()
+      .columns;
+    const declared: Array<string> = model
+      .getTableColumns()
+      .columns.filter((name: string): boolean => {
+        return !baseColumns.includes(name);
+      });
+
+    expect(declared.sort()).toEqual([...OWN_COLUMNS].sort());
+  });
+
+  test("inherits the policy read audience but is root-written and root-deleted", () => {
+    expect(model.readRecordPermissions).toEqual(policy.readRecordPermissions);
+    expect(model.readRecordPermissions.length).toBeGreaterThan(0);
+    expect(model.createRecordPermissions).toEqual([]);
+    expect(model.updateRecordPermissions).toEqual([]);
+    expect(model.deleteRecordPermissions).toEqual([]);
+  });
+
+  test("lets policy readers read every declared field but lets clients write none", () => {
+    for (const name of OWN_COLUMNS) {
+      const access: ColumnAccessControl | null =
+        model.getColumnAccessControlFor(name);
+
+      expect({ name, create: access?.create || [] }).toEqual({
+        name,
+        create: [],
+      });
+      expect({ name, update: access?.update || [] }).toEqual({
+        name,
+        update: [],
+      });
+      expect({ name, read: access?.read || [] }).toEqual({
+        name,
+        read: policy.readRecordPermissions,
+      });
+    }
+  });
+
+  test("follows label/read scoping through its incoming-call policy", () => {
+    expect(model.canAccessIfCanReadOn).toBe("incomingCallPolicy");
+    expect(
+      model.getTableColumnMetadata("incomingCallPolicy")
+        .manyToOneRelationColumn,
+    ).toBe("incomingCallPolicyId");
+    expect(model.getTableColumnMetadata("incomingCallPolicy").modelType).toBe(
+      IncomingCallPolicy,
+    );
+  });
+});
+
+describe("IncomingCallPolicyPhoneNumber persistence contract", () => {
+  test("requires every identity needed to route and later release a number", () => {
+    for (const name of REQUIRED_COLUMNS) {
+      expect({
+        name,
+        tableRequired: model.getTableColumnMetadata(name).required,
+        databaseNullable: column(name).options.nullable,
+      }).toEqual({
+        name,
+        tableRequired: true,
+        databaseNullable: false,
+      });
+    }
+  });
+
+  test("keeps descriptive provider metadata optional", () => {
+    for (const name of ["countryCode", "areaCode", "phoneNumberPurchasedAt"]) {
+      expect({
+        name,
+        tableRequired: model.getTableColumnMetadata(name).required,
+        databaseNullable: column(name).options.nullable,
+      }).toEqual({
+        name,
+        tableRequired: false,
+        databaseNullable: true,
+      });
+    }
+  });
+
+  test("cascades with project, policy, and the provider configuration", () => {
+    const expected: Array<{
+      propertyName: string;
+      modelType: ModelType;
+    }> = [
+      { propertyName: "project", modelType: Project },
+      { propertyName: "incomingCallPolicy", modelType: IncomingCallPolicy },
+      {
+        propertyName: "projectCallSMSConfig",
+        modelType: ProjectCallSMSConfig,
+      },
+    ];
+
+    for (const item of expected) {
+      expect({
+        propertyName: item.propertyName,
+        onDelete: relation(item.propertyName).options.onDelete,
+        nullable: relation(item.propertyName).options.nullable,
+        modelType: model.getTableColumnMetadata(item.propertyName).modelType,
+      }).toEqual({
+        propertyName: item.propertyName,
+        onDelete: "CASCADE",
+        nullable: false,
+        modelType: item.modelType,
+      });
+    }
+  });
+
+  test("makes an active phone number globally unique for unambiguous webhook routing", () => {
+    const uniquePhone: IndexMetadataArgs | undefined = indexWithName(
+      "IDX_INCOMING_CALL_POLICY_PHONE_NUMBER_UNIQUE",
+    );
+
+    expect(uniquePhone).toBeDefined();
+    expect(uniquePhone?.unique).toBe(true);
+    expect(uniquePhone?.columns).toEqual(["phoneNumber"]);
+    expect(uniquePhone?.where).toBe('"deletedAt" IS NULL');
+  });
+
+  test("makes a provider SID unique inside the configuration that owns it", () => {
+    const uniqueProviderId: IndexMetadataArgs | undefined = indexWithName(
+      "IDX_INCOMING_CALL_POLICY_PROVIDER_PHONE_NUMBER_UNIQUE",
+    );
+
+    expect(uniqueProviderId).toBeDefined();
+    expect(uniqueProviderId?.unique).toBe(true);
+    expect(uniqueProviderId?.columns).toEqual([
+      "projectCallSMSConfigId",
+      "callProviderPhoneNumberId",
+    ]);
+    expect(uniqueProviderId?.where).toBe('"deletedAt" IS NULL');
+  });
+
+  test("indexes policy/project lookup without making policy unique", () => {
+    const policyProjectIndex: IndexMetadataArgs | undefined = indices().find(
+      (entry: IndexMetadataArgs): boolean => {
+        return (
+          Array.isArray(entry.columns) &&
+          entry.columns.length === 2 &&
+          entry.columns.includes("incomingCallPolicyId") &&
+          entry.columns.includes("projectId")
+        );
+      },
+    );
+
+    expect(policyProjectIndex).toBeDefined();
+    expect(policyProjectIndex?.unique).not.toBe(true);
+
+    const policyUniqueIndexes: Array<IndexMetadataArgs> = indices().filter(
+      (entry: IndexMetadataArgs): boolean => {
+        return (
+          entry.unique === true &&
+          Array.isArray(entry.columns) &&
+          entry.columns.includes("incomingCallPolicyId")
+        );
+      },
+    );
+
+    expect(policyUniqueIndexes).toEqual([]);
+  });
+
+  test("uses entity relations for policy, project, and provider configuration", () => {
+    expect(model.getTableColumnMetadata("project").type).toBe(
+      TableColumnType.Entity,
+    );
+    expect(model.getTableColumnMetadata("incomingCallPolicy").type).toBe(
+      TableColumnType.Entity,
+    );
+    expect(model.getTableColumnMetadata("projectCallSMSConfig").type).toBe(
+      TableColumnType.Entity,
+    );
+  });
+});

package/Tests/Models/DatabaseModels/RuleBaseModel.test.ts

@@ -0,0 +1,69 @@
+import NetworkDeviceAutoImportRule from "../../../Models/DatabaseModels/NetworkDeviceAutoImportRule";
+import StatusPageMonitorRule from "../../../Models/DatabaseModels/StatusPageMonitorRule";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import Dictionary from "../../../Types/Dictionary";
+import { describe, expect, it } from "@jest/globals";
+
+describe("RuleBaseModel criteria column", () => {
+  it("publishes nullable JSON match criteria metadata", () => {
+    const rule: StatusPageMonitorRule = new StatusPageMonitorRule();
+    const metadata: TableColumnMetadata =
+      rule.getTableColumnMetadata("criteria");
+
+    expect(metadata.type).toBe(TableColumnType.JSON);
+    expect(metadata.required).toBe(false);
+    expect(metadata.title).toBe("Match Criteria");
+    expect(rule.criteria).toBeUndefined();
+  });
+
+  it("inherits each concrete rule table's own permissions", () => {
+    const statusPageRule: StatusPageMonitorRule = new StatusPageMonitorRule();
+    const autoImportRule: NetworkDeviceAutoImportRule =
+      new NetworkDeviceAutoImportRule();
+
+    expect(statusPageRule.createRecordPermissions).not.toEqual(
+      autoImportRule.createRecordPermissions,
+    );
+    expect(statusPageRule.readRecordPermissions).not.toEqual(
+      autoImportRule.readRecordPermissions,
+    );
+    expect(statusPageRule.updateRecordPermissions).not.toEqual(
+      autoImportRule.updateRecordPermissions,
+    );
+
+    expect(statusPageRule.getColumnAccessControlFor("criteria")).toEqual({
+      create: statusPageRule.createRecordPermissions,
+      read: statusPageRule.readRecordPermissions,
+      update: statusPageRule.updateRecordPermissions,
+    });
+    expect(autoImportRule.getColumnAccessControlFor("criteria")).toEqual({
+      create: autoImportRule.createRecordPermissions,
+      read: autoImportRule.readRecordPermissions,
+      update: autoImportRule.updateRecordPermissions,
+    });
+  });
+
+  it("returns a fresh access-control dictionary on every read", () => {
+    const rule: StatusPageMonitorRule = new StatusPageMonitorRule();
+    const first: Dictionary<ColumnAccessControl> =
+      rule.getColumnAccessControlForAllColumns();
+    const second: Dictionary<ColumnAccessControl> =
+      rule.getColumnAccessControlForAllColumns();
+
+    expect(first).not.toBe(second);
+    expect(first["criteria"]).not.toBeUndefined();
+
+    first["criteria"] = { create: [], read: [], update: [] };
+
+    expect(second["criteria"]).toEqual({
+      create: rule.createRecordPermissions,
+      read: rule.readRecordPermissions,
+      update: rule.updateRecordPermissions,
+    });
+    expect(rule.getColumnAccessControlFor("criteria")).toEqual(
+      second["criteria"],
+    );
+  });
+});

package/Tests/Models/DatabaseModels/StaticRuleCriteriaInheritance.test.ts

@@ -0,0 +1,181 @@
+import AllModelTypes from "../../../Models/DatabaseModels/Index";
+import MetricPipelineRule from "../../../Models/DatabaseModels/MetricPipelineRule";
+import DatabaseBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import RuleBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/RuleBaseModel";
+import RelationOnlyRuleBaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/RelationOnlyRuleBaseModel";
+import TableColumnType from "../../../Types/Database/TableColumnType";
+import { describe, expect, it } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import type { CheckMetadataArgs } from "typeorm/metadata-args/CheckMetadataArgs";
+import type { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+
+type ModelType = new () => DatabaseBaseModel;
+
+const STATIC_MATCH_CRITERIA_RULE_MODEL_NAMES: Array<string> = [
+  "AlertEpisodeLabelRule",
+  "AlertEpisodeOwnerRule",
+  "AlertLabelRule",
+  "AlertOwnerRule",
+  "CephClusterLabelRule",
+  "CephClusterOwnerRule",
+  "CloudResourceLabelRule",
+  "CloudResourceOwnerRule",
+  "DashboardLabelRule",
+  "DashboardOwnerRule",
+  "DockerHostLabelRule",
+  "DockerHostOwnerRule",
+  "DockerSwarmClusterLabelRule",
+  "DockerSwarmClusterOwnerRule",
+  "HostLabelRule",
+  "HostOwnerRule",
+  "IncidentEpisodeLabelRule",
+  "IncidentEpisodeOwnerRule",
+  "IncidentLabelRule",
+  "IncidentOwnerRule",
+  "IncomingCallPolicyLabelRule",
+  "IncomingCallPolicyOwnerRule",
+  "IoTFleetLabelRule",
+  "IoTFleetOwnerRule",
+  "KubernetesClusterLabelRule",
+  "KubernetesClusterOwnerRule",
+  "MonitorLabelRule",
+  "MonitorOwnerRule",
+  "NetworkDeviceLabelRule",
+  "NetworkDeviceOwnerRule",
+  "OnCallDutyPolicyLabelRule",
+  "OnCallDutyPolicyOwnerRule",
+  "OnCallDutyPolicyScheduleLabelRule",
+  "OnCallDutyPolicyScheduleOwnerRule",
+  "PodmanHostLabelRule",
+  "PodmanHostOwnerRule",
+  "ProxmoxClusterLabelRule",
+  "ProxmoxClusterOwnerRule",
+  "RumApplicationLabelRule",
+  "RumApplicationOwnerRule",
+  "RunbookLabelRule",
+  "RunbookOwnerRule",
+  "ScheduledMaintenanceLabelRule",
+  "ScheduledMaintenanceOwnerRule",
+  "ServerlessFunctionLabelRule",
+  "ServerlessFunctionOwnerRule",
+  "ServiceLabelRule",
+  "ServiceOwnerRule",
+  "StatusPageLabelRule",
+  "StatusPageOwnerRule",
+  "VMwareVCenterLabelRule",
+  "VMwareVCenterOwnerRule",
+  "WorkflowLabelRule",
+  "WorkflowOwnerRule",
+  "AlertEpisodeOnCallRule",
+  "AlertEpisodePrivacyRule",
+  "AlertOnCallRule",
+  "AlertPrivacyRule",
+  "IncidentEpisodeOnCallRule",
+  "IncidentEpisodePrivacyRule",
+  "IncidentOnCallRule",
+  "IncidentPrivacyRule",
+  "AlertGroupingRule",
+  "IncidentGroupingRule",
+  "AlertReminderRule",
+  "IncidentReminderRule",
+  "ScheduledMaintenanceReminderRule",
+  "IncidentSlaRule",
+  "AutoRemediationRule",
+  "RunbookRule",
+  "StatusPageMonitorRule",
+  "NetworkDeviceAutoImportRule",
+  "NetworkSiteAssignmentRule",
+];
+
+const RELATION_ONLY_RULE_MODEL_NAMES: Array<string> = [
+  "AlertReminderRule",
+  "IncidentReminderRule",
+  "ScheduledMaintenanceReminderRule",
+];
+
+function getRegisteredModelType(modelName: string): ModelType {
+  const modelType: ModelType | undefined = (
+    AllModelTypes as Array<ModelType>
+  ).find((candidate: ModelType): boolean => {
+    return candidate.name === modelName;
+  });
+
+  expect(modelType).toBeDefined();
+
+  return modelType!;
+}
+
+describe("static match-criteria rule model inheritance", () => {
+  it("keeps the explicit model inventory complete and duplicate-free", () => {
+    expect(STATIC_MATCH_CRITERIA_RULE_MODEL_NAMES).toHaveLength(73);
+    expect(new Set(STATIC_MATCH_CRITERIA_RULE_MODEL_NAMES).size).toBe(73);
+  });
+
+  it.each(STATIC_MATCH_CRITERIA_RULE_MODEL_NAMES)(
+    "%s inherits the shared criteria JSON column and its API access control",
+    (modelName: string) => {
+      const Model: ModelType = getRegisteredModelType(modelName);
+      const model: DatabaseBaseModel = new Model();
+
+      expect(model).toBeInstanceOf(RuleBaseModel);
+      expect(model.getTableColumns().columns).toContain("criteria");
+      expect(model.getTableColumnMetadata("criteria").type).toBe(
+        TableColumnType.JSON,
+      );
+      expect(model.getColumnAccessControlFor("criteria")).toEqual({
+        create: model.getCreatePermissions(),
+        read: model.getReadPermissions(),
+        update: model.getUpdatePermissions(),
+      });
+    },
+  );
+
+  it.each(RELATION_ONLY_RULE_MODEL_NAMES)(
+    "%s uses the nullable fail-closed enabled-state encoding",
+    (modelName: string) => {
+      const Model: ModelType = getRegisteredModelType(modelName);
+      const model: DatabaseBaseModel = new Model();
+      const enabledColumn: ColumnMetadataArgs | undefined =
+        getMetadataArgsStorage().columns.find(
+          (column: ColumnMetadataArgs): boolean => {
+            return (
+              column.target === Model && column.propertyName === "isEnabled"
+            );
+          },
+        );
+      const compatibilityCheck: CheckMetadataArgs | undefined =
+        getMetadataArgsStorage().checks.find(
+          (check: CheckMetadataArgs): boolean => {
+            return (
+              check.target === Model &&
+              String(check.expression).includes(
+                '"criteria" IS NULL OR "isEnabled" IS DISTINCT FROM true',
+              )
+            );
+          },
+        );
+
+      expect(model).toBeInstanceOf(RelationOnlyRuleBaseModel);
+      expect(enabledColumn?.options.nullable).toBe(true);
+      expect(compatibilityCheck).toBeDefined();
+    },
+  );
+
+  it("leaves MetricPipelineRule on DatabaseBaseModel with its existing filter schema", () => {
+    const model: MetricPipelineRule = new MetricPipelineRule();
+
+    expect(Object.getPrototypeOf(MetricPipelineRule.prototype)).toBe(
+      DatabaseBaseModel.prototype,
+    );
+    expect(model).not.toBeInstanceOf(RuleBaseModel);
+    expect(model.getTableColumns().columns).not.toContain("criteria");
+    expect(model.getTableColumns().columns).toContain("filterCondition");
+    expect(model.getTableColumns().columns).toContain("filters");
+    expect(model.getTableColumnMetadata("filterCondition").type).toBe(
+      TableColumnType.ShortText,
+    );
+    expect(model.getTableColumnMetadata("filters").type).toBe(
+      TableColumnType.JSON,
+    );
+  });
+});