@oneuptime/common 14.0.12 → 14.0.13

package/Tests/Models/DatabaseModels/{IncidentFormModel.test.ts → FormModel.test.ts}

@@ -1,36 +1,38 @@
 import Models from "../../../Models/DatabaseModels/Index";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import Dashboard from "../../../Models/DatabaseModels/Dashboard";
+import Form from "../../../Models/DatabaseModels/Form";
+import FormSubmission from "../../../Models/DatabaseModels/FormSubmission";
 import Incident from "../../../Models/DatabaseModels/Incident";
-import IncidentForm from "../../../Models/DatabaseModels/IncidentForm";
-import IncidentFormSubmission from "../../../Models/DatabaseModels/IncidentFormSubmission";
-import IncidentSeverity from "../../../Models/DatabaseModels/IncidentSeverity";
-import IncidentTemplate from "../../../Models/DatabaseModels/IncidentTemplate";
 import Project from "../../../Models/DatabaseModels/Project";
+import ScheduledMaintenance from "../../../Models/DatabaseModels/ScheduledMaintenance";
 import User from "../../../Models/DatabaseModels/User";
 import DatabaseRequestType from "../../../Server/Types/BaseDatabase/DatabaseRequestType";
 import ModelPermission from "../../../Server/Types/Database/Permissions/Index";
 import ColumnPermissions from "../../../Server/Types/Database/Permissions/ColumnPermission";
 import TablePermission from "../../../Server/Types/Database/Permissions/TablePermission";
 import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import ColumnBillingAccessControl from "../../../Types/BaseDatabase/ColumnBillingAccessControl";
 import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import { PlanType } from "../../../Types/Billing/SubscriptionPlan";
-import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
-import ColumnBillingAccessControl from "../../../Types/BaseDatabase/ColumnBillingAccessControl";
+import ColumnLength from "../../../Types/Database/ColumnLength";
 import ColumnType from "../../../Types/Database/ColumnType";
-import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
 import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
 import TableColumnType from "../../../Types/Database/TableColumnType";
 import { getUniqueColumnBy } from "../../../Types/Database/UniqueColumnBy";
