@stigmer/react 3.11.0 → 3.12.0

package/src/datastore/__tests__/recordValues.test.ts

@@ -1,359 +0,0 @@
-// Tests for the client-side projection of the DD-004 canonical value
-// contract. The cases mirror the authoritative Go schema tests
-// (pkg/domain/datastore/schema) so a drift between projection and
-// enforcement shows up here first.
-
-import { describe, expect, it } from "vitest";
-import { create } from "@bufbuild/protobuf";
-import {
-  FieldDeclarationSchema,
-  FieldType,
-} from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/spec_pb";
-import { RecordConditionOp } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_io_pb";
-import {
-  buildUpdateFields,
-  coerceFieldValue,
-  formatFieldValue,
-  formatSystemTimestamp,
-  isListOperator,
-  isSortableField,
-  isValuelessOperator,
-  operatorsForField,
-  RESERVED_FIELD_NAMES,
-  SYSTEM_FIELD_OPERATORS,
-} from "../recordValues.js";
-
-function field(overrides: {
-  name?: string;
-  type: FieldType;
-  required?: boolean;
-  enumValues?: string[];
-}) {
-  return create(FieldDeclarationSchema, {
-    name: overrides.name ?? "f",
-    type: overrides.type,
-    required: overrides.required ?? false,
-    enumValues: overrides.enumValues ?? [],
-  });
-}
-
-describe("coerceFieldValue", () => {
-  it("passes explicit null through for every type (tri-state clear)", () => {
-    for (const type of [
-      FieldType.string,
-      FieldType.integer,
-      FieldType.number,
-      FieldType.bool,
-      FieldType.timestamp,
-      FieldType.date,
-      FieldType.time,
-      FieldType.json,
-    ]) {
-      expect(coerceFieldValue(field({ type }), null)).toEqual({ ok: true, value: null });
-    }
-  });
-
-  describe("string", () => {
-    it("accepts a plain string", () => {
-      expect(coerceFieldValue(field({ type: FieldType.string }), "hello")).toEqual({
-        ok: true,
-        value: "hello",
-      });
-    });
-
-    it("rejects non-strings", () => {
-      const r = coerceFieldValue(field({ name: "note", type: FieldType.string }), 5);
-      expect(r).toEqual({ ok: false, error: 'field "note" must be a string' });
-    });
-
-    it("enforces enum_values membership", () => {
-      const f = field({
-        name: "status",
-        type: FieldType.string,
-        enumValues: ["confirmed", "cancelled"],
-      });
-      expect(coerceFieldValue(f, "confirmed")).toEqual({ ok: true, value: "confirmed" });
-      expect(coerceFieldValue(f, "pending")).toEqual({
-        ok: false,
-        error: 'field "status" must be one of [confirmed cancelled]',
-      });
-    });
-  });
-
-  describe("integer", () => {
-    it("accepts integral numbers", () => {
-      expect(coerceFieldValue(field({ type: FieldType.integer }), 42)).toEqual({
-        ok: true,
-        value: 42,
-      });
-      expect(coerceFieldValue(field({ type: FieldType.integer }), -7)).toEqual({
-        ok: true,
-        value: -7,
-      });
-      expect(coerceFieldValue(field({ type: FieldType.integer }), 0)).toEqual({
-        ok: true,
-        value: 0,
-      });
-    });
-
-    it("rejects fractional, non-numeric, and unsafe values", () => {
-      const f = field({ name: "n", type: FieldType.integer });
-      expect(coerceFieldValue(f, 1.5)).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "3")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, Number.MAX_SAFE_INTEGER + 2)).toMatchObject({ ok: false });
-    });
-  });
-
-  describe("number", () => {
-    it("accepts finite numbers", () => {
-      expect(coerceFieldValue(field({ type: FieldType.number }), 3.14)).toEqual({
-        ok: true,
-        value: 3.14,
-      });
-    });
-
-    it("rejects non-numbers and non-finite values", () => {
-      const f = field({ name: "n", type: FieldType.number });
-      expect(coerceFieldValue(f, "3.14")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, Number.POSITIVE_INFINITY)).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, Number.NaN)).toMatchObject({ ok: false });
-    });
-  });
-
-  describe("bool", () => {
-    it("accepts booleans and rejects everything else", () => {
-      const f = field({ name: "b", type: FieldType.bool });
-      expect(coerceFieldValue(f, true)).toEqual({ ok: true, value: true });
-      expect(coerceFieldValue(f, false)).toEqual({ ok: true, value: false });
-      expect(coerceFieldValue(f, "true")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, 1)).toMatchObject({ ok: false });
-    });
-  });
-
-  describe("timestamp", () => {
-    const f = field({ name: "at", type: FieldType.timestamp });
-
-    it("accepts RFC 3339 UTC and offset forms", () => {
-      expect(coerceFieldValue(f, "2026-07-21T04:30:00Z")).toEqual({
-        ok: true,
-        value: "2026-07-21T04:30:00Z",
-      });
-      expect(coerceFieldValue(f, "2026-07-21T04:30:00.123Z")).toMatchObject({ ok: true });
-      expect(coerceFieldValue(f, "2026-07-21T10:00:00+05:30")).toMatchObject({ ok: true });
-    });
-
-    it("rejects date-only, missing zone, and garbage", () => {
-      expect(coerceFieldValue(f, "2026-07-21")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "2026-07-21T04:30:00")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "yesterday")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, 1721536200)).toMatchObject({ ok: false });
-    });
-  });
-
-  describe("date", () => {
-    const f = field({ name: "day", type: FieldType.date });
-
-    it("accepts valid YYYY-MM-DD", () => {
-      expect(coerceFieldValue(f, "2026-07-21")).toEqual({ ok: true, value: "2026-07-21" });
-      expect(coerceFieldValue(f, "2024-02-29")).toMatchObject({ ok: true }); // leap day
-    });
-
-    it("rejects impossible dates and other shapes", () => {
-      expect(coerceFieldValue(f, "2026-02-30")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "2026-13-01")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "2023-02-29")).toMatchObject({ ok: false }); // not a leap year
-      expect(coerceFieldValue(f, "21-07-2026")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "2026-7-1")).toMatchObject({ ok: false }); // unpadded
-    });
-  });
-
-  describe("time", () => {
-    const f = field({ name: "slot", type: FieldType.time });
-
-    it("canonicalizes HH:MM to HH:MM:SS", () => {
-      expect(coerceFieldValue(f, "09:30")).toEqual({ ok: true, value: "09:30:00" });
-    });
-
-    it("passes HH:MM:SS through", () => {
-      expect(coerceFieldValue(f, "23:59:59")).toEqual({ ok: true, value: "23:59:59" });
-    });
-
-    it("rejects unpadded, out-of-range, and garbage input", () => {
-      expect(coerceFieldValue(f, "9:30")).toMatchObject({ ok: false }); // unpadded
-      expect(coerceFieldValue(f, "24:00")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "12:60")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "12:00:60")).toMatchObject({ ok: false });
-      expect(coerceFieldValue(f, "noon")).toMatchObject({ ok: false });
-    });
-  });
-
-  describe("json", () => {
-    it("passes any JSON value through untouched", () => {
-      const f = field({ type: FieldType.json });
-      const nested = { a: [1, "two", { three: true }] };
-      expect(coerceFieldValue(f, nested)).toEqual({ ok: true, value: nested });
-      expect(coerceFieldValue(f, [1, 2])).toMatchObject({ ok: true });
-      expect(coerceFieldValue(f, "plain")).toMatchObject({ ok: true });
-    });
-  });
-
-  it("rejects unspecified field types", () => {
-    expect(
-      coerceFieldValue(field({ type: FieldType.field_type_unspecified }), "x"),
-    ).toMatchObject({ ok: false });
-  });
-});
-
-describe("formatFieldValue", () => {
-  it("renders null/undefined as empty", () => {
-    expect(formatFieldValue(FieldType.string, null)).toBe("");
-    expect(formatFieldValue(FieldType.integer, undefined)).toBe("");
-  });
-
-  it("trims the stored timestamp's zero fraction", () => {
-    expect(formatFieldValue(FieldType.timestamp, "2026-07-21T04:30:00.000000000Z")).toBe(
-      "2026-07-21T04:30:00Z",
-    );
-    // Non-zero fractions carry information and stay.
-    expect(formatFieldValue(FieldType.timestamp, "2026-07-21T04:30:00.500000000Z")).toBe(
-      "2026-07-21T04:30:00.500000000Z",
-    );
-  });
-
-  it("stringifies json values compactly", () => {
-    expect(formatFieldValue(FieldType.json, { a: 1 })).toBe('{"a":1}');
-  });
-
-  it("renders scalars canonically", () => {
-    expect(formatFieldValue(FieldType.bool, true)).toBe("true");
-    expect(formatFieldValue(FieldType.integer, 42)).toBe("42");
-    expect(formatFieldValue(FieldType.date, "2026-07-21")).toBe("2026-07-21");
-  });
-
-  it("formats system timestamps the same way", () => {
-    expect(formatSystemTimestamp("2026-07-21T04:30:00.000000000Z")).toBe(
-      "2026-07-21T04:30:00Z",
-    );
-  });
-});
-
-describe("operator matrix", () => {
-  it("string fields get equality operators", () => {
-    expect(operatorsForField(field({ type: FieldType.string, required: true }))).toEqual([
-      RecordConditionOp.eq,
-      RecordConditionOp.neq,
-      RecordConditionOp.is_in,
-      RecordConditionOp.not_in,
-    ]);
-  });
-
-  it("bool fields get eq/neq only", () => {
-    expect(operatorsForField(field({ type: FieldType.bool, required: true }))).toEqual([
-      RecordConditionOp.eq,
-      RecordConditionOp.neq,
-    ]);
-  });
-
-  it("numeric and temporal fields get range operators", () => {
-    for (const type of [
-      FieldType.integer,
-      FieldType.number,
-      FieldType.timestamp,
-      FieldType.date,
-      FieldType.time,
-    ]) {
-      expect(operatorsForField(field({ type, required: true }))).toEqual([
-        RecordConditionOp.eq,
-        RecordConditionOp.neq,
-        RecordConditionOp.gt,
-        RecordConditionOp.gte,
-        RecordConditionOp.lt,
-        RecordConditionOp.lte,
-      ]);
-    }
-  });
-
-  it("json fields are not filterable — even optional ones get no null tests", () => {
-    expect(operatorsForField(field({ type: FieldType.json }))).toEqual([]);
-  });
-
-  it("optional fields additionally get null tests", () => {
-    const ops = operatorsForField(field({ type: FieldType.string, required: false }));
-    expect(ops).toContain(RecordConditionOp.is_null);
-    expect(ops).toContain(RecordConditionOp.not_null);
-  });
-
-  it("required fields never get null tests", () => {
-    const ops = operatorsForField(field({ type: FieldType.string, required: true }));
-    expect(ops).not.toContain(RecordConditionOp.is_null);
-    expect(ops).not.toContain(RecordConditionOp.not_null);
-  });
-
-  it("system fields mirror the server matrix", () => {
-    expect(SYSTEM_FIELD_OPERATORS.get("id")).toEqual([
-      RecordConditionOp.eq,
-      RecordConditionOp.is_in,
-    ]);
-    expect(SYSTEM_FIELD_OPERATORS.get("created_at")).toEqual([
-      RecordConditionOp.gt,
-      RecordConditionOp.gte,
-      RecordConditionOp.lt,
-      RecordConditionOp.lte,
-    ]);
-    expect(SYSTEM_FIELD_OPERATORS.get("updated_at")).toEqual(
-      SYSTEM_FIELD_OPERATORS.get("created_at"),
-    );
-    // Not filterable: attribution and ambient scope.
-    expect(SYSTEM_FIELD_OPERATORS.has("created_by")).toBe(false);
-    expect(SYSTEM_FIELD_OPERATORS.has("org")).toBe(false);
-    expect(SYSTEM_FIELD_OPERATORS.has("partition")).toBe(false);
-  });
-
-  it("classifies operator arity", () => {
-    expect(isValuelessOperator(RecordConditionOp.is_null)).toBe(true);
-    expect(isValuelessOperator(RecordConditionOp.not_null)).toBe(true);
-    expect(isValuelessOperator(RecordConditionOp.eq)).toBe(false);
-    expect(isListOperator(RecordConditionOp.is_in)).toBe(true);
-    expect(isListOperator(RecordConditionOp.not_in)).toBe(true);
-    expect(isListOperator(RecordConditionOp.eq)).toBe(false);
-  });
-});
-
-describe("isSortableField", () => {
-  it("declared non-json fields sort; json does not", () => {
-    expect(isSortableField(field({ type: FieldType.date }))).toBe(true);
-    expect(isSortableField(field({ type: FieldType.string }))).toBe(true);
-    expect(isSortableField(field({ type: FieldType.json }))).toBe(false);
-    expect(isSortableField(field({ type: FieldType.field_type_unspecified }))).toBe(false);
-  });
-});
-
-describe("buildUpdateFields", () => {
-  it("carries dirty values and explicit nulls, omits untouched fields", () => {
-    const payload = buildUpdateFields(
-      new Map<string, string | null>([
-        ["patient_phone", "+15550100"],
-        ["notes", null],
-      ]),
-    );
-    expect(payload).toEqual({ patient_phone: "+15550100", notes: null });
-    expect("slot_time" in payload).toBe(false);
-  });
-
-  it("produces an empty object for no edits", () => {
-    expect(buildUpdateFields(new Map())).toEqual({});
-  });
-});
-
-describe("RESERVED_FIELD_NAMES", () => {
-  it("matches the server's reserved set", () => {
-    expect([...RESERVED_FIELD_NAMES].sort()).toEqual([
-      "created_at",
-      "created_by",
-      "id",
-      "org",
-      "partition",
-      "updated_at",
-    ]);
-  });
-});

