@oneuptime/common 14.0.7 → 14.0.8

package/Tests/Models/IncidentCustomFieldCreateSettingsColumns.test.ts

@@ -0,0 +1,252 @@
+import AlertCustomField from "../../Models/DatabaseModels/AlertCustomField";
+import BaseModel from "../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import IncidentCustomField from "../../Models/DatabaseModels/IncidentCustomField";
+import InventoryItemCustomField from "../../Models/DatabaseModels/InventoryItemCustomField";
+import MonitorCustomField from "../../Models/DatabaseModels/MonitorCustomField";
+import OnCallDutyPolicyCustomField from "../../Models/DatabaseModels/OnCallDutyPolicyCustomField";
+import ScheduledMaintenanceCustomField from "../../Models/DatabaseModels/ScheduledMaintenanceCustomField";
+import StatusPageCustomField from "../../Models/DatabaseModels/StatusPageCustomField";
+import TeamCustomField from "../../Models/DatabaseModels/TeamCustomField";
+import TeamMemberCustomField from "../../Models/DatabaseModels/TeamMemberCustomField";
+import DatabaseRequestType from "../../Server/Types/BaseDatabase/DatabaseRequestType";
+import ColumnPermissions from "../../Server/Types/Database/Permissions/ColumnPermission";
+import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import ObjectID from "../../Types/ObjectID";
+import Permission, { UserTenantAccessPermission } from "../../Types/Permission";
+import { describe, expect, test } from "@jest/globals";
+import { getMetadataArgsStorage } from "typeorm";
+import { IndexMetadataArgs } from "typeorm/metadata-args/IndexMetadataArgs";
+
+/*
+ * The incident custom field settings, in model metadata, where a later
+ * well-meaning edit could change them without breaking a functional test:
+ *
+ *   - isRequiredOnCreate, showOnCreate and includeInSubscriberNotifications
+ *     default to off, so existing fields keep behaving as they did - in
+ *     particular, no field starts going out to external subscribers;
+ *   - sortOrder is optional;
+ *   - variableKey is the service's: computed, written by nobody through the
+ *     API, readable by whoever reads the field, and unique per project;
+ *   - the columns exist on IncidentCustomField only. The shared settings page
+ *     and Custom Fields card offer them per model (hasColumn), and a select
+ *     of a column a model does not have would fail for that resource.
+ */
+
+const model: IncidentCustomField = new IncidentCustomField();
+const projectId: ObjectID = ObjectID.generate();
+
+const SETTINGS_COLUMNS: Array<string> = [
+  "isRequiredOnCreate",
+  "sortOrder",
+  "showOnCreate",
+  "includeInSubscriberNotifications",
+];
+
+function accessControl(column: string): ColumnAccessControl {
+  const control: ColumnAccessControl | null =
+    model.getColumnAccessControlFor(column);
+
+  expect(control).not.toBeNull();
+
+  return control as ColumnAccessControl;
+}
+
+function metadata(column: string): TableColumnMetadata {
+  return model.getTableColumnMetadata(column);
+}
+
+function props(permissions: Array<Permission>): DatabaseCommonInteractionProps {
+  const tenantPermission: UserTenantAccessPermission = {
+    projectId,
+    _type: "UserTenantAccessPermission",
+    permissions: permissions.map((permission: Permission) => {
+      return {
+        _type: "UserPermission",
+        permission: permission,
+        labelIds: [],
+        isBlockPermission: false,
+      };
+    }),
+  };
+
+  return {
+    userId: ObjectID.generate(),
+    tenantId: projectId,
+    userTenantAccessPermission: {
+      [projectId.toString()]: tenantPermission,
+    },
+  };
+}
+
+describe("IncidentCustomField create and notification settings", () => {
+  test.each(SETTINGS_COLUMNS)(
+    "%s has the access control of the field's other settings",
+    (column: string) => {
+      expect(accessControl(column)).toEqual(accessControl("dropdownOptions"));
+    },
+  );
+
+  test.each([
+    "isRequiredOnCreate",
+    "showOnCreate",
+    "includeInSubscriberNotifications",
+  ])("%s is a boolean that starts off", (column: string) => {
+    expect(metadata(column).type).toBe(TableColumnType.Boolean);
+    expect(metadata(column).defaultValue).toBe(false);
+    expect(metadata(column).isDefaultValueColumn).toBe(true);
+  });
+
+  test("sortOrder is an optional number", () => {
+    expect(metadata("sortOrder").type).toBe(TableColumnType.Number);
+    expect(metadata("sortOrder").required).toBeFalsy();
+  });
+
+  test("a project admin can create and edit the settings", () => {
+    const admin: DatabaseCommonInteractionProps = props([
+      Permission.ProjectAdmin,
+    ]);
+    const data: IncidentCustomField = new IncidentCustomField();
+    data.name = "Impact";
+    data.isRequiredOnCreate = true;
+    data.sortOrder = 2;
+    data.showOnCreate = true;
+    data.includeInSubscriberNotifications = true;
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        IncidentCustomField,
+        data,
+        admin,
+        DatabaseRequestType.Create,
+      );
+    }).not.toThrow();
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        IncidentCustomField,
+        data,
+        admin,
+        DatabaseRequestType.Update,
+      );
+    }).not.toThrow();
+  });
+
+  test("an incident member can read but not change them", () => {
+    const member: DatabaseCommonInteractionProps = props([
+      Permission.IncidentMember,
+    ]);
+    const data: IncidentCustomField = new IncidentCustomField();
+    data.includeInSubscriberNotifications = true;
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        IncidentCustomField,
+        data,
+        member,
+        DatabaseRequestType.Update,
+      );
+    }).toThrow();
+
+    for (const column of [...SETTINGS_COLUMNS, "variableKey"]) {
+      expect(accessControl(column).read).toContain(Permission.IncidentMember);
+    }
+  });
+});
+
+describe("IncidentCustomField.variableKey", () => {
+  test("is readable like the field's name, and written by nobody through the API", () => {
+    expect(accessControl("variableKey")).toEqual({
+      create: [],
+      read: accessControl("name").read,
+      update: [],
+    });
+  });
+
+  test("is computed, so a create carrying one passes the column check (the service replaces it)", () => {
+    expect(metadata("variableKey").computed).toBe(true);
+    expect(metadata("variableKey").type).toBe(TableColumnType.ShortText);
+
+    const data: IncidentCustomField = new IncidentCustomField();
+    data.name = "Impact";
+    data.variableKey = "impact";
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        IncidentCustomField,
+        data,
+        props([Permission.ProjectAdmin]),
+        DatabaseRequestType.Create,
+      );
+    }).not.toThrow();
+  });
+
+  test("is refused on update by the column check, behind the service dropping it", () => {
+    const data: IncidentCustomField = new IncidentCustomField();
+    data.variableKey = "hijacked";
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        IncidentCustomField,
+        data,
+        props([Permission.ProjectOwner]),
+        DatabaseRequestType.Update,
+      );
+    }).toThrow();
+  });
+
+  test("is unique per project", () => {
+    const indexes: Array<IndexMetadataArgs> = getMetadataArgsStorage()
+      .indices.filter((index: IndexMetadataArgs) => {
+        return index.target === IncidentCustomField;
+      })
+      .filter((index: IndexMetadataArgs) => {
+        return (
+          Array.isArray(index.columns) &&
+          (index.columns as Array<string>).includes("variableKey")
+        );
+      });
+
+    expect(indexes).toHaveLength(1);
+    expect(indexes[0]!.columns).toEqual(["projectId", "variableKey"]);
+    expect(indexes[0]!.unique).toBe(true);
+  });
+});
+
+describe("the other custom field definition tables", () => {
+  const others: Array<{ new (): BaseModel }> = [
+    AlertCustomField,
+    MonitorCustomField,
+    StatusPageCustomField,
+    InventoryItemCustomField,
+    ScheduledMaintenanceCustomField,
+    OnCallDutyPolicyCustomField,
+    TeamCustomField,
+    TeamMemberCustomField,
+  ];
+
+  test.each(
+    others.map(
+      (type: { new (): BaseModel }): [string, { new (): BaseModel }] => {
+        return [type.name, type];
+      },
+    ),
+  )(
+    "%s has none of the incident-only columns",
+    (_name: string, type: { new (): BaseModel }) => {
+      const other: BaseModel = new type();
+
+      for (const column of [...SETTINGS_COLUMNS, "variableKey"]) {
+        expect(other.hasColumn(column)).toBe(false);
+      }
+    },
+  );
+
+  test("IncidentCustomField has all of them", () => {
+    for (const column of [...SETTINGS_COLUMNS, "variableKey"]) {
+      expect(model.hasColumn(column)).toBe(true);
+    }
+  });
+});

