@oneuptime/common 12.0.8 → 12.0.9

package/Tests/UI/Components/Workflow/ModelColumnEditor.test.ts

@@ -9,8 +9,10 @@
 
 import {
   ModelColumnEditorMode,
+  ParsedQuery,
   buildColumnValueJson,
   classifyColumnValueCompatibility,
+  normalizeInitialValue,
 } from "../../../../UI/Components/Workflow/ModelColumnEditor";
 import { ModelSchemaColumn } from "../../../../UI/Components/Workflow/ModelSchema";
 import Dictionary from "../../../../Types/Dictionary";
@@ -202,7 +204,7 @@ describe("classifyColumnValueCompatibility — operators", () => {
 
 describe("buildColumnValueJson", () => {
   test("an empty set collapses to empty text, so required still fires", () => {
-    expect(buildColumnValueJson({})).toBe("");
+    expect(buildColumnValueJson({}, ModelColumnEditorMode.Query)).toBe("");
   });
 
   test("a row with no column name is dropped", () => {
@@ -210,7 +212,7 @@ describe("buildColumnValueJson", () => {
       "": "orphan",
     } as Dictionary<DictionaryEntryValue>;
 
-    expect(buildColumnValueJson(rows)).toBe("");
+    expect(buildColumnValueJson(rows, ModelColumnEditorMode.Query)).toBe("");
   });
 
   test("plain values serialize as plain JSON", () => {
@@ -219,7 +221,9 @@ describe("buildColumnValueJson", () => {
       isEnabled: true,
     } as Dictionary<DictionaryEntryValue>;
 
-    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Query)),
+    ).toEqual({
       name: "abc",
       isEnabled: true,
     });
@@ -235,7 +239,9 @@ describe("buildColumnValueJson", () => {
       name: new NotEqual<string>("abc"),
     } as unknown as Dictionary<DictionaryEntryValue>;
 
-    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Query)),
+    ).toEqual({
       name: { _type: ObjectType.NotEqual, value: "abc" },
     });
   });
@@ -249,7 +255,9 @@ describe("buildColumnValueJson", () => {
       e: new Includes(["p", "q"]),
     } as unknown as Dictionary<DictionaryEntryValue>;
 
-    const parsed: JSONObject = JSON.parse(buildColumnValueJson(rows));
+    const parsed: JSONObject = JSON.parse(
+      buildColumnValueJson(rows, ModelColumnEditorMode.Query),
+    );
 
     expect((parsed["a"] as JSONObject)["_type"]).toBe(ObjectType.NotEqual);
     expect((parsed["b"] as JSONObject)["_type"]).toBe(ObjectType.Search);
@@ -263,7 +271,9 @@ describe("buildColumnValueJson", () => {
       _id: "{{local.components.api-get-1.returnValues.response-body}}",
     } as Dictionary<DictionaryEntryValue>;
 
-    expect(JSON.parse(buildColumnValueJson(rows))).toEqual({
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Query)),
+    ).toEqual({
       _id: "{{local.components.api-get-1.returnValues.response-body}}",
     });
   });
@@ -274,7 +284,9 @@ describe("buildColumnValueJson", () => {
       isEnabled: true,
     } as unknown as Dictionary<DictionaryEntryValue>;
 
-    const roundTripped: JSONObject = JSON.parse(buildColumnValueJson(rows));
+    const roundTripped: JSONObject = JSON.parse(
+      buildColumnValueJson(rows, ModelColumnEditorMode.Query),
+    );
 
     expect(
       classifyColumnValueCompatibility(
@@ -285,3 +297,226 @@ describe("buildColumnValueJson", () => {
     ).toBe(true);
   });
 });
