@oneuptime/common 14.0.1 → 14.0.3

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

@@ -13,6 +13,7 @@ import RumSessionReplayView from "../../../Models/DatabaseModels/RumSessionRepla
 import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
 import Dictionary from "../../../Types/Dictionary";
 import { TableColumnMetadata } from "../../../Types/Database/TableColumn";
+import TableColumnType from "../../../Types/Database/TableColumnType";
 import Permission from "../../../Types/Permission";
 import SessionReplayCaptureTrigger from "../../../Types/Rum/SessionReplayCaptureTrigger";
 import SessionReplayConsentMode from "../../../Types/Rum/SessionReplayConsentMode";
@@ -159,6 +160,8 @@ describe("RumApplication session replay configuration", () => {
       "sessionReplayMonthlyBudgetInGB",
       "sessionReplayLastChunkReceivedAt",
       "sessionReplayBudgetExceededAt",
+      "sessionReplayTracePropagationOrigins",
+      "sessionReplaySameOriginTracePropagation",
     ];
 
     for (const columnName of expectedColumns) {
@@ -266,6 +269,120 @@ describe("RumApplication session replay configuration", () => {
     );
   });
 
+  /*
+   * Same-origin trace propagation: the recorder adds traceparent and a
+   * tracestate member carrying the session id to requests to the page's own
+   * origin. On by default (for existing applications too, via the column
+   * default), so the switch is the way back without a customer redeploy.
+   * Turning it on links recordings to backend telemetry that may name the
+   * user and sends the session id past the customer's backend, which is the
+   * identity switch's reason for its narrower ACL - so it gets that ACL.
+   */
+  it("ships same-origin trace propagation on by default, as a required boolean", () => {
+    const column: TableColumnMetadata = getColumn(
+      "sessionReplaySameOriginTracePropagation",
+    );
+
+    expect(column.defaultValue).toBe(true);
+    expect(column.required).toBe(true);
+    expect(column.isDefaultValueColumn).toBe(true);
+    expect(column.type).toBe(TableColumnType.Boolean);
+    expect(column.title).toBe("Same-origin trace propagation");
+
+    /* The description names what it sends, where, and what that costs. */
+    for (const phrase of [
+      "traceparent",
+      "tracestate",
+      "session id",
+      "own origin",
+      "sampled",
+      "third parties",
+    ]) {
+      expect({ phrase, found: column.description?.includes(phrase) }).toEqual({
+        phrase,
+        found: true,
+      });
+    }
+  });
+
+  /*
+   * TraceIdRatioBased hashes the trace id differently in each language SDK
+   * (and the OTel spec recommends it for root spans only), so a ratio
+   * delegate for sampled remote parents on every service of a polyglot
+   * backend drops spans from traces the first hop kept. The description
+   * used to recommend the delegate without saying where it goes.
+   */
+  it("scopes the remote-parent ratio delegate in the description to the first hop", () => {
+    const description: string =
+      getColumn("sessionReplaySameOriginTracePropagation").description || "";
+
+    for (const phrase of [
+      "remoteParentSampled ratio delegate only on the service(s) your pages call directly",
+      "never on the services they call",
+      "ratio decisions differ between language SDKs",
+      "tail sampling in an OpenTelemetry Collector",
+    ]) {
+      expect({ phrase, found: description.includes(phrase) }).toEqual({
+        phrase,
+        found: true,
+      });
+    }
+
+    expect(description).not.toContain(
+      "(set a remoteParentSampled delegate to keep ratio sampling)",
+    );
+  });
+
+  it("gives same-origin trace propagation the identity switch's narrower create and update ACL", () => {
+    const accessControl: Dictionary<ColumnAccessControl> =
+      model.getColumnAccessControlForAllColumns();
+    const sameOrigin: ColumnAccessControl | undefined =
+      accessControl["sessionReplaySameOriginTracePropagation"];
+    const identity: ColumnAccessControl | undefined =
+      accessControl["sessionReplayCaptureUserIdentity"];
+
+    expect(sameOrigin).toBeDefined();
+    expect([...(sameOrigin?.create || [])].sort()).toEqual(
+      [...(identity?.create || [])].sort(),
+    );
+    expect([...(sameOrigin?.update || [])].sort()).toEqual(
+      [...(identity?.update || [])].sort(),
+    );
+
+    for (const permission of [
+      Permission.ProjectMember,
+      Permission.SettingsMember,
+    ]) {
+      expect(sameOrigin?.create || []).not.toContain(permission);
+      expect(sameOrigin?.update || []).not.toContain(permission);
+    }
+
+    expect(sameOrigin?.update || []).toContain(Permission.ProjectAdmin);
+    expect(sameOrigin?.update || []).toContain(Permission.EditRumApplication);
+
+    /* Readable by everyone who can read the rest of the replay policy. */
+    expect([...(sameOrigin?.read || [])].sort()).toEqual(
+      [
+        ...(accessControl["sessionReplayTracePropagationOrigins"]?.read || []),
+      ].sort(),
+    );
+  });
+
+  /*
+   * The origins list used to promise "Empty means never inject". With
+   * same-origin propagation on by default that is false for the page's own
+   * origin, so the list is described as the CROSS-origin one.
+   */
+  it("describes the trace propagation origins as the cross-origin list", () => {
+    const description: string =
+      getColumn("sessionReplayTracePropagationOrigins").description || "";
+
+    expect(description).not.toContain("Empty means never inject");
+    expect(description).toContain("OTHER origins");
+    expect(description).toContain("Same-origin trace propagation");
+    expect(description).toContain("never the session id");
+  });
+
   it("never exposes the ingest diagnostics as writable", () => {
     const accessControl: Dictionary<ColumnAccessControl> =
       model.getColumnAccessControlForAllColumns();

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

@@ -0,0 +1,236 @@
+import WorkspaceProjectAuthToken, {
+  LegacyServerOnlyMiscDataKeys,
+} from "../../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import DatabaseRequestType from "../../../Server/Types/BaseDatabase/DatabaseRequestType";
+import SelectPermission from "../../../Server/Types/Database/Permissions/SelectPermission";
+import TablePermission from "../../../Server/Types/Database/Permissions/TablePermission";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+import ColumnPermissions from "../../../Server/Types/Database/Permissions/ColumnPermission";
+import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import ObjectID from "../../../Types/ObjectID";
+import Permission, {
+  UserPermission,
+  UserTenantAccessPermission,
+} from "../../../Types/Permission";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * WorkspaceProjectAuthToken is the binding every Slack and Microsoft Teams
+ * path trusts: which workspace or tenant a project's bot token belongs to.
+ * For Teams the server goes further and mints a fresh Graph app token for
+ * whichever tenant `workspaceProjectId` names.
+ *
+ * So the binding may only be written by the connect flows, which prove the
+ * workspace or tenant first (see WorkspaceOAuthState). The CRUD API must not
+ * be a second way to create it or to change which workspace it names.
+ *
+ * Nor may it change miscData. For Microsoft Teams that holds the Bot
+ * Framework service URLs proactive sends go to, with the bot's token
+ * attached, plus the tenant's consent state. The Slack channel cache, the
+ * one part the dashboard edits, has its own route (PUT /slack/channel-cache).
+ *
+ * And miscData, which every role down to Viewer can read, must not carry a
+ * credential: the Teams Graph app token lives only in the server-only
+ * authToken / authTokenExpiresAt columns.
+ */
+
+const projectId: ObjectID = ObjectID.generate();
+const userId: ObjectID = ObjectID.generate();
+
+function propsWith(
+  permissions: Array<Permission>,
+): DatabaseCommonInteractionProps {
+  const userPermissions: Array<UserPermission> = permissions.map(
+    (permission: Permission) => {
+      return {
+        _type: "UserPermission" as const,
+        permission: permission,
+        labelIds: [],
+        isBlockPermission: false,
+      };
+    },
+  );
+
+  const tenantPermission: UserTenantAccessPermission = {
+    projectId,
+    _type: "UserTenantAccessPermission",
+    permissions: userPermissions,
+  };
+
+  return {
+    userId,
+    tenantId: projectId,
+    userTenantAccessPermission: {
+      [projectId.toString()]: tenantPermission,
+    },
+  };
+}
+
+function check(
+  permissions: Array<Permission>,
+  type: DatabaseRequestType,
+): Error | null {
+  try {
+    TablePermission.checkTableLevelPermissions(
+      WorkspaceProjectAuthToken,
+      propsWith(permissions),
+      type,
+    );
+  } catch (err) {
+    return err as Error;
+  }
+
+  return null;
+}
+
+function selectError(
+  permissions: Array<Permission>,
+  select: Record<string, boolean>,
+): Error | null {
+  try {
+    SelectPermission.checkSelectPermission(
+      WorkspaceProjectAuthToken,
+      select as any,
+      propsWith(permissions),
+    );
+  } catch (err) {
+    return err as Error;
+  }
+
+  return null;
+}
+
+const columnAccess: (column: string) => ColumnAccessControl = (
+  column: string,
+): ColumnAccessControl => {
+  const accessControl: ColumnAccessControl | null =
+    new WorkspaceProjectAuthToken().getColumnAccessControlFor(column);
+
+  expect(accessControl).not.toBeNull();
+  return accessControl!;
+};
+
+describe("WorkspaceProjectAuthToken access control", () => {
+  test("no project role can create the binding through the CRUD API", () => {
+    expect(new WorkspaceProjectAuthToken().getCreatePermissions()).toEqual([]);
+
+    for (const permission of [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ]) {
+      const error: Error | null = check(
+        [permission],
+        DatabaseRequestType.Create,
+      );
+
+      expect(error).not.toBeNull();
+      expect(error?.message).toContain("is not allowed");
+    }
+  });
+
+  test("no project role can repoint the binding at another workspace or tenant", () => {
+    expect(columnAccess("workspaceProjectId").update).toEqual([]);
+  });
+
+  test("no project role can replace the bot token", () => {
+    expect(columnAccess("authToken").update).toEqual([]);
+    expect(columnAccess("authToken").read).toEqual([]);
+  });
+
+  test("members can still read the connection", () => {
+    expect(check([Permission.Viewer], DatabaseRequestType.Read)).toBeNull();
+    expect(columnAccess("miscData").read).toContain(Permission.Viewer);
+  });
+
+  test("no project role can change miscData through the CRUD API", () => {
+    expect(columnAccess("miscData").update).toEqual([]);
+
+    for (const permission of [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ]) {
+      const update: WorkspaceProjectAuthToken = new WorkspaceProjectAuthToken();
+      update.miscData = {
+        installedTeams: {
+          "team-1": {
+            id: "team-1",
+            serviceUrl: "https://attacker.example.com/",
+          },
+        },
+      };
+
+      let error: Error | null = null;
+
+      try {
+        ColumnPermissions.checkDataColumnPermissions(
+          WorkspaceProjectAuthToken,
+          update,
+          propsWith([permission]),
+          DatabaseRequestType.Update,
+        );
+      } catch (err) {
+        error = err as Error;
+      }
+
+      expect(error).not.toBeNull();
+      expect(error?.message).toContain("miscData");
+    }
+  });
+
+  /*
+   * For Microsoft Teams `authToken` is a live Microsoft Graph app token for
+   * the customer's tenant. It used to be copied into miscData as well, which
+   * every Viewer can read, so any Viewer could lift it with
+   * GET /workspace-project-auth-token selecting miscData.
+   */
+  test("no project role can read or write the token's expiry", () => {
+    expect(columnAccess("authTokenExpiresAt").read).toEqual([]);
+    expect(columnAccess("authTokenExpiresAt").create).toEqual([]);
+    expect(columnAccess("authTokenExpiresAt").update).toEqual([]);
+  });
+
+  test("no project role can select the token columns", () => {
+    for (const permission of [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+    ]) {
+      for (const column of ["authToken", "authTokenExpiresAt"]) {
+        const error: Error | null = selectError([permission], {
+          [column]: true,
+        });
+
+        expect(error).toBeInstanceOf(NotAuthorizedException);
+      }
+    }
+  });
+
+  test("a Viewer can still select miscData, which the dashboard reads", () => {
+    expect(
+      selectError([Permission.Viewer], {
+        miscData: true,
+        workspaceType: true,
+        workspaceProjectId: true,
+      }),
+    ).toBeNull();
+  });
+
+  test("the keys that used to carry the Graph app token are stripped from miscData", () => {
+    expect(LegacyServerOnlyMiscDataKeys).toEqual(
+      expect.arrayContaining(["appAccessToken", "appAccessTokenExpiresAt"]),
+    );
+  });
+
+  test("owners and admins can still disconnect", () => {
+    expect(
+      check([Permission.ProjectAdmin], DatabaseRequestType.Delete),
+    ).toBeNull();
+    expect(
+      check([Permission.ProjectOwner], DatabaseRequestType.Delete),
+    ).toBeNull();
+  });
+});

package/Tests/Models/IncidentEpisodePublicNoteNotifyColumnContract.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV3,
+} from "@asteasolutions/zod-to-openapi";
+import IncidentEpisodePublicNote from "../../Models/DatabaseModels/IncidentEpisodePublicNote";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import { JSONObject } from "../../Types/JSON";
+import { ModelSchema } from "../../Utils/Schema/ModelSchema";
+import { SafeParseReturnType, ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+
+/*
+ * What the published API says about "notify subscribers" on a new incident
+ * episode public note.
+ *
+ * When a create leaves the flag out, the server takes it from the episode:
+ * on for an episode whose subscribers were told it was created, off for one
+ * created quietly. The OpenAPI spec, the MCP tools and the Terraform
+ * provider are all generated from this column's metadata, so a fixed
+ * `default: true` there would be wrong for quiet episodes - and the
+ * Terraform provider turns a spec default into a value it always sends,
+ * which would bypass the episode's setting entirely.
+ */
+
+const COLUMN: string = "shouldStatusPageSubscribersBeNotifiedOnNoteCreated";
+
+function getGeneratedCreateSchema(): JSONObject {
+  const registry: OpenAPIRegistry = new OpenAPIRegistry();
+
+  registry.register(
+    "IncidentEpisodePublicNoteCreate",
+    ModelSchema.getCreateModelSchema({ modelType: IncidentEpisodePublicNote }),
+  );
+
+  const document: JSONObject = new OpenApiGeneratorV3(
+    registry.definitions,
+  ).generateComponents() as unknown as JSONObject;
+
+  return ((document["components"] as JSONObject)["schemas"] as JSONObject)[
+    "IncidentEpisodePublicNoteCreate"
+  ] as JSONObject;
+}
+
+describe("IncidentEpisodePublicNote notify-on-create column contract", () => {
+  const note: IncidentEpisodePublicNote = new IncidentEpisodePublicNote();
+  const metadata: TableColumnMetadata = note.getTableColumnMetadata(COLUMN);
+
+  test("declares no fixed default, because the default depends on the episode", () => {
+    expect(metadata.defaultValue).toBeUndefined();
+  });
+
+  test("stays optional on create, so leaving it out is allowed", () => {
+    expect(note.isDefaultValueColumn(COLUMN)).toBe(true);
+    expect(metadata.required).toBeFalsy();
+  });
+
+  test("describes the episode-based default for API readers", () => {
+    expect(metadata.description).toContain("If left out");
+    expect(metadata.description).toContain("follows the episode");
+  });
+
+  test("a new note object does not start with the flag set", () => {
+    expect(
+      new IncidentEpisodePublicNote()
+        .shouldStatusPageSubscribersBeNotifiedOnNoteCreated,
+    ).toBeUndefined();
+  });
+
+  test("the generated create schema publishes the field without a default", () => {
+    const property: JSONObject = (
+      getGeneratedCreateSchema()["properties"] as JSONObject
+    )[COLUMN] as JSONObject;
+
+    expect(property).toBeDefined();
+    expect(property["type"]).toBe("boolean");
+    expect(property).not.toHaveProperty("default");
+  });
+
+  test("the generated create schema does not require the field", () => {
+    const required: Array<string> =
+      (getGeneratedCreateSchema()["required"] as Array<string> | undefined) ||
+      [];
+
+    expect(required).not.toContain(COLUMN);
+  });
+
+  test("validating the field when it is left out keeps it unset for the server to fill in", () => {
+    const schema: ZodObject<ZodRawShape> = ModelSchema.getCreateModelSchema({
+      modelType: IncidentEpisodePublicNote,
+    }) as unknown as ZodObject<ZodRawShape>;
+    const fieldSchema: ZodTypeAny = schema.shape[COLUMN] as ZodTypeAny;
+
+    expect(fieldSchema).toBeDefined();
+
+    const parsed: SafeParseReturnType<unknown, unknown> =
+      fieldSchema.safeParse(undefined);
+
+    expect(parsed.success).toBe(true);
+    expect(parsed.data).toBeUndefined();
+    expect(fieldSchema.safeParse(false).data).toBe(false);
+    expect(fieldSchema.safeParse(true).data).toBe(true);
+  });
+});

package/Tests/Models/IncidentPublicNoteNotifyColumnContract.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV3,
+} from "@asteasolutions/zod-to-openapi";
+import IncidentPublicNote from "../../Models/DatabaseModels/IncidentPublicNote";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import { JSONObject } from "../../Types/JSON";
+import { ModelSchema } from "../../Utils/Schema/ModelSchema";
+import { SafeParseReturnType, ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+
+/*
+ * What the published API says about "notify subscribers" on a new incident
+ * public note.
+ *
+ * When a create leaves the flag out, the server takes it from the incident:
+ * on for an incident whose subscribers were told it was declared, off for one
+ * declared quietly. The OpenAPI spec, the MCP tools and the Terraform
+ * provider are all generated from this column's metadata, so a fixed
+ * `default: true` there would be wrong for quiet incidents - and the
+ * Terraform provider turns a spec default into a value it always sends,
+ * which would bypass the incident's setting entirely.
+ */
+
+const COLUMN: string = "shouldStatusPageSubscribersBeNotifiedOnNoteCreated";
+
+function getGeneratedCreateSchema(): JSONObject {
+  const registry: OpenAPIRegistry = new OpenAPIRegistry();
+
+  registry.register(
+    "IncidentPublicNoteCreate",
+    ModelSchema.getCreateModelSchema({ modelType: IncidentPublicNote }),
+  );
+
+  const document: JSONObject = new OpenApiGeneratorV3(
+    registry.definitions,
+  ).generateComponents() as unknown as JSONObject;
+
+  return ((document["components"] as JSONObject)["schemas"] as JSONObject)[
+    "IncidentPublicNoteCreate"
+  ] as JSONObject;
+}
+
+describe("IncidentPublicNote notify-on-create column contract", () => {
+  const note: IncidentPublicNote = new IncidentPublicNote();
+  const metadata: TableColumnMetadata = note.getTableColumnMetadata(COLUMN);
+
+  test("declares no fixed default, because the default depends on the incident", () => {
+    expect(metadata.defaultValue).toBeUndefined();
+  });
+
+  test("stays optional on create, so leaving it out is allowed", () => {
+    expect(note.isDefaultValueColumn(COLUMN)).toBe(true);
+    expect(metadata.required).toBeFalsy();
+  });
+
+  test("describes the incident-based default for API readers", () => {
+    expect(metadata.description).toContain("If left out");
+    expect(metadata.description).toContain("follows the incident");
+  });
+
+  test("the generated create schema publishes the field without a default", () => {
+    const property: JSONObject = (
+      getGeneratedCreateSchema()["properties"] as JSONObject
+    )[COLUMN] as JSONObject;
+
+    expect(property).toBeDefined();
+    expect(property["type"]).toBe("boolean");
+    expect(property).not.toHaveProperty("default");
+  });
+
+  test("the generated create schema does not require the field", () => {
+    const required: Array<string> =
+      (getGeneratedCreateSchema()["required"] as Array<string> | undefined) ||
+      [];
+
+    expect(required).not.toContain(COLUMN);
+  });
+
+  test("validating the field when it is left out keeps it unset for the server to fill in", () => {
+    const schema: ZodObject<ZodRawShape> = ModelSchema.getCreateModelSchema({
+      modelType: IncidentPublicNote,
+    }) as unknown as ZodObject<ZodRawShape>;
+    const fieldSchema: ZodTypeAny = schema.shape[COLUMN] as ZodTypeAny;
+
+    expect(fieldSchema).toBeDefined();
+
+    const parsed: SafeParseReturnType<unknown, unknown> =
+      fieldSchema.safeParse(undefined);
+
+    expect(parsed.success).toBe(true);
+    expect(parsed.data).toBeUndefined();
+    expect(fieldSchema.safeParse(false).data).toBe(false);
+    expect(fieldSchema.safeParse(true).data).toBe(true);
+  });
+});

package/Tests/Models/ScheduledMaintenancePublicNoteNotifyColumnContract.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV3,
+} from "@asteasolutions/zod-to-openapi";
+import ScheduledMaintenancePublicNote from "../../Models/DatabaseModels/ScheduledMaintenancePublicNote";
+import { TableColumnMetadata } from "../../Types/Database/TableColumn";
+import { JSONObject } from "../../Types/JSON";
+import { ModelSchema } from "../../Utils/Schema/ModelSchema";
+import { SafeParseReturnType, ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+
+/*
+ * What the published API says about "notify subscribers" on a new scheduled
+ * maintenance public note.
+ *
+ * When a create leaves the flag out, the server takes it from the scheduled
+ * maintenance event: on for an event whose subscribers were told it was
+ * created, off for one created quietly. The OpenAPI spec, the MCP tools and
+ * the Terraform provider are all generated from this column's metadata, so a
+ * fixed `default: true` there would be wrong for quiet events - and the
+ * Terraform provider turns a spec default into a value it always sends,
+ * which would bypass the event's setting entirely.
+ *
+ * The column keeps `example: true`. That is only a sample value for readers
+ * of the spec, not a default, so these tests check for `default` only.
+ */
+
+const COLUMN: string = "shouldStatusPageSubscribersBeNotifiedOnNoteCreated";
+
+function getGeneratedCreateSchema(): JSONObject {
+  const registry: OpenAPIRegistry = new OpenAPIRegistry();
+
+  registry.register(
+    "ScheduledMaintenancePublicNoteCreate",
+    ModelSchema.getCreateModelSchema({
+      modelType: ScheduledMaintenancePublicNote,
+    }),
+  );
+
+  const document: JSONObject = new OpenApiGeneratorV3(
+    registry.definitions,
+  ).generateComponents() as unknown as JSONObject;
+
+  return ((document["components"] as JSONObject)["schemas"] as JSONObject)[
+    "ScheduledMaintenancePublicNoteCreate"
+  ] as JSONObject;
+}
+
+describe("ScheduledMaintenancePublicNote notify-on-create column contract", () => {
+  const note: ScheduledMaintenancePublicNote =
+    new ScheduledMaintenancePublicNote();
+  const metadata: TableColumnMetadata = note.getTableColumnMetadata(COLUMN);
+
+  test("declares no fixed default, because the default depends on the event", () => {
+    expect(metadata.defaultValue).toBeUndefined();
+  });
+
+  test("stays optional on create, so leaving it out is allowed", () => {
+    expect(note.isDefaultValueColumn(COLUMN)).toBe(true);
+    expect(metadata.required).toBeFalsy();
+  });
+
+  test("describes the event-based default for API readers", () => {
+    expect(metadata.description).toContain("If left out");
+    expect(metadata.description).toContain(
+      "follows the scheduled maintenance event",
+    );
+  });
+
+  test("a new note object does not start with the flag set", () => {
+    expect(
+      new ScheduledMaintenancePublicNote()
+        .shouldStatusPageSubscribersBeNotifiedOnNoteCreated,
+    ).toBeUndefined();
+  });
+
+  test("the generated create schema publishes the field without a default", () => {
+    const property: JSONObject = (
+      getGeneratedCreateSchema()["properties"] as JSONObject
+    )[COLUMN] as JSONObject;
+
+    expect(property).toBeDefined();
+    expect(property["type"]).toBe("boolean");
+    expect(property).not.toHaveProperty("default");
+  });
+
+  test("the generated create schema does not require the field", () => {
+    const required: Array<string> =
+      (getGeneratedCreateSchema()["required"] as Array<string> | undefined) ||
+      [];
+
+    expect(required).not.toContain(COLUMN);
+  });
+
+  test("validating the field when it is left out keeps it unset for the server to fill in", () => {
+    const schema: ZodObject<ZodRawShape> = ModelSchema.getCreateModelSchema({
+      modelType: ScheduledMaintenancePublicNote,
+    }) as unknown as ZodObject<ZodRawShape>;
+    const fieldSchema: ZodTypeAny = schema.shape[COLUMN] as ZodTypeAny;
+
+    expect(fieldSchema).toBeDefined();
+
+    const parsed: SafeParseReturnType<unknown, unknown> =
+      fieldSchema.safeParse(undefined);
+
+    expect(parsed.success).toBe(true);
+    expect(parsed.data).toBeUndefined();
+    expect(fieldSchema.safeParse(false).data).toBe(false);
+    expect(fieldSchema.safeParse(true).data).toBe(true);
+  });
+});