-import IconProp from "../../../Types/Icon/IconProp";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
 import {
-  DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING,
-  INCIDENT_FORM_REPORTER_EMAIL_MAX_LENGTH,
-  INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH,
-  IncidentFormFieldSetting,
-  PublicIncidentForm,
-  getPublicIncidentForm,
-} from "../../../Types/Incident/IncidentFormPublic";
+  FormFieldSource,
+  getDefaultFormFields,
+  readFormFields,
+  validateFormFields,
+} from "../../../Types/Form/FormField";
+import { validateFormTargetSettings } from "../../../Types/Form/FormTargetSettings";
+import FormTargetType, {
+  DEFAULT_FORM_TARGET_TYPE,
+} from "../../../Types/Form/FormTargetType";
+import IconProp from "../../../Types/Icon/IconProp";
+import { JSONArray, JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import Permission, {
   PermissionGroup,
@@ -39,7 +41,6 @@ import Permission, {
   UserTenantAccessPermission,
 } from "../../../Types/Permission";
 import UserType from "../../../Types/UserType";
-import { JSONObject } from "../../../Types/JSON";
 import {
   ModelSchema,
   ModelSchemaType,
@@ -55,17 +56,20 @@ import type { IndexMetadataArgs } from "typeorm/metadata-args/IndexMetadataArgs"
 import type { RelationMetadataArgs } from "typeorm/metadata-args/RelationMetadataArgs";
 
 /*
- * Incident forms and their submissions, at the schema and permission level.
+ * Forms and their submissions, at the schema and permission level.
+ *
+ * A form lets people with no OneUptime account create incidents - and page
+ * on-call - or schedule maintenance in a project. So building, changing and
+ * deleting one is for project owners and admins, and for whoever is given
+ * the Form permissions on purpose; everyone who reads incidents or
+ * scheduled maintenance may read forms and their links. The link key is
+ * minted by the service and only form editors may replace it.
  *
- * A form lets people with no OneUptime account page on-call, so who may
- * build one is the incident settings tier (owners, admins, incident admins),
- * not the tier that edits templates; everyone who reads incidents may read
- * forms and their links. The link key is minted by the service and only
- * form editors may replace it. Submissions are written by the submit route
- * alone: the API can read them and incident admins can delete them, nothing
- * else. The service tests pass just as happily against a model the wrong
- * role can write, so those rules are pinned here - along with every column
- * the migration creates.
+ * A submission holds what a stranger wrote and how to reach them, so it is
+ * read only by owners, admins and Read Form Submission, and written by the
+ * submit route alone. The service tests pass just as happily against a
+ * model the wrong role can write, so those rules are pinned here - along
+ * with every column the migration creates.
  */
 
 type ModelType = { new (): BaseModel };
@@ -78,55 +82,52 @@ const PROJECT_ID: ObjectID = new ObjectID(
   "0194d4ba-0000-4000-8000-00000000f001",
 );
 
-const FORM_WRITERS: Array<Permission> = [
-  Permission.ProjectOwner,
-  Permission.ProjectAdmin,
-  Permission.IncidentAdmin,
-];
-
-const INCIDENT_READERS: Array<Permission> = [
+const OWNERS_AND_ADMINS: Array<Permission> = [
   Permission.ProjectOwner,
   Permission.ProjectAdmin,
-  Permission.ProjectMember,
-  Permission.Viewer,
-  Permission.IncidentAdmin,
-  Permission.IncidentMember,
-  Permission.IncidentViewer,
 ];
 
 const FORM_CREATORS: Array<Permission> = [
-  ...FORM_WRITERS,
-  Permission.CreateIncidentForm,
-];
-const FORM_READERS: Array<Permission> = [
-  ...INCIDENT_READERS,
-  Permission.ReadIncidentForm,
+  ...OWNERS_AND_ADMINS,
+  Permission.CreateForm,
 ];
 const FORM_EDITORS: Array<Permission> = [
-  ...FORM_WRITERS,
-  Permission.EditIncidentForm,
+  ...OWNERS_AND_ADMINS,
+  Permission.EditForm,
 ];
 const FORM_DELETERS: Array<Permission> = [
-  ...FORM_WRITERS,
-  Permission.DeleteIncidentForm,
+  ...OWNERS_AND_ADMINS,
+  Permission.DeleteForm,
+];
+const FORM_READERS: Array<Permission> = [
+  ...OWNERS_AND_ADMINS,
+  Permission.ProjectMember,
+  Permission.Viewer,
+  Permission.IncidentAdmin,
+  Permission.IncidentMember,
+  Permission.IncidentViewer,
+  Permission.ScheduledMaintenanceAdmin,
+  Permission.ScheduledMaintenanceMember,
+  Permission.ScheduledMaintenanceViewer,
+  Permission.ReadForm,
 ];
 
 const SUBMISSION_READERS: Array<Permission> = [
-  ...INCIDENT_READERS,
-  Permission.ReadIncidentFormSubmission,
+  ...OWNERS_AND_ADMINS,
+  Permission.ReadFormSubmission,
 ];
 const SUBMISSION_DELETERS: Array<Permission> = [
-  ...FORM_WRITERS,
-  Permission.DeleteIncidentFormSubmission,
+  ...OWNERS_AND_ADMINS,
+  Permission.DeleteFormSubmission,
 ];
 
 const GRANULAR_PERMISSIONS: Array<[Permission, string]> = [
-  [Permission.CreateIncidentForm, "Create Incident Form"],
-  [Permission.DeleteIncidentForm, "Delete Incident Form"],
-  [Permission.EditIncidentForm, "Edit Incident Form"],
-  [Permission.ReadIncidentForm, "Read Incident Form"],
-  [Permission.DeleteIncidentFormSubmission, "Delete Incident Form Submission"],
-  [Permission.ReadIncidentFormSubmission, "Read Incident Form Submission"],
+  [Permission.CreateForm, "Create Form"],
+  [Permission.DeleteForm, "Delete Form"],
+  [Permission.EditForm, "Edit Form"],
+  [Permission.ReadForm, "Read Form"],
+  [Permission.DeleteFormSubmission, "Delete Form Submission"],
+  [Permission.ReadFormSubmission, "Read Form Submission"],
 ];
 
 const BASE_COLUMNS: Array<string> = [
@@ -144,14 +145,9 @@ const FORM_COLUMNS: Array<string> = [
   "description",
   "isEnabled",
   "shareKey",
-  "incidentSeverity",
-  "incidentSeverityId",
-  "allowReporterToChooseSeverity",
-  "incidentTemplate",
-  "incidentTemplateId",
-  "descriptionSetting",
-  "customFieldSettings",
-  "isReporterDetailsRequired",
+  "targetType",
+  "fields",
+  "targetSettings",
   "successMessage",
   "ipWhitelist",
   "createdByUser",
@@ -160,19 +156,14 @@ const FORM_COLUMNS: Array<string> = [
   "deletedByUserId",
 ];
 
-// The columns a form editor changes after the form is created.
+// The columns a form editor changes once the form exists.
 const FORM_SETTINGS_COLUMNS: Array<string> = [
   "name",
   "description",
   "isEnabled",
-  "incidentSeverity",
-  "incidentSeverityId",
-  "allowReporterToChooseSeverity",
-  "incidentTemplate",
-  "incidentTemplateId",
-  "descriptionSetting",
-  "customFieldSettings",
-  "isReporterDetailsRequired",
+  "targetType",
+  "fields",
+  "targetSettings",
   "successMessage",
   "ipWhitelist",
 ];
@@ -180,12 +171,16 @@ const FORM_SETTINGS_COLUMNS: Array<string> = [
 const SUBMISSION_COLUMNS: Array<string> = [
   "project",
   "projectId",
-  "incidentForm",
-  "incidentFormId",
+  "form",
+  "formId",
+  "answers",
+  "submitterName",
+  "submitterEmail",
+  "targetType",
   "incident",
   "incidentId",
-  "reporterName",
-  "reporterEmail",
+  "scheduledMaintenance",
+  "scheduledMaintenanceId",
 ];
 
 function propsWith(permission: Permission): DatabaseCommonInteractionProps {
@@ -212,31 +207,21 @@ function propsWith(permission: Permission): DatabaseCommonInteractionProps {
   };
 }
 
-function formPayload(): IncidentForm {
-  const form: IncidentForm = new IncidentForm();
+function formPayload(): Form {
+  const form: Form = new Form();
   form.projectId = PROJECT_ID;
-  form.name = "Report a Security Concern";
-  form.description = "Anything that looks wrong.";
-  form.incidentSeverityId = ObjectID.generate();
-  form.incidentTemplateId = ObjectID.generate();
-  form.allowReporterToChooseSeverity = true;
-  form.descriptionSetting = IncidentFormFieldSetting.Required;
-  form.customFieldSettings = { impact: "Required" };
-  form.isReporterDetailsRequired = false;
-  form.successMessage = "Thanks!";
+  form.name = "Request a Change";
+  form.description = "Anything you need changed.";
   form.isEnabled = true;
+  form.targetType = FormTargetType.ScheduledMaintenance;
+  form.fields = getDefaultFormFields(
+    FormTargetType.ScheduledMaintenance,
+  ) as unknown as JSONArray;
+  form.targetSettings = { showOnStatusPages: false };
+  form.successMessage = "Thanks!";
   return form;
 }
 
-function submissionPayload(): IncidentFormSubmission {
-  const submission: IncidentFormSubmission = new IncidentFormSubmission();
-  submission.projectId = PROJECT_ID;
-  submission.incidentFormId = ObjectID.generate();
-  submission.incidentId = ObjectID.generate();
-  submission.reporterName = "Jane Doe";
-  return submission;
-}
-
 function access(model: BaseModel, column: string): ColumnAccessControl {
   const control: ColumnAccessControl | null =
     model.getColumnAccessControlFor(column);
@@ -304,14 +289,10 @@ function claimants(predicate: (model: BaseModel) => boolean): Array<string> {
   });
 }
 
-describe("IncidentForm and IncidentFormSubmission registration", () => {
+describe("Form and FormSubmission registration", () => {
   test.each([
-    [IncidentForm, "IncidentForm", "/incident-form"],
-    [
-      IncidentFormSubmission,
-      "IncidentFormSubmission",
-      "/incident-form-submission",
-    ],
+    [Form, "Form", "/form"],
+    [FormSubmission, "FormSubmission", "/form-submission"],
   ] as Array<[ModelType, string, string]>)(
     "%p is registered and owns its table and CRUD route",
     (modelType: ModelType, tableName: string, route: string) => {
@@ -335,15 +316,30 @@ describe("IncidentForm and IncidentFormSubmission registration", () => {
     },
   );
 
+  test("incident forms are gone: no model owns their tables or routes", () => {
+    expect(
+      claimants((candidate: BaseModel): boolean => {
+        return (
+          candidate.tableName === "IncidentForm" ||
+          candidate.tableName === "IncidentFormSubmission" ||
+          (candidate.getCrudApiPath()?.toString() || "").startsWith(
+            "/incident-form",
+          )
+        );
+      }),
+    ).toEqual([]);
+  });
+
   test("both are named, documented and scoped to a project", () => {
-    const form: IncidentForm = new IncidentForm();
-    const submission: IncidentFormSubmission = new IncidentFormSubmission();
+    const form: Form = new Form();
+    const submission: FormSubmission = new FormSubmission();
 
-    expect(form.singularName).toBe("Incident Form");
-    expect(form.pluralName).toBe("Incident Forms");
+    expect(form.singularName).toBe("Form");
+    expect(form.pluralName).toBe("Forms");
     expect(form.icon).toBe(IconProp.ClipboardDocumentList);
-    expect(submission.singularName).toBe("Incident Form Submission");
-    expect(submission.pluralName).toBe("Incident Form Submissions");
+    expect(submission.singularName).toBe("Form Submission");
+    expect(submission.pluralName).toBe("Form Submissions");
+    expect(submission.icon).toBe(IconProp.ClipboardDocumentCheck);
 
     for (const model of [form, submission] as Array<BaseModel>) {
       expect(model.enableDocumentation).toBe(true);
@@ -352,8 +348,8 @@ describe("IncidentForm and IncidentFormSubmission registration", () => {
     }
   });
 
-  test("a form is offered to workflows; a submission is not (its incident's triggers fire instead)", () => {
-    expect(new IncidentForm().enableWorkflowOn).toEqual({
+  test("a form is offered to workflows; a submission is not (what it created has its own triggers)", () => {
+    expect(new Form().enableWorkflowOn).toEqual({
       create: true,
       delete: true,
       update: true,
@@ -361,7 +357,7 @@ describe("IncidentForm and IncidentFormSubmission registration", () => {
     });
 
     const submissionWorkflow: Record<string, unknown> =
-      (new IncidentFormSubmission().enableWorkflowOn as unknown as
+      (new FormSubmission().enableWorkflowOn as unknown as
         | Record<string, unknown>
         | undefined) || {};
 
@@ -372,8 +368,8 @@ describe("IncidentForm and IncidentFormSubmission registration", () => {
     ).toEqual([]);
   });
 
-  test.each([[IncidentForm], [IncidentFormSubmission]] as Array<[ModelType]>)(
-    "%p is on the Growth plan, like incident templates",
+  test.each([[Form], [FormSubmission]] as Array<[ModelType]>)(
+    "%p is on the Growth plan",
     (modelType: ModelType) => {
       const model: BaseModel = new modelType();
 
@@ -381,16 +377,13 @@ describe("IncidentForm and IncidentFormSubmission registration", () => {
       expect(model.getReadBillingPlan()).toBe(PlanType.Growth);
       expect(model.getUpdateBillingPlan()).toBe(PlanType.Growth);
       expect(model.getDeleteBillingPlan()).toBe(PlanType.Growth);
-      expect(new IncidentTemplate().getCreateBillingPlan()).toBe(
-        PlanType.Growth,
-      );
     },
   );
 });
 
-describe("the six incident form permissions", () => {
+describe("the six form permissions", () => {
   test.each(GRANULAR_PERMISSIONS)(
-    "%s is a tenant-assignable Incident permission titled %j",
+    "%s is a tenant-assignable Form permission titled %j",
     (permission: Permission, title: string) => {
       const props: PermissionProps | undefined = PERMISSION_PROPS.find(
         (candidate: PermissionProps): boolean => {
@@ -400,7 +393,7 @@ describe("the six incident form permissions", () => {
 
       expect(props).toBeDefined();
       expect(props!.title).toBe(title);
-      expect(props!.group).toBe(PermissionGroup.Incident);
+      expect(props!.group).toBe(PermissionGroup.Form);
       expect(props!.isAssignableToTenant).toBe(true);
       expect(props!.isAccessControlPermission).toBe(false);
       expect(props!.isRolePermission).toBe(false);
@@ -409,15 +402,45 @@ describe("the six incident form permissions", () => {
     },
   );
 
-  test("each is spelled as its enum member", () => {
+  test("each is spelled as its enum member, in a group of their own", () => {
     for (const [permission] of GRANULAR_PERMISSIONS) {
       expect(Permission[permission as keyof typeof Permission]).toBe(
         permission,
       );
     }
+
+    expect(PermissionGroup.Form).toBe("Form");
+    expect(
+      PERMISSION_PROPS.filter((props: PermissionProps): boolean => {
+        return props.group === PermissionGroup.Form;
+      })
+        .map((props: PermissionProps): Permission => {
+          return props.permission;
+        })
+        .sort(),
+    ).toEqual(
+      GRANULAR_PERMISSIONS.map(([permission]: [Permission, string]) => {
+        return permission;
+      }).sort(),
+    );
   });
 
-  test.each([[IncidentForm], [IncidentFormSubmission]] as Array<[ModelType]>)(
+  test("the incident form permissions are gone", () => {
+    for (const name of [
+      "CreateIncidentForm",
+      "DeleteIncidentForm",
+      "EditIncidentForm",
+      "ReadIncidentForm",
+      "DeleteIncidentFormSubmission",
+      "ReadIncidentFormSubmission",
+    ]) {
+      expect((Permission as unknown as Record<string, unknown>)[name]).toBe(
+        undefined,
+      );
+    }
+  });
+
+  test.each([[Form], [FormSubmission]] as Array<[ModelType]>)(
     "every permission %p names is in the permission catalogue, and none is ProjectUser",
     (modelType: ModelType) => {
       const model: BaseModel = new modelType();
@@ -457,28 +480,27 @@ describe("the six incident form permissions", () => {
   );
 });
 
-describe("IncidentForm: who may build, read and change a form", () => {
-  const model: IncidentForm = new IncidentForm();
+describe("Form: who may build, read and change a form", () => {
+  const model: Form = new Form();
 
-  test("create, update and delete: owners, admins and incident admins, plus the granular permission", () => {
+  test("create, update and delete: owners, admins and the granular permission", () => {
     expect(model.getCreatePermissions()).toEqual(FORM_CREATORS);
     expect(model.getUpdatePermissions()).toEqual(FORM_EDITORS);
     expect(model.getDeletePermissions()).toEqual(FORM_DELETERS);
   });
 
-  test("read: everyone who reads incidents", () => {
+  test("read: everyone who reads incidents or scheduled maintenance", () => {
     expect(model.getReadPermissions()).toEqual(FORM_READERS);
   });
 
   test.each([
     Permission.ProjectOwner,
     Permission.ProjectAdmin,
-    Permission.IncidentAdmin,
-    Permission.CreateIncidentForm,
+    Permission.CreateForm,
   ])("%s may create a form", (permission: Permission) => {
     expect(() => {
       ModelPermission.checkCreatePermissions(
-        IncidentForm,
+        Form,
         formPayload(),
         propsWith(permission),
       );
@@ -486,22 +508,24 @@ describe("IncidentForm: who may build, read and change a form", () => {
   });
 
   /*
-   * Incident members may edit incident templates, but a form lets people
-   * outside the team page on-call, so building one is not theirs to do.
+   * A form lets people outside the team create records in the project -
+   * incidents that page on-call, maintenance that goes on status pages - so
+   * neither tier's admins may build one by that role alone.
    */
   test.each([
+    Permission.IncidentAdmin,
+    Permission.ScheduledMaintenanceAdmin,
     Permission.ProjectMember,
     Permission.IncidentMember,
     Permission.Viewer,
-    Permission.IncidentViewer,
-    Permission.ReadIncidentForm,
-    Permission.EditIncidentForm,
-    Permission.DeleteIncidentForm,
+    Permission.ReadForm,
+    Permission.EditForm,
+    Permission.DeleteForm,
     Permission.CreateIncidentTemplate,
   ])("%s may not create a form", (permission: Permission) => {
     expect(() => {
       ModelPermission.checkCreatePermissions(
-        IncidentForm,
+        Form,
         formPayload(),
         propsWith(permission),
       );
@@ -511,20 +535,20 @@ describe("IncidentForm: who may build, read and change a form", () => {
   test.each([
     Permission.ProjectOwner,
     Permission.ProjectAdmin,
-    Permission.IncidentAdmin,
-    Permission.EditIncidentForm,
+    Permission.EditForm,
   ])("%s may change every setting of a form", (permission: Permission) => {
-    const settings: IncidentForm = formPayload();
+    const settings: Form = formPayload();
     delete settings.projectId;
+    settings.ipWhitelist = "10.0.0.0/8";
 
     expect(() => {
       TablePermission.checkTableLevelPermissions(
-        IncidentForm,
+        Form,
         propsWith(permission),
         DatabaseRequestType.Update,
       );
       ColumnPermissions.checkDataColumnPermissions(
-        IncidentForm,
+        Form,
         settings,
         propsWith(permission),
         DatabaseRequestType.Update,
@@ -533,17 +557,17 @@ describe("IncidentForm: who may build, read and change a form", () => {
   });
 
   test.each([
+    Permission.IncidentAdmin,
+    Permission.ScheduledMaintenanceAdmin,
     Permission.ProjectMember,
-    Permission.IncidentMember,
     Permission.Viewer,
-    Permission.IncidentViewer,
-    Permission.ReadIncidentForm,
-    Permission.CreateIncidentForm,
+    Permission.ReadForm,
+    Permission.CreateForm,
     Permission.EditIncidentTemplate,
   ])("%s may not change a form", (permission: Permission) => {
     expect(() => {
       TablePermission.checkTableLevelPermissions(
-        IncidentForm,
+        Form,
         propsWith(permission),
         DatabaseRequestType.Update,
       );
@@ -551,28 +575,44 @@ describe("IncidentForm: who may build, read and change a form", () => {
   });
 
   test.each([
-    Permission.IncidentViewer,
     Permission.Viewer,
     Permission.ProjectMember,
+    Permission.IncidentViewer,
     Permission.IncidentMember,
-    Permission.ReadIncidentForm,
+    Permission.ScheduledMaintenanceViewer,
+    Permission.ScheduledMaintenanceMember,
+    Permission.ReadForm,
   ])("%s may read forms", (permission: Permission) => {
     expect(() => {
       TablePermission.checkTableLevelPermissions(
-        IncidentForm,
+        Form,
         propsWith(permission),
         DatabaseRequestType.Read,
       );
     }).not.toThrow();
   });
 
+  test.each([
+    Permission.ReadFormSubmission,
+    Permission.CreateIncidentTemplate,
+    Permission.ReadStatusPageOwnerTeam,
+  ])("%s may not read forms", (permission: Permission) => {
+    expect(() => {
+      TablePermission.checkTableLevelPermissions(
+        Form,
+        propsWith(permission),
+        DatabaseRequestType.Read,
+      );
+    }).toThrow(NotAuthorizedException);
+  });
+
   test("nobody can set who deleted a form", () => {
-    const form: IncidentForm = formPayload();
+    const form: Form = formPayload();
     form.deletedByUserId = ObjectID.generate();
 
     expect(() => {
       ModelPermission.checkCreatePermissions(
-        IncidentForm,
+        Form,
         form,
         propsWith(Permission.ProjectOwner),
       );
@@ -580,19 +620,17 @@ describe("IncidentForm: who may build, read and change a form", () => {
   });
 });
 
-describe("IncidentForm.shareKey: the key in the form's link", () => {
-  const model: IncidentForm = new IncidentForm();
+describe("Form.shareKey: the key in the form's link", () => {
+  const model: Form = new Form();
 
-  test("is a computed ObjectID the API reference documents", () => {
+  test("is a computed ObjectID the API reference documents, with the link it is part of", () => {
     const metadata: TableColumnMetadata =
       model.getTableColumnMetadata("shareKey");
 
     expect(metadata.type).toBe(TableColumnType.ObjectID);
     expect(metadata.computed).toBe(true);
     expect(metadata.hideColumnInDocumentation).toBeFalsy();
-    expect(metadata.description).toContain(
-      "/accounts/incident-form/<shareKey>",
-    );
+    expect(metadata.description).toContain("/accounts/form/<shareKey>");
   });
 
   test("nobody chooses it on create; readers of the form read it; form editors may replace it", () => {
@@ -603,36 +641,28 @@ describe("IncidentForm.shareKey: the key in the form's link", () => {
     expect(control.update).toEqual(model.getUpdatePermissions());
   });
 
-  /*
-   * A computed column is not refused on create - the value is simply
-   * replaced by IncidentFormService.onBeforeCreate (its test pins that).
-   */
   test("a key in a create request passes the permission check, to be replaced by the service", () => {
-    const form: IncidentForm = formPayload();
+    const form: Form = formPayload();
     form.shareKey = ObjectID.generate();
 
     expect(() => {
       ModelPermission.checkCreatePermissions(
-        IncidentForm,
+        Form,
         form,
-        propsWith(Permission.IncidentAdmin),
+        propsWith(Permission.CreateForm),
       );
     }).not.toThrow();
   });
 
-  test.each([
-    Permission.IncidentAdmin,
-    Permission.EditIncidentForm,
-    Permission.ProjectAdmin,
-  ])(
+  test.each([Permission.EditForm, Permission.ProjectAdmin])(
     "%s may reset it, as the dashboard's Reset Link does",
     (permission: Permission) => {
-      const reset: IncidentForm = new IncidentForm();
+      const reset: Form = new Form();
       reset.shareKey = ObjectID.generate();
 
       expect(() => {
         ColumnPermissions.checkDataColumnPermissions(
-          IncidentForm,
+          Form,
           reset,
           propsWith(permission),
           DatabaseRequestType.Update,
@@ -642,17 +672,17 @@ describe("IncidentForm.shareKey: the key in the form's link", () => {
   );
 
   test.each([
-    Permission.IncidentMember,
+    Permission.IncidentAdmin,
     Permission.IncidentViewer,
-    Permission.ReadIncidentForm,
-    Permission.CreateIncidentForm,
+    Permission.ReadForm,
+    Permission.CreateForm,
   ])("%s may not reset it", (permission: Permission) => {
-    const reset: IncidentForm = new IncidentForm();
+    const reset: Form = new Form();
     reset.shareKey = ObjectID.generate();
 
     expect(() => {
       ColumnPermissions.checkDataColumnPermissions(
-        IncidentForm,
+        Form,
         reset,
         propsWith(permission),
         DatabaseRequestType.Update,
@@ -661,7 +691,7 @@ describe("IncidentForm.shareKey: the key in the form's link", () => {
   });
 
   test("is unique across every project and never null: a visit finds its form by this key alone", () => {
-    const args: ColumnMetadataArgs = columnArgs(IncidentForm, "shareKey");
+    const args: ColumnMetadataArgs = columnArgs(Form, "shareKey");
 
     expect(args.options.type).toBe(ColumnType.ObjectID);
     expect(args.options.unique).toBe(true);
@@ -670,8 +700,8 @@ describe("IncidentForm.shareKey: the key in the form's link", () => {
   });
 });
 
-describe("IncidentForm columns", () => {
-  const model: IncidentForm = new IncidentForm();
+describe("Form columns", () => {
+  const model: Form = new Form();
 
   test("has exactly the columns the migration creates", () => {
     expect([...model.getTableColumns().columns].sort()).toEqual(
@@ -721,98 +751,82 @@ describe("IncidentForm columns", () => {
     expect(getUniqueColumnBy(model, "name")).toBe("projectId");
   });
 
-  /*
-   * Required when a form is created (the dashboard's create form and the
-   * API both ask for it), but nullable in the database, so deleting the
-   * severity neither fails because of a form nor deletes the form.
-   */
-  test("incidentSeverityId is required by the app but nullable in the database, and cleared when its severity is deleted", () => {
+  test("what the form creates is required, and starts as an incident", () => {
     const metadata: TableColumnMetadata =
-      model.getTableColumnMetadata("incidentSeverityId");
+      model.getTableColumnMetadata("targetType");
 
-    expect(metadata.type).toBe(TableColumnType.ObjectID);
+    expect(metadata.type).toBe(TableColumnType.ShortText);
     expect(metadata.required).toBe(true);
-    expect(model.getRequiredColumns().columns).toContain("incidentSeverityId");
-    expect(
-      columnArgs(IncidentForm, "incidentSeverityId").options.nullable,
-    ).toBe(true);
-    expect(
-      relationArgs(IncidentForm, "incidentSeverity").options,
-    ).toMatchObject({ nullable: true, onDelete: "SET NULL" });
+    expect(metadata.title).toBe("Creates");
+    expect(metadata.defaultValue).toBe(DEFAULT_FORM_TARGET_TYPE);
+    expect(model.isDefaultValueColumn("targetType")).toBe(true);
+    expect(columnArgs(Form, "targetType").options).toMatchObject({
+      type: ColumnType.ShortText,
+      length: ColumnLength.ShortText,
+      nullable: false,
+      default: FormTargetType.Incident,
+    });
   });
 
-  test("the template is optional, and cleared when the template is deleted", () => {
-    expect(model.getTableColumnMetadata("incidentTemplateId").required).toBe(
-      false,
-    );
-    expect(
-      columnArgs(IncidentForm, "incidentTemplateId").options.nullable,
-    ).toBe(true);
-    expect(
-      relationArgs(IncidentForm, "incidentTemplate").options,
-    ).toMatchObject({ nullable: true, onDelete: "SET NULL" });
-  });
+  test("accepting submissions is a required switch that starts on", () => {
+    const metadata: TableColumnMetadata =
+      model.getTableColumnMetadata("isEnabled");
 
-  test("the project, severity and template ids are indexed", () => {
-    expect(indexedColumns(IncidentForm)).toEqual(
-      ["incidentSeverityId", "incidentTemplateId", "projectId"].sort(),
-    );
+    expect(metadata.type).toBe(TableColumnType.Boolean);
+    expect(metadata.required).toBe(true);
+    expect(metadata.title).toBe("Accepting Submissions");
+    expect(metadata.defaultValue).toBe(true);
+    expect(columnArgs(Form, "isEnabled").options).toMatchObject({
+      type: ColumnType.Boolean,
+      nullable: false,
+      default: true,
+    });
   });
 
-  test.each([
-    ["isEnabled", true],
-    ["allowReporterToChooseSeverity", false],
-    ["isReporterDetailsRequired", true],
-  ])(
-    "%s is a required boolean that starts as %j",
-    (column: string, defaultValue: boolean) => {
-      const metadata: TableColumnMetadata =
-        model.getTableColumnMetadata(column);
-
-      expect(metadata.type).toBe(TableColumnType.Boolean);
-      expect(metadata.required).toBe(true);
-      expect(metadata.defaultValue).toBe(defaultValue);
-      expect(model.isDefaultValueColumn(column)).toBe(true);
-      expect(columnArgs(IncidentForm, column).options).toMatchObject({
-        type: ColumnType.Boolean,
-        nullable: false,
-        default: defaultValue,
-      });
-    },
-  );
-
-  test("the description question starts as Optional, the contract's default", () => {
+  test("the questions are a nullable JSON list the server fills in for a new form", () => {
     const metadata: TableColumnMetadata =
-      model.getTableColumnMetadata("descriptionSetting");
+      model.getTableColumnMetadata("fields");
 
-    expect(metadata.type).toBe(TableColumnType.ShortText);
-    expect(metadata.defaultValue).toBe(
-      DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING,
-    );
-    expect(metadata.defaultValue).toBe(IncidentFormFieldSetting.Optional);
-    expect(model.isDefaultValueColumn("descriptionSetting")).toBe(true);
-    expect(
-      columnArgs(IncidentForm, "descriptionSetting").options,
-    ).toMatchObject({
-      nullable: false,
-      default: DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING,
-    });
+    expect(metadata.type).toBe(TableColumnType.JSON);
+    expect(metadata.required).toBeFalsy();
+    expect(metadata.title).toBe("Questions");
+    expect(columnArgs(Form, "fields").options.nullable).toBe(true);
+
+    for (const source of Object.values(FormFieldSource)) {
+      expect(metadata.description).toContain(source);
+    }
   });
 
-  test("the questions are a nullable JSON object keyed by template variable key", () => {
-    const metadata: TableColumnMetadata = model.getTableColumnMetadata(
-      "customFieldSettings",
+  test("the example questions in the API reference are questions the server accepts", () => {
+    const example: unknown = model.getTableColumnMetadata("fields").example;
+
+    expect(Array.isArray(example)).toBe(true);
+    expect(
+      validateFormFields({
+        value: example,
+        targetType: FormTargetType.Incident,
+      }),
+    ).toBeNull();
+    expect(readFormFields(example)).toHaveLength(
+      (example as Array<unknown>).length,
     );
+  });
+
+  test("the On Submit settings are a nullable JSON object whose example the server accepts", () => {
+    const metadata: TableColumnMetadata =
+      model.getTableColumnMetadata("targetSettings");
 
     expect(metadata.type).toBe(TableColumnType.JSON);
     expect(metadata.required).toBeFalsy();
+    expect(columnArgs(Form, "targetSettings").options.nullable).toBe(true);
     expect(
-      columnArgs(IncidentForm, "customFieldSettings").options.nullable,
-    ).toBe(true);
-    expect(metadata.description).toContain("variableKey");
-    expect(metadata.description).toContain("Required");
-    expect(metadata.description).toContain("Optional");
-    expect(metadata.description).toContain("not listed");
+      validateFormTargetSettings({
+        value: metadata.example,
+        targetType: FormTargetType.Incident,
+      }),
+    ).toBeNull();
+    expect(metadata.description).toContain("showOnStatusPages");
+    expect(metadata.description).toContain("incidentTemplateId");
   });
 
   test.each(["description", "successMessage"])(
@@ -844,6 +858,10 @@ describe("IncidentForm columns", () => {
     });
   });
 
+  test("only the project id is indexed (the share key's unique constraint is its index)", () => {
+    expect(indexedColumns(Form)).toEqual(["projectId"]);
+  });
+
   interface RelationCase {
     relation: string;
     idColumn: string;
@@ -858,18 +876,6 @@ describe("IncidentForm columns", () => {
       modelType: Project,
       onDelete: "CASCADE",
     },
-    {
-      relation: "incidentSeverity",
-      idColumn: "incidentSeverityId",
-      modelType: IncidentSeverity,
-      onDelete: "SET NULL",
-    },
-    {
-      relation: "incidentTemplate",
-      idColumn: "incidentTemplateId",
-      modelType: IncidentTemplate,
-      onDelete: "SET NULL",
-    },
     {
       relation: "createdByUser",
       idColumn: "createdByUserId",
@@ -891,22 +897,17 @@ describe("IncidentForm columns", () => {
       expect(metadata.type).toBe(TableColumnType.Entity);
       expect(metadata.modelType).toBe(modelType);
       expect(metadata.manyToOneRelationColumn).toBe(idColumn);
-      expect(relationArgs(IncidentForm, relation).relationType).toBe(
-        "many-to-one",
-      );
-      expect(relationArgs(IncidentForm, relation).options.onDelete).toBe(
-        onDelete,
-      );
+      expect(relationArgs(Form, relation).relationType).toBe("many-to-one");
+      expect(relationArgs(Form, relation).options.onDelete).toBe(onDelete);
     },
   );
 });
 
 /*
  * What the published API (and so the MCP tools and the Terraform provider)
- * says about a form: see IncidentCustomFieldApiSchemaContract.test.ts for how
- * the provider reads these schemas.
+ * says about a form.
  */
-describe("IncidentForm in the published API", () => {
+describe("Form in the published API", () => {
   type SchemaGetter = (data: {
     modelType: new () => BaseModel;
   }) => ModelSchemaType;
@@ -914,7 +915,7 @@ describe("IncidentForm in the published API", () => {
   function generated(getSchema: SchemaGetter): JSONObject {
     const registry: OpenAPIRegistry = new OpenAPIRegistry();
 
-    registry.register("Schema", getSchema({ modelType: IncidentForm }));
+    registry.register("Schema", getSchema({ modelType: Form }));
 
     const document: JSONObject = new OpenApiGeneratorV3(
       registry.definitions,
@@ -949,25 +950,23 @@ describe("IncidentForm in the published API", () => {
     return (schema["required"] as Array<string> | undefined) || [];
   }
 
-  test("a form cannot be created without a name and a severity", () => {
-    expect(requiredOf(create)).toEqual(
-      expect.arrayContaining(["name", "incidentSeverityId"]),
-    );
+  test("a form cannot be created without a name", () => {
+    expect(requiredOf(create)).toEqual(expect.arrayContaining(["name"]));
   });
 
-  test("the switches and the description question are optional to send, with their defaults published", () => {
+  test("what it creates and whether it accepts submissions are optional to send, with their defaults published", () => {
     for (const column of [
       "isEnabled",
-      "allowReporterToChooseSeverity",
-      "isReporterDetailsRequired",
-      "descriptionSetting",
+      "targetType",
+      "fields",
+      "targetSettings",
     ]) {
       expect(requiredOf(create)).not.toContain(column);
     }
 
-    expect(
-      (propertiesOf(create)["descriptionSetting"] as JSONObject)["default"],
-    ).toBe(DEFAULT_INCIDENT_FORM_DESCRIPTION_SETTING);
+    expect((propertiesOf(create)["targetType"] as JSONObject)["default"]).toBe(
+      DEFAULT_FORM_TARGET_TYPE,
+    );
     expect((propertiesOf(create)["isEnabled"] as JSONObject)["default"]).toBe(
       true,
     );
@@ -983,122 +982,106 @@ describe("IncidentForm in the published API", () => {
     expect(property["readOnly"]).toBe(true);
   });
 
-  test.each(
-    FORM_SETTINGS_COLUMNS.filter((column: string): boolean => {
-      return !["incidentSeverity", "incidentTemplate"].includes(column);
-    }),
-  )("%s is writable on create and update", (column: string) => {
-    expect(propertiesOf(create)[column]).toBeDefined();
-    expect(propertiesOf(update)[column]).toBeDefined();
-  });
+  test.each(FORM_SETTINGS_COLUMNS)(
+    "%s is writable on create and update",
+    (column: string) => {
+      expect(propertiesOf(create)[column]).toBeDefined();
+      expect(propertiesOf(update)[column]).toBeDefined();
+    },
+  );
 });
 
-describe("IncidentFormSubmission: written by the submit route alone", () => {
-  const model: IncidentFormSubmission = new IncidentFormSubmission();
+describe("FormSubmission: written by the submit route alone", () => {
+  const model: FormSubmission = new FormSubmission();
 
-  test("the API cannot create or edit a submission; incident readers read them; incident admins delete them", () => {
+  test("the API cannot create or edit a submission; owners, admins and the granular permissions read and delete them", () => {
     expect(model.getCreatePermissions()).toEqual([]);
     expect(model.getUpdatePermissions()).toEqual([]);
     expect(model.getReadPermissions()).toEqual(SUBMISSION_READERS);
     expect(model.getDeletePermissions()).toEqual(SUBMISSION_DELETERS);
   });
 
-  test.each([
-    Permission.ProjectOwner,
-    Permission.ProjectAdmin,
-    Permission.IncidentAdmin,
-    Permission.CreateIncidentForm,
-  ])("not even %s may create one through the API", (permission: Permission) => {
-    expect(() => {
-      ModelPermission.checkCreatePermissions(
-        IncidentFormSubmission,
-        submissionPayload(),
-        propsWith(permission),
-      );
-    }).toThrow(NotAuthorizedException);
-  });
+  test.each(SUBMISSION_COLUMNS)(
+    "%s is read by submission readers and written by nobody",
+    (column: string) => {
+      expect(access(model, column)).toEqual({
+        create: [],
+        read: SUBMISSION_READERS,
+        update: [],
+      });
+    },
+  );
 
   test.each([
-    Permission.ProjectOwner,
+    Permission.ProjectMember,
+    Permission.Viewer,
     Permission.IncidentAdmin,
-    Permission.EditIncidentForm,
-  ])("not even %s may edit one", (permission: Permission) => {
-    expect(() => {
-      TablePermission.checkTableLevelPermissions(
-        IncidentFormSubmission,
-        propsWith(permission),
-        DatabaseRequestType.Update,
-      );
-    }).toThrow(NotAuthorizedException);
-  });
-
-  test.each(SUBMISSION_DELETERS)(
-    "%s may delete one, and the reporter's name and email with it",
+    Permission.IncidentViewer,
+    Permission.ScheduledMaintenanceAdmin,
+    Permission.ReadForm,
+    Permission.EditForm,
+  ])(
+    "%s may not read a stranger's answers, name and email",
     (permission: Permission) => {
       expect(() => {
         TablePermission.checkTableLevelPermissions(
-          IncidentFormSubmission,
+          FormSubmission,
           propsWith(permission),
-          DatabaseRequestType.Delete,
+          DatabaseRequestType.Read,
         );
-      }).not.toThrow();
+      }).toThrow(NotAuthorizedException);
     },
   );
 
   test.each([
-    Permission.ProjectMember,
-    Permission.IncidentMember,
-    Permission.IncidentViewer,
-    Permission.ReadIncidentFormSubmission,
-    Permission.DeleteIncidentForm,
-  ])("%s may not delete one", (permission: Permission) => {
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ReadFormSubmission,
+  ])("%s may read submissions", (permission: Permission) => {
     expect(() => {
       TablePermission.checkTableLevelPermissions(
-        IncidentFormSubmission,
+        FormSubmission,
         propsWith(permission),
-        DatabaseRequestType.Delete,
-      );
-    }).toThrow(NotAuthorizedException);
-  });
-
-  /*
-   * A submission belongs to its incident, like the incident's notes: a role
-   * limited to some labels, or to the incidents its holder owns, must not
-   * list the reporters of every other incident.
-   */
-  test("reads follow the incident's labels", () => {
-    expect(model.canAccessIfCanReadOn).toBe("incident");
-  });
-
-  test("owners see the submissions of the incidents they own", () => {
-    expect(model.ownedThrough).toEqual({
-      fkColumn: "incidentId",
-      parentModels: [Incident],
-      includeProjectScope: false,
-    });
-  });
-
-  test("reading a form does not mean reading its submissions", () => {
-    expect(() => {
-      TablePermission.checkTableLevelPermissions(
-        IncidentFormSubmission,
-        propsWith(Permission.ReadIncidentForm),
         DatabaseRequestType.Read,
       );
-    }).toThrow(NotAuthorizedException);
+    }).not.toThrow();
+  });
 
+  test.each([
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.DeleteFormSubmission,
+  ])("%s may delete a submission", (permission: Permission) => {
     expect(() => {
       TablePermission.checkTableLevelPermissions(
-        IncidentFormSubmission,
-        propsWith(Permission.ReadIncidentFormSubmission),
-        DatabaseRequestType.Read,
+        FormSubmission,
+        propsWith(permission),
+        DatabaseRequestType.Delete,
       );
     }).not.toThrow();
   });
+
+  test.each([Permission.ProjectOwner, Permission.ReadFormSubmission])(
+    "%s may not create one",
+    (permission: Permission) => {
+      const submission: FormSubmission = new FormSubmission();
+      submission.projectId = PROJECT_ID;
+      submission.formId = ObjectID.generate();
+      submission.submitterName = "Jane";
+
+      expect(() => {
+        ModelPermission.checkCreatePermissions(
+          FormSubmission,
+          submission,
+          propsWith(permission),
+        );
+      }).toThrow(NotAuthorizedException);
+    },
+  );
 });
 
-describe("IncidentFormSubmission columns", () => {
-  const model: IncidentFormSubmission = new IncidentFormSubmission();
+describe("FormSubmission columns", () => {
+  const model: FormSubmission = new FormSubmission();
 
   test("has exactly the columns the migration creates - no created-by or deleted-by user", () => {
     expect([...model.getTableColumns().columns].sort()).toEqual(
@@ -1106,145 +1089,100 @@ describe("IncidentFormSubmission columns", () => {
     );
   });
 
-  test.each(SUBMISSION_COLUMNS)(
-    "%s is read by submission readers and written by nobody",
-    (column: string) => {
-      expect(access(model, column)).toEqual({
-        create: [],
-        read: SUBMISSION_READERS,
-        update: [],
-      });
-    },
-  );
-
-  test.each([
-    ["projectId", true],
-    ["incidentFormId", true],
-    ["incidentId", false],
-  ])(
-    "%s is an id relation queries may read (required: %j)",
-    (column: string, required: boolean) => {
-      const metadata: TableColumnMetadata =
-        model.getTableColumnMetadata(column);
+  test("the project, form, incident and event ids are indexed", () => {
+    expect(indexedColumns(FormSubmission)).toEqual(
+      ["formId", "incidentId", "projectId", "scheduledMaintenanceId"].sort(),
+    );
+  });
 
-      expect(metadata.type).toBe(TableColumnType.ObjectID);
-      expect(Boolean(metadata.required)).toBe(required);
-      expect(metadata.canReadOnRelationQuery).toBe(true);
-      expect(columnArgs(IncidentFormSubmission, column).options.nullable).toBe(
-        !required,
-      );
-    },
-  );
+  test("the submitter's name and email are optional and as long as the public form allows", () => {
+    expect(model.getTableColumnMetadata("submitterName")).toMatchObject({
+      type: TableColumnType.ShortText,
+      required: false,
+    });
+    expect(columnArgs(FormSubmission, "submitterName").options).toMatchObject({
+      nullable: true,
+      length: ColumnLength.ShortText,
+    });
+    expect(model.getTableColumnMetadata("submitterEmail")).toMatchObject({
+      type: TableColumnType.Email,
+      required: false,
+    });
+    expect(columnArgs(FormSubmission, "submitterEmail").options).toMatchObject({
+      nullable: true,
+      length: ColumnLength.Email,
+    });
+  });
 
-  test("the project, form and incident ids are indexed", () => {
-    expect(indexedColumns(IncidentFormSubmission)).toEqual(
-      ["incidentFormId", "incidentId", "projectId"].sort(),
+  test("the answers are a nullable JSON list", () => {
+    expect(model.getTableColumnMetadata("answers").type).toBe(
+      TableColumnType.JSON,
     );
+    expect(columnArgs(FormSubmission, "answers").options.nullable).toBe(true);
   });
 
+  interface RelationCase {
+    relation: string;
+    idColumn: string;
+    modelType: ModelType;
+    onDelete: string;
+    nullable: boolean;
+  }
+
   test.each([
-    ["project", "projectId", Project, "CASCADE"],
-    ["incidentForm", "incidentFormId", IncidentForm, "CASCADE"],
-    ["incident", "incidentId", Incident, "SET NULL"],
-  ] as Array<[string, string, ModelType, string]>)(
-    "%s points at its model through %s, and is %s on delete",
-    (
-      relation: string,
-      idColumn: string,
-      modelType: ModelType,
-      onDelete: string,
-    ) => {
+    {
+      relation: "project",
+      idColumn: "projectId",
+      modelType: Project,
+      onDelete: "CASCADE",
+      nullable: false,
+    },
+    {
+      relation: "form",
+      idColumn: "formId",
+      modelType: Form,
+      onDelete: "CASCADE",
+      nullable: false,
+    },
+    {
+      relation: "incident",
+      idColumn: "incidentId",
+      modelType: Incident,
+      onDelete: "SET NULL",
+      nullable: true,
+    },
+    {
+      relation: "scheduledMaintenance",
+      idColumn: "scheduledMaintenanceId",
+      modelType: ScheduledMaintenance,
+      onDelete: "SET NULL",
+      nullable: true,
+    },
+  ] as Array<RelationCase>)(
+    "$relation points at its model through $idColumn: $onDelete on delete",
+    ({ relation, idColumn, modelType, onDelete, nullable }: RelationCase) => {
       const metadata: TableColumnMetadata =
         model.getTableColumnMetadata(relation);
 
       expect(metadata.type).toBe(TableColumnType.Entity);
       expect(metadata.modelType).toBe(modelType);
       expect(metadata.manyToOneRelationColumn).toBe(idColumn);
-      expect(
-        relationArgs(IncidentFormSubmission, relation).options.onDelete,
-      ).toBe(onDelete);
+      expect(relationArgs(FormSubmission, relation).options).toMatchObject({
+        onDelete,
+        nullable,
+      });
     },
   );
 
-  test("the reporter's name and email are optional and as long as the public contract allows", () => {
-    expect(model.getTableColumnMetadata("reporterName").type).toBe(
-      TableColumnType.ShortText,
-    );
-    expect(model.getTableColumnMetadata("reporterEmail").type).toBe(
-      TableColumnType.Email,
-    );
-
-    const name: ColumnMetadataArgs = columnArgs(
-      IncidentFormSubmission,
-      "reporterName",
-    );
-    const email: ColumnMetadataArgs = columnArgs(
-      IncidentFormSubmission,
-      "reporterEmail",
+  test("deleting the form deletes its submissions; deleting what one created keeps it", () => {
+    expect(relationArgs(FormSubmission, "form").options.onDelete).toBe(
+      "CASCADE",
     );
-
-    expect(name.options.nullable).toBe(true);
-    expect(email.options.nullable).toBe(true);
-    expect(Number(name.options.length)).toBe(
-      INCIDENT_FORM_REPORTER_NAME_MAX_LENGTH,
+    expect(relationArgs(FormSubmission, "incident").options.onDelete).toBe(
+      "SET NULL",
     );
-    expect(Number(email.options.length)).toBe(
-      INCIDENT_FORM_REPORTER_EMAIL_MAX_LENGTH,
-    );
-    expect(email.options.transformer).toBeDefined();
-  });
-});
-
-describe("an IncidentForm row and the public contract", () => {
-  test("a stored form passed as it is gives the public page its subset and nothing else", () => {
-    const form: IncidentForm = formPayload();
-    form._id = "0c0c0c0c-0000-4000-8000-00000000f002";
-    form.shareKey = new ObjectID("0d0d0d0d-0000-4000-8000-00000000f003");
-    form.ipWhitelist = "10.0.0.0/8";
-    form.createdByUserId = ObjectID.generate();
-
-    const severityId: string = form.incidentSeverityId!.toString();
-
-    const publicForm: PublicIncidentForm = getPublicIncidentForm({
-      form: form,
-      askedDefinitions: [
-        {
-          name: "Impact",
-          customFieldType: CustomFieldType.Text,
-          isRequiredOnCreate: true,
-        },
-      ],
-      severities: [{ _id: severityId, name: "High" }],
-      isCaptchaRequired: false,
-    });
-
-    expect(publicForm).toEqual({
-      name: "Report a Security Concern",
-      description: "Anything that looks wrong.",
-      descriptionSetting: IncidentFormFieldSetting.Required,
-      isReporterDetailsRequired: false,
-      severities: [{ _id: severityId, name: "High" }],
-      defaultIncidentSeverityId: severityId,
-      customFields: [
-        {
-          name: "Impact",
-          customFieldType: CustomFieldType.Text,
-          isRequired: true,
-        },
-      ],
-      isCaptchaRequired: false,
-    });
-
-    const serialized: string = JSON.stringify(publicForm);
-
-    for (const secret of [
-      "0d0d0d0d-0000-4000-8000-00000000f003",
-      form.incidentTemplateId!.toString(),
-      PROJECT_ID.toString(),
-      "10.0.0.0/8",
-      "Thanks!",
-    ]) {
-      expect(serialized).not.toContain(secret);
-    }
+    expect(
+      relationArgs(FormSubmission, "scheduledMaintenance").options.onDelete,
+    ).toBe("SET NULL");
   });
 });