+
+/*
+ * Record mode drives the create and update payloads, which is the half of this
+ * editor that never actually rendered: ArgumentsForm selected it only for
+ * ComponentInputType.BaseModel, and no component declares an argument of that
+ * type. These pin the behaviour that half needs now that it is reachable.
+ */
+describe("buildColumnValueJson — record mode", () => {
+  test("drops a row whose value is still empty", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: "acme",
+      secretValue: "",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Record)),
+    ).toEqual({ name: "acme" });
+  });
+
+  /*
+   * The editor opens with a blank row for every column a create must be given.
+   * Serialized, those rows are "" — a non-empty string, which both
+   * validateRequired and GraphLint's isEmptyArgumentValue read as "filled in".
+   * Keeping them would let an untouched Create One save as if it were complete.
+   */
+  test("a form of nothing but seeded blank rows still reads as empty", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: "",
+      secretValue: "",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(buildColumnValueJson(rows, ModelColumnEditorMode.Record)).toBe("");
+  });
+
+  test("false and zero are values, not emptiness", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      isEnabled: false,
+      count: 0,
+    } as unknown as Dictionary<DictionaryEntryValue>;
+
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Record)),
+    ).toEqual({ isEnabled: false, count: 0 });
+  });
+
+  /*
+   * Query mode must keep them: matching a column against "" is a real
+   * condition, and silently dropping it would change which records a step acts
+   * on.
+   */
+  test("query mode keeps an empty value, because matching on it is a real filter", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      name: "",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Query)),
+    ).toEqual({ name: "" });
+  });
+
+  test("a row with no column name is dropped in record mode too", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      "": "orphan",
+      name: "acme",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Record)),
+    ).toEqual({ name: "acme" });
+  });
+
+  test("a reference typed into a row survives as an ordinary string", () => {
+    const rows: Dictionary<DictionaryEntryValue> = {
+      monitorId:
+        "{{local.components.monitor-find-one-1.returnValues.model._id}}",
+    } as Dictionary<DictionaryEntryValue>;
+
+    expect(
+      JSON.parse(buildColumnValueJson(rows, ModelColumnEditorMode.Record)),
+    ).toEqual({
+      monitorId:
+        "{{local.components.monitor-find-one-1.returnValues.model._id}}",
+    });
+  });
+});
+
+describe("classifyColumnValueCompatibility — mode-specific wording", () => {
+  /*
+   * Record mode renders with enableOperators={false}, so telling its reader to
+   * use the "is any of" operator was pointing at a control that is not on their
+   * screen.
+   */
+  test("a list in a record does not suggest an operator", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        { name: ["a", "b"] } as unknown as JSONObject,
+        COLUMNS,
+        ModelColumnEditorMode.Record,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons[0]).not.toMatch(/is any of/);
+    expect(result.reasons[0]).toMatch(/Keep editing as JSON/);
+  });
+
+  test("a list in a query still suggests the operator", () => {
+    const result: { reasons: Array<string> } = classifyColumnValueCompatibility(
+      { name: ["a", "b"] } as unknown as JSONObject,
+      COLUMNS,
+      ModelColumnEditorMode.Query,
+    );
+
+    expect(result.reasons[0]).toMatch(/is any of/);
+  });
+
+  /*
+   * A bare {{ }} reference where a value goes is not JSON, so it cannot be
+   * rows — but it is a perfectly good workflow value, and both GraphLint and
+   * form validation accept it because they mask references before parsing.
+   * Calling it "not a JSON object" told the builder something the canvas
+   * contradicted.
+   */
+  test("a template reference is explained as such, not called broken", () => {
+    const result: { compatible: boolean; reasons: Array<string> } =
+      classifyColumnValueCompatibility(
+        null,
+        COLUMNS,
+        ModelColumnEditorMode.Record,
+        true,
+      );
+
+    expect(result.compatible).toBe(false);
+    expect(result.reasons[0]).toMatch(/\{\{ \}\} reference/);
+    expect(result.reasons[0]).not.toMatch(/isn't a JSON object/);
+  });
+
+  test("genuinely broken text is still called that", () => {
+    const result: { reasons: Array<string> } = classifyColumnValueCompatibility(
+      null,
+      COLUMNS,
+      ModelColumnEditorMode.Record,
+      false,
+    );
+
+    expect(result.reasons[0]).toMatch(/isn't a JSON object/);
+  });
+});
+
+describe("normalizeInitialValue", () => {
+  test("an absent value is an empty, representable record", () => {
+    for (const empty of [null, undefined, ""]) {
+      const parsed: ParsedQuery = normalizeInitialValue(empty);
+
+      expect(parsed.parsed).toEqual({});
+      expect(parsed.text).toBe("");
+      expect(parsed.hasTemplateExpressions).toBe(false);
+    }
+  });
+
+  test("an object is taken as-is and pretty-printed for the JSON editor", () => {
+    const parsed: ParsedQuery = normalizeInitialValue({ name: "acme" });
+
+    expect(parsed.parsed).toEqual({ name: "acme" });
+    expect(JSON.parse(parsed.text)).toEqual({ name: "acme" });
+  });
+
+  test("a stored JSON string parses into rows", () => {
+    const parsed: ParsedQuery = normalizeInitialValue('{"name":"acme"}');
+
+    expect(parsed.parsed).toEqual({ name: "acme" });
+    expect(parsed.hasTemplateExpressions).toBe(false);
+  });
+
+  /*
+   * The case that was misreported. checkJSONSyntax masks {{...}} before
+   * parsing, so GraphLint and Validation both consider this valid; the editor
+   * used bare JSON.parse and so disagreed with them silently.
+   */
+  test("a bare reference where a value goes is flagged as a reference", () => {
+    const parsed: ParsedQuery = normalizeInitialValue(
+      '{"retries": {{local.variables.retryCount}}}',
+    );
+
+    expect(parsed.parsed).toBeNull();
+    expect(parsed.hasTemplateExpressions).toBe(true);
+    // The stored text is preserved exactly, for the JSON editor to show.
+    expect(parsed.text).toBe('{"retries": {{local.variables.retryCount}}}');
+  });
+
+  /*
+   * A reference inside a string is ordinary JSON and must stay editable as
+   * rows — that is the common case, and locking it would be a regression.
+   */
+  test("a quoted reference is ordinary JSON and stays as rows", () => {
+    const parsed: ParsedQuery = normalizeInitialValue(
+      '{"name": "{{local.variables.name}}"}',
+    );
+
+    expect(parsed.parsed).toEqual({ name: "{{local.variables.name}}" });
+    expect(parsed.hasTemplateExpressions).toBe(false);
+  });
+
+  test("text that is broken with or without references is not excused", () => {
+    const parsed: ParsedQuery = normalizeInitialValue(
+      '{"name": {{local.variables.x}}',
+    );
+
+    expect(parsed.parsed).toBeNull();
+    expect(parsed.hasTemplateExpressions).toBe(false);
+  });
+
+  test("a JSON array is not a record", () => {
+    const parsed: ParsedQuery = normalizeInitialValue('[{"name":"acme"}]');
+
+    expect(parsed.parsed).toBeNull();
+    expect(parsed.hasTemplateExpressions).toBe(false);
+  });
+
+  test("a JSON scalar is not a record either", () => {
+    expect(normalizeInitialValue('"just a string"').parsed).toBeNull();
+    expect(normalizeInitialValue("42").parsed).toBeNull();
+  });
+});