package/Tests/Models/StatusPageSubscriberUnsubscribeColumns.test.ts

@@ -0,0 +1,218 @@
+import StatusPageSubscriber from "../../Models/DatabaseModels/StatusPageSubscriber";
+import DatabaseRequestType from "../../Server/Types/BaseDatabase/DatabaseRequestType";
+import ColumnPermissions from "../../Server/Types/Database/Permissions/ColumnPermission";
+import { ColumnAccessControl } from "../../Types/BaseDatabase/AccessControl";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import Email from "../../Types/Email";
+import ObjectID from "../../Types/ObjectID";
+import Permission, { UserTenantAccessPermission } from "../../Types/Permission";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The two columns behind unsubscribing without signing in, in model
+ * metadata, where a later well-meaning edit could change them without
+ * breaking any functional test:
+ *
+ *   - unsubscribeToken is a credential. Holding it unsubscribes the
+ *     subscription, so nobody reads it through the API (the dashboard, the
+ *     public status page API, exports), nobody writes it, and it stays out
+ *     of the API documentation. It is `computed` so the create column check
+ *     - which runs after the service mints it - lets a teammate's create
+ *     through.
+ *   - unsubscribedAt is readable by exactly the roles that read the rest of
+ *     a subscriber, and written only by the service.
+ */
+
+const model: StatusPageSubscriber = new StatusPageSubscriber();
+
+const projectId: ObjectID = ObjectID.generate();
+
+function props(permissions: Array<Permission>): DatabaseCommonInteractionProps {
+  const tenantPermission: UserTenantAccessPermission = {
+    projectId,
+    _type: "UserTenantAccessPermission",
+    permissions: permissions.map((permission: Permission) => {
+      return {
+        _type: "UserPermission",
+        permission: permission,
+        labelIds: [],
+        isBlockPermission: false,
+      };
+    }),
+  };
+
+  return {
+    userId: ObjectID.generate(),
+    tenantId: projectId,
+    userTenantAccessPermission: {
+      [projectId.toString()]: tenantPermission,
+    },
+  };
+}
+
+function accessControl(column: string): ColumnAccessControl {
+  const control: ColumnAccessControl | null =
+    model.getColumnAccessControlFor(column);
+
+  expect(control).not.toBeNull();
+
+  return control as ColumnAccessControl;
+}
+
+function metadata(column: string): TableColumnMetadata {
+  return model.getTableColumnMetadata(column);
+}
+
+describe("StatusPageSubscriber.unsubscribeToken", () => {
+  test("nobody can read, create or update it through the API", () => {
+    expect(accessControl("unsubscribeToken")).toEqual({
+      create: [],
+      read: [],
+      update: [],
+    });
+  });
+
+  test("is computed, short text and hidden from the API documentation", () => {
+    expect(metadata("unsubscribeToken").computed).toBe(true);
+    expect(metadata("unsubscribeToken").hideColumnInDocumentation).toBe(true);
+    expect(metadata("unsubscribeToken").type).toBe(TableColumnType.ShortText);
+  });
+
+  test("a teammate's create carrying the minted token passes the column check", () => {
+    const created: StatusPageSubscriber = new StatusPageSubscriber();
+    created.projectId = projectId;
+    created.statusPageId = ObjectID.generate();
+    created.subscriberEmail = new Email("site03-all@acme.com");
+    created.isSubscriptionConfirmed = true;
+    created.unsubscribeToken = "ab".repeat(32);
+
+    for (const permission of [
+      Permission.ProjectAdmin,
+      Permission.StatusPageAdmin,
+      Permission.CreateStatusPageSubscriber,
+    ]) {
+      expect(() => {
+        ColumnPermissions.checkDataColumnPermissions(
+          StatusPageSubscriber,
+          created,
+          props([permission]),
+          DatabaseRequestType.Create,
+        );
+      }).not.toThrow();
+    }
+  });
+
+  test("nobody may rewrite it on an update", () => {
+    const update: StatusPageSubscriber = new StatusPageSubscriber();
+    update.unsubscribeToken = "ab".repeat(32);
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        StatusPageSubscriber,
+        update,
+        props([Permission.ProjectOwner, Permission.ProjectAdmin]),
+        DatabaseRequestType.Update,
+      );
+    }).toThrow(/unsubscribeToken/);
+  });
+});
+
+describe("StatusPageSubscriber.unsubscribedAt", () => {
+  test("is read by exactly the roles that read whether a subscriber is unsubscribed", () => {
+    expect([...accessControl("unsubscribedAt").read].sort()).toEqual(
+      [...accessControl("isUnsubscribed").read].sort(),
+    );
+    expect(accessControl("unsubscribedAt").read).toContain(
+      Permission.StatusPageViewer,
+    );
+  });
+
+  test("nobody writes it through the API; the service does", () => {
+    expect(accessControl("unsubscribedAt").create).toEqual([]);
+    expect(accessControl("unsubscribedAt").update).toEqual([]);
+    expect(metadata("unsubscribedAt").computed).toBe(true);
+    expect(metadata("unsubscribedAt").type).toBe(TableColumnType.Date);
+  });
+
+  test("a teammate cannot backdate it on an update", () => {
+    const update: StatusPageSubscriber = new StatusPageSubscriber();
+    update.unsubscribedAt = new Date("2001-01-01T00:00:00.000Z");
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        StatusPageSubscriber,
+        update,
+        props([Permission.ProjectOwner]),
+        DatabaseRequestType.Update,
+      );
+    }).toThrow(/unsubscribedAt/);
+  });
+
+  test("toggling Is Unsubscribed on the dashboard is still allowed", () => {
+    const update: StatusPageSubscriber = new StatusPageSubscriber();
+    update.isUnsubscribed = true;
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        StatusPageSubscriber,
+        update,
+        props([Permission.StatusPageMember]),
+        DatabaseRequestType.Update,
+      );
+    }).not.toThrow();
+  });
+});
+
+/*
+ * isAddedByTeam decides whether the page's owners hear about an unsubscribe,
+ * so no client may set it: a teammate or an API key that could send `false`
+ * would make a shared address it added leave silently.
+ */
+describe("StatusPageSubscriber.isAddedByTeam", () => {
+  test("is read by exactly the roles that read the rest of a subscriber, so the lists can filter on it", () => {
+    expect([...accessControl("isAddedByTeam").read].sort()).toEqual(
+      [...accessControl("isUnsubscribed").read].sort(),
+    );
+  });
+
+  test("nobody writes it through the API; the service sets it on every create", () => {
+    expect(accessControl("isAddedByTeam").create).toEqual([]);
+    expect(accessControl("isAddedByTeam").update).toEqual([]);
+    expect(metadata("isAddedByTeam").computed).toBe(true);
+    expect(metadata("isAddedByTeam").type).toBe(TableColumnType.Boolean);
+    expect(metadata("isAddedByTeam").defaultValue).toBe(false);
+  });
+
+  test("a teammate's create carrying the stamp passes the column check", () => {
+    const created: StatusPageSubscriber = new StatusPageSubscriber();
+    created.projectId = projectId;
+    created.statusPageId = ObjectID.generate();
+    created.subscriberEmail = new Email("site03-all@acme.com");
+    created.isAddedByTeam = true;
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        StatusPageSubscriber,
+        created,
+        props([Permission.CreateStatusPageSubscriber]),
+        DatabaseRequestType.Create,
+      );
+    }).not.toThrow();
+  });
+
+  test("nobody may turn it off (or on) on an update", () => {
+    const update: StatusPageSubscriber = new StatusPageSubscriber();
+    update.isAddedByTeam = false;
+
+    expect(() => {
+      ColumnPermissions.checkDataColumnPermissions(
+        StatusPageSubscriber,
+        update,
+        props([Permission.ProjectOwner]),
+        DatabaseRequestType.Update,
+      );
+    }).toThrow(/isAddedByTeam/);
+  });
+});

package/Tests/Server/API/ExpiredSessionRouteGuards.test.ts

@@ -315,6 +315,13 @@ const GUARDED_ROUTES: Array<GuardedRoute> = [
     uri: "/scheduled-maintenance/generate-note-from-ai/:scheduledMaintenanceId",
     registeredBy: "ScheduledMaintenanceAPI",
   },
+
+  // "Will notify": the audience summary on declaring an incident and on notes.
+  {
+    method: "POST",
+    uri: "/incident/subscriber-audience",
+    registeredBy: "IncidentAPI",
+  },
 ];
 
 type RecordedRoute = ReturnType<typeof mockRouter.match>;