package/src/datastore/__tests__/schemaAndSyncViews.test.tsx

@@ -1,142 +0,0 @@
-// Render tests for the two Overview views: the schema view (spec for
-// structure — fields, constraints with authored messages, authorization
-// summary) and the sync report (status for health).
-
-import { describe, it, expect, afterEach } from "vitest";
-import { render, screen, cleanup } from "@testing-library/react";
-import { create } from "@bufbuild/protobuf";
-import {
-  DatastoreSpecSchema,
-  FieldType,
-} from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/spec_pb";
-import {
-  CollectionMaterializationState,
-  DatastoreStatusSchema,
-  DatastoreSyncOutcome,
-} from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/status_pb";
-import { CollectionSchemaView, formatSubject } from "../CollectionSchemaView";
-import { DatastoreSyncReport } from "../DatastoreSyncReport";
-
-afterEach(() => cleanup());
-
-describe("CollectionSchemaView", () => {
-  const spec = create(DatastoreSpecSchema, {
-    timezone: "Asia/Kolkata",
-    authorization: {
-      roles: [{ name: "admin" }, { name: "patient" }],
-      defaultRole: "patient",
-      bindings: [
-        {
-          subject: {
-            kind: { case: "channelSender", value: { senderKind: "whatsapp", value: "+15550100" } },
-          },
-          role: "admin",
-        },
-      ],
-    },
-    collections: [
-      {
-        name: "bookings",
-        description: "Confirmed appointments",
-        fields: [
-          { name: "slot_date", type: FieldType.date, required: true },
-          {
-            name: "status",
-            type: FieldType.string,
-            enumValues: ["confirmed", "cancelled"],
-            description: "Booking lifecycle",
-          },
-        ],
-        uniques: [
-          {
-            name: "one_confirmed_per_slot",
-            fields: ["slot_date"],
-            message: "that slot is already booked",
-          },
-        ],
-      },
-    ],
-  });
-
-  it("renders fields, enum values, and required markers", () => {
-    render(<CollectionSchemaView spec={spec} />);
-    expect(screen.getByText("slot_date")).toBeTruthy();
-    expect(screen.getByText(/confirmed \| cancelled/)).toBeTruthy();
-    expect(screen.getByText("Booking lifecycle")).toBeTruthy();
-  });
-
-  it("renders constraints with the operator's authored message verbatim", () => {
-    render(<CollectionSchemaView spec={spec} />);
-    expect(screen.getByText("one_confirmed_per_slot")).toBeTruthy();
-    expect(screen.getByText(/that slot is already booked/)).toBeTruthy();
-  });
-
-  it("summarizes the authorization block: roles, bindings, default_role, timezone", () => {
-    render(<CollectionSchemaView spec={spec} />);
-    // "admin" appears as a role chip and as the binding's role.
-    expect(screen.getAllByText("admin").length).toBeGreaterThan(0);
-    // "patient" appears as a role chip and as the default_role chip.
-    expect(screen.getAllByText("patient").length).toBeGreaterThan(0);
-    expect(screen.getByText("whatsapp:+15550100")).toBeTruthy();
-    expect(screen.getByText("Asia/Kolkata")).toBeTruthy();
-  });
-
-  it("states the deny-by-default posture when no default_role is set", () => {
-    const noDefault = create(DatastoreSpecSchema, {
-      authorization: { roles: [{ name: "admin" }] },
-      collections: [{ name: "c", fields: [{ name: "f", type: FieldType.string }] }],
-    });
-    render(<CollectionSchemaView spec={noDefault} />);
-    expect(screen.getByText(/unbound callers are denied/)).toBeTruthy();
-  });
-});
-
-describe("formatSubject", () => {
-  it("renders channel senders and principals plainly", () => {
-    expect(
-      formatSubject({
-        kind: { case: "channelSender", value: { senderKind: "whatsapp", value: "+1" } },
-      } as never),
-    ).toBe("whatsapp:+1");
-    expect(
-      formatSubject({
-        kind: { case: "principal", value: { kind: "identity_account", id: "ida_1" } },
-      } as never),
-    ).toBe("identity_account/ida_1");
-    expect(formatSubject(undefined)).toBe("unknown");
-  });
-});
-
-describe("DatastoreSyncReport", () => {
-  it("renders the outcome badge and per-collection counts", () => {
-    const status = create(DatastoreStatusSchema, {
-      lastSyncOutcome: DatastoreSyncOutcome.synced,
-      collections: [
-        {
-          name: "bookings",
-          state: CollectionMaterializationState.active,
-          recordCount: 214n,
-        },
-        {
-          name: "old_notes",
-          state: CollectionMaterializationState.removed,
-          recordCount: 3n,
-        },
-      ],
-    });
-    render(<DatastoreSyncReport status={status} />);
-    expect(screen.getByText("synced")).toBeTruthy();
-    expect(screen.getByText("214")).toBeTruthy();
-    expect(screen.getByText("active")).toBeTruthy();
-    expect(screen.getByText("removed")).toBeTruthy();
-  });
-
-  it("renders the rejected outcome", () => {
-    const status = create(DatastoreStatusSchema, {
-      lastSyncOutcome: DatastoreSyncOutcome.rejected,
-    });
-    render(<DatastoreSyncReport status={status} />);
-    expect(screen.getByText("rejected")).toBeTruthy();
-    expect(screen.getByText(/No collections have been synced yet/)).toBeTruthy();
-  });
-});