package/Tests/UI/Components/Workflow/ModelColumnEditorServerContract.test.ts

@@ -41,7 +41,10 @@ type RoundTripFunction = (rows: Dictionary<DictionaryEntryValue>) => JSONObject;
 const roundTrip: RoundTripFunction = (
   rows: Dictionary<DictionaryEntryValue>,
 ): JSONObject => {
-  const stored: string = buildColumnValueJson(rows);
+  const stored: string = buildColumnValueJson(
+    rows,
+    ModelColumnEditorMode.Query,
+  );
   const parsedByRunner: JSONObject = JSON.parse(stored);
 
   return JSONFunctions.deserialize(parsedByRunner) as JSONObject;
@@ -156,11 +159,14 @@ describe("row editor output survives the server's deserialization", () => {
   });
 
   test("a record of values to write deserializes to plain values", () => {
-    const stored: string = buildColumnValueJson({
-      name: "acme",
-      isEnabled: true,
-      count: 4,
-    } as Dictionary<DictionaryEntryValue>);
+    const stored: string = buildColumnValueJson(
+      {
+        name: "acme",
+        isEnabled: true,
+        count: 4,
+      } as Dictionary<DictionaryEntryValue>,
+      ModelColumnEditorMode.Record,
+    );
 
     expect(JSONFunctions.deserialize(JSON.parse(stored))).toEqual({
       name: "acme",
@@ -175,7 +181,9 @@ describe("row editor output survives the server's deserialization", () => {
       count: new GreaterThan<number>(3),
     } as unknown as Dictionary<DictionaryEntryValue>;
 
-    const stored: JSONObject = JSON.parse(buildColumnValueJson(rows));
+    const stored: JSONObject = JSON.parse(
+      buildColumnValueJson(rows, ModelColumnEditorMode.Query),
+    );
 
     expect(
       classifyColumnValueCompatibility(stored, [], ModelColumnEditorMode.Query)

package/Tests/UI/Components/Workflow/ModelSchema.test.ts

@@ -17,11 +17,23 @@ import {
   isBooleanColumn,
   isNumericColumn,
   isScalarColumn,
+  requiredWritableColumns,
 } from "../../../../UI/Components/Workflow/ModelSchema";
 import API from "../../../../UI/Utils/API/API";
 import HTTPErrorResponse from "../../../../Types/API/HTTPErrorResponse";
+import TableColumnType from "../../../../Types/Database/TableColumnType";
 import { afterEach, describe, expect, test } from "@jest/globals";
 
+/*
+ * Every `type` here is a TableColumnType *value*, because that is what the
+ * endpoint puts on the wire — JSON.stringify of a string enum emits the value.
+ *
+ * This is worth being explicit about, because several values differ from the
+ * member name that reads like the obvious literal: ShortText is "Text",
+ * ObjectID is "Object ID", PositiveNumber is "Positive Number". These tests
+ * previously asserted against the member names, so they passed while the code
+ * they covered classified the two most-declared non-relation types wrongly.
+ */
 type MakeColumnFunction = (
   overrides: Partial<ModelSchemaColumn>,
 ) => ModelSchemaColumn;
@@ -32,7 +44,7 @@ const makeColumn: MakeColumnFunction = (
   return {
     id: "name",
     title: "Name",
-    type: "ShortText",
+    type: TableColumnType.ShortText,
     isRelation: false,
     ...overrides,
   };
@@ -41,15 +53,19 @@ const makeColumn: MakeColumnFunction = (
 describe("isScalarColumn", () => {
   test("accepts the column types a single input can hold", () => {
     const scalarTypes: Array<string> = [
-      "ShortText",
-      "LongText",
-      "ObjectID",
-      "Number",
-      "Boolean",
-      "Date",
-      "Email",
-      "URL",
-      "Markdown",
+      TableColumnType.ShortText,
+      TableColumnType.LongText,
+      TableColumnType.VeryLongText,
+      TableColumnType.ObjectID,
+      TableColumnType.Number,
+      TableColumnType.PositiveNumber,
+      TableColumnType.Boolean,
+      TableColumnType.Date,
+      TableColumnType.Email,
+      TableColumnType.LongURL,
+      TableColumnType.Markdown,
+      TableColumnType.Slug,
+      TableColumnType.Port,
     ];
 
     for (const type of scalarTypes) {
@@ -57,42 +73,199 @@ describe("isScalarColumn", () => {
     }
   });
 
+  /*
+   * The exact regression: "Text" is what the wire carries for a ShortText
+   * column, and it is the single most common column type in the schema.
+   */
+  test('accepts a ShortText column, which arrives on the wire as "Text"', () => {
+    expect(isScalarColumn(makeColumn({ type: "Text" }))).toBe(true);
+  });
+
+  test('accepts an ObjectID column, which arrives as "Object ID"', () => {
+    expect(isScalarColumn(makeColumn({ type: "Object ID" }))).toBe(true);
+  });
+
   test("rejects a relation, however it is typed", () => {
     expect(
-      isScalarColumn(makeColumn({ type: "ShortText", isRelation: true })),
+      isScalarColumn(
+        makeColumn({ type: TableColumnType.ShortText, isRelation: true }),
+      ),
     ).toBe(false);
     expect(
-      isScalarColumn(makeColumn({ type: "Entity", isRelation: true })),
+      isScalarColumn(
+        makeColumn({ type: TableColumnType.Entity, isRelation: true }),
+      ),
     ).toBe(false);
   });
 
   test("rejects types a single box cannot hold", () => {
-    expect(isScalarColumn(makeColumn({ type: "JSON" }))).toBe(false);
-    expect(isScalarColumn(makeColumn({ type: "Buffer" }))).toBe(false);
-    expect(isScalarColumn(makeColumn({ type: "EntityArray" }))).toBe(false);
+    expect(isScalarColumn(makeColumn({ type: TableColumnType.JSON }))).toBe(
+      false,
+    );
+    expect(isScalarColumn(makeColumn({ type: TableColumnType.Buffer }))).toBe(
+      false,
+    );
+    expect(
+      isScalarColumn(makeColumn({ type: TableColumnType.EntityArray })),
+    ).toBe(false);
+    expect(
+      isScalarColumn(makeColumn({ type: TableColumnType.MonitorSteps })),
+    ).toBe(false);
   });
 
   test("rejects a type it has never heard of", () => {
     expect(isScalarColumn(makeColumn({ type: "SomethingNew" }))).toBe(false);
   });
+
+  /*
+   * Guards the whole class of bug above: no member NAME may be accepted unless
+   * it happens to also be a value. If someone reintroduces a hand-written
+   * literal list, this fails.
+   */
+  test("never classifies on the enum member name", () => {
+    const values: Array<string> = Object.values(TableColumnType);
+
+    for (const [name] of Object.entries(TableColumnType)) {
+      if (values.includes(name)) {
+        continue;
+      }
+
+      expect(isScalarColumn(makeColumn({ type: name }))).toBe(false);
+    }
+  });
 });
 
 describe("isNumericColumn", () => {
-  test("is true for the two numeric types", () => {
-    expect(isNumericColumn(makeColumn({ type: "Number" }))).toBe(true);
-    expect(isNumericColumn(makeColumn({ type: "PositiveNumber" }))).toBe(true);
+  test("is true for every numeric width", () => {
+    const numericTypes: Array<string> = [
+      TableColumnType.Number,
+      TableColumnType.SmallNumber,
+      TableColumnType.BigNumber,
+      TableColumnType.PositiveNumber,
+      TableColumnType.SmallPositiveNumber,
+      TableColumnType.BigPositiveNumber,
+      TableColumnType.Port,
+    ];
+
+    for (const type of numericTypes) {
+      expect(isNumericColumn(makeColumn({ type: type }))).toBe(true);
+    }
   });
 
   test("is false for everything else", () => {
-    expect(isNumericColumn(makeColumn({ type: "ShortText" }))).toBe(false);
-    expect(isNumericColumn(makeColumn({ type: "Boolean" }))).toBe(false);
+    expect(
+      isNumericColumn(makeColumn({ type: TableColumnType.ShortText })),
+    ).toBe(false);
+    expect(isNumericColumn(makeColumn({ type: TableColumnType.Boolean }))).toBe(
+      false,
+    );
+  });
+
+  test("is false for a relation, whatever it is typed", () => {
+    expect(
+      isNumericColumn(
+        makeColumn({ type: TableColumnType.Number, isRelation: true }),
+      ),
+    ).toBe(false);
   });
 });
 
 describe("isBooleanColumn", () => {
   test("is true only for Boolean", () => {
-    expect(isBooleanColumn(makeColumn({ type: "Boolean" }))).toBe(true);
-    expect(isBooleanColumn(makeColumn({ type: "ShortText" }))).toBe(false);
+    expect(isBooleanColumn(makeColumn({ type: TableColumnType.Boolean }))).toBe(
+      true,
+    );
+    expect(
+      isBooleanColumn(makeColumn({ type: TableColumnType.ShortText })),
+    ).toBe(false);
+  });
+});
+
+/*
+ * The record editor opens with a blank row for each of these, so getting the
+ * set wrong is immediately visible: too many rows and the builder is asked for
+ * values the server would have supplied, too few and the create fails.
+ */
+describe("requiredWritableColumns", () => {
+  test("keeps a required column with no default", () => {
+    const columns: Array<ModelSchemaColumn> = [
+      makeColumn({ id: "name", required: true }),
+    ];
+
+    expect(
+      requiredWritableColumns(columns).map((c: ModelSchemaColumn) => {
+        return c.id;
+      }),
+    ).toEqual(["name"]);
+  });
+
+  test("drops optional columns", () => {
+    expect(
+      requiredWritableColumns([makeColumn({ id: "description" })]),
+    ).toEqual([]);
+    expect(
+      requiredWritableColumns([
+        makeColumn({ id: "description", required: false }),
+      ]),
+    ).toEqual([]);
+  });
+
+  /*
+   * DatabaseService.checkRequiredFields exempts a column carrying a default, so
+   * asking the builder for one would be asking for something the create does
+   * not need.
+   */
+  test("drops a required column that has a default", () => {
+    expect(
+      requiredWritableColumns([
+        makeColumn({ id: "createdAt", required: true, hasDefault: true }),
+      ]),
+    ).toEqual([]);
+  });
+
+  /*
+   * applyTenantColumn stamps the project itself and discards anything supplied
+   * for it, so a row for it could only ever mislead.
+   */
+  test("drops the project column even when it is required", () => {
+    expect(
+      requiredWritableColumns([
+        makeColumn({ id: "projectId", required: true, isTenantColumn: true }),
+      ]),
+    ).toEqual([]);
+  });
+
+  test("drops relations, because a row holds one scalar", () => {
+    expect(
+      requiredWritableColumns([
+        makeColumn({
+          id: "monitorStatus",
+          required: true,
+          isRelation: true,
+          type: TableColumnType.Entity,
+        }),
+      ]),
+    ).toEqual([]);
+  });
+
+  test("treats a column from an older response, with no flags, as optional", () => {
+    expect(requiredWritableColumns([makeColumn({ id: "name" })])).toEqual([]);
+  });
+
+  test("picks only the required ones out of a realistic mix", () => {
+    const columns: Array<ModelSchemaColumn> = [
+      makeColumn({ id: "_id", required: true, hasDefault: true }),
+      makeColumn({ id: "projectId", required: true, isTenantColumn: true }),
+      makeColumn({ id: "name", required: true }),
+      makeColumn({ id: "secretValue", required: true }),
+      makeColumn({ id: "description" }),
+    ];
+
+    expect(
+      requiredWritableColumns(columns).map((c: ModelSchemaColumn) => {
+        return c.id;
+      }),
+    ).toEqual(["name", "secretValue"]);
   });
 });
 
@@ -159,16 +332,57 @@ describe("fetchModelSchema", () => {
     await expect(fetchModelSchema("Monitor")).rejects.toBe(errorResponse);
   });
 
-  test("escapes the table name into the path", async () => {
-    mockGet({ data: { columns: [] } });
-
-    await fetchModelSchema("Weird/Name");
+  type RequestedUrlFunction = () => string;
 
+  const requestedUrl: RequestedUrlFunction = (): string => {
     const call: { url: { toString: () => string } } = (
       API.get as unknown as jest.Mock
     ).mock.calls[0][0] as { url: { toString: () => string } };
 
-    expect(call.url.toString()).toContain("Weird%2FName");
-    expect(call.url.toString()).not.toContain("Weird/Name");
+    return call.url.toString();
+  };
+
+  /*
+   * The read request has to keep the URL it always had. The field picker and
+   * the query builder are both gated on read access deliberately — filtering on
+   * a column your role cannot read is a disclosure vector — so an accidental
+   * "access" parameter on those would widen what they offer.
+   */
+  test("asks for read access by default, without saying so", async () => {
+    mockGet({ data: { columns: [] } });
+
+    await fetchModelSchema("Monitor");
+
+    expect(requestedUrl()).not.toContain("access");
+  });
+
+  test("says nothing extra when read is asked for explicitly", async () => {
+    mockGet({ data: { columns: [] } });
+
+    await fetchModelSchema("Monitor", "read");
+
+    expect(requestedUrl()).not.toContain("access");
+  });
+
+  /*
+   * Write access is what makes MonitorSecret.secretValue visible: it declares
+   * read: [] with full create and update lists, so under the read gate the one
+   * column Create One Monitor Secret exists to write is absent.
+   */
+  test("asks for write access when the record editor needs it", async () => {
+    mockGet({ data: { columns: [] } });
+
+    await fetchModelSchema("MonitorSecret", "write");
+
+    expect(requestedUrl()).toContain("access=write");
+  });
+
+  test("escapes the table name into the path", async () => {
+    mockGet({ data: { columns: [] } });
+
+    await fetchModelSchema("Weird/Name");
+
+    expect(requestedUrl()).toContain("Weird%2FName");
+    expect(requestedUrl()).not.toContain("Weird/Name");
   });
 });