package/src/datastore/__tests__/useDatastoreDescription.test.tsx

@@ -1,143 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { renderHook, waitFor } from "@testing-library/react";
-import type { ReactNode } from "react";
-import { create } from "@bufbuild/protobuf";
-import { DatastoreDescriptionSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_io_pb";
-import { StigmerContext } from "../../context";
-import { FetchCacheContext } from "../../internal/FetchCacheProvider";
-import { useDatastoreDescription } from "../useDatastoreDescription";
-
-function createMockStigmer(overrides: {
-  describeDatastore?: (...args: unknown[]) => Promise<unknown>;
-} = {}) {
-  return {
-    datastore: {
-      describeDatastore:
-        overrides.describeDatastore ?? vi.fn().mockResolvedValue(null),
-    },
-  } as never;
-}
-
-function wrapper(client: unknown) {
-  return function Wrapper({ children }: { children: ReactNode }) {
-    return (
-      <FetchCacheContext.Provider value={null}>
-        <StigmerContext.Provider value={client as never}>
-          {children}
-        </StigmerContext.Provider>
-      </FetchCacheContext.Provider>
-    );
-  };
-}
-
-describe("useDatastoreDescription", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("fetches the description and passes org + datastore through", async () => {
-    const description = create(DatastoreDescriptionSchema, {
-      datastore: "clinic",
-      partitions: ["default", "dr-alt"],
-    });
-    const describeDatastore = vi.fn().mockResolvedValue(description);
-    const client = createMockStigmer({ describeDatastore });
-
-    const { result } = renderHook(() => useDatastoreDescription("acme", "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-
-    expect(result.current.description).toBe(description);
-    expect(describeDatastore).toHaveBeenCalledWith(
-      expect.objectContaining({ org: "acme", datastore: "clinic" }),
-    );
-  });
-
-  it("always offers the default partition even when the catalog is empty", async () => {
-    // The catalog materializes with the first record write; an empty
-    // datastore reports no partitions but "default" is always addressable.
-    const description = create(DatastoreDescriptionSchema, {
-      datastore: "clinic",
-      partitions: [],
-    });
-    const client = createMockStigmer({
-      describeDatastore: vi.fn().mockResolvedValue(description),
-    });
-
-    const { result } = renderHook(() => useDatastoreDescription("acme", "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-    expect(result.current.partitions).toEqual(["default"]);
-  });
-
-  it("prepends default when the catalog holds only named partitions", async () => {
-    const description = create(DatastoreDescriptionSchema, {
-      datastore: "clinic",
-      partitions: ["dr-alt"],
-    });
-    const client = createMockStigmer({
-      describeDatastore: vi.fn().mockResolvedValue(description),
-    });
-
-    const { result } = renderHook(() => useDatastoreDescription("acme", "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-    expect(result.current.partitions).toEqual(["default", "dr-alt"]);
-  });
-
-  it("does not duplicate default when the catalog already carries it", async () => {
-    const description = create(DatastoreDescriptionSchema, {
-      datastore: "clinic",
-      partitions: ["default", "dr-alt"],
-    });
-    const client = createMockStigmer({
-      describeDatastore: vi.fn().mockResolvedValue(description),
-    });
-
-    const { result } = renderHook(() => useDatastoreDescription("acme", "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-    expect(result.current.partitions).toEqual(["default", "dr-alt"]);
-  });
-
-  it("skips fetching when org or datastore is null", () => {
-    const describeDatastore = vi.fn();
-    const client = createMockStigmer({ describeDatastore });
-
-    const { result } = renderHook(() => useDatastoreDescription(null, "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.description).toBeNull();
-    expect(result.current.partitions).toEqual(["default"]);
-    expect(describeDatastore).not.toHaveBeenCalled();
-  });
-
-  it("surfaces PERMISSION_DENIED as error — the defensive denied-state branch", async () => {
-    // A reach-level denial must be catchable and rendered as the
-    // Records-tab denied panel, never a page-level failure.
-    const denial = new Error("unauthorized to use records in this datastore");
-    const client = createMockStigmer({
-      describeDatastore: vi.fn().mockRejectedValue(denial),
-    });
-
-    const { result } = renderHook(() => useDatastoreDescription("acme", "clinic"), {
-      wrapper: wrapper(client),
-    });
-
-    await waitFor(() => expect(result.current.isLoading).toBe(false));
-    expect(result.current.error?.message).toBe(
-      "unauthorized to use records in this datastore",
-    );
-    expect(result.current.description).toBeNull();
-  });
-});