@stigmer/react 3.2.3 → 3.4.0

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

@@ -0,0 +1,169 @@
+// Tests for the records-specific filter model — typed 1:1 against
+// RecordConditionOp, structurally unable to express anything
+// findRecords cannot serve (DD-008 invariant 2).
+
+import { describe, expect, it } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import {
+  CollectionDeclarationSchema,
+  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 {
+  buildRecordFilter,
+  filterableFields,
+  formatConditionChip,
+  isConditionComplete,
+} from "../recordFilter.js";
+
+const COLLECTION = create(CollectionDeclarationSchema, {
+  name: "bookings",
+  fields: [
+    { name: "slot_date", type: FieldType.date, required: true },
+    { name: "status", type: FieldType.string, enumValues: ["confirmed", "cancelled"] },
+    { name: "notes", type: FieldType.json },
+  ],
+});
+
+describe("filterableFields", () => {
+  it("offers declared filterable fields plus the filterable system fields", () => {
+    const names = filterableFields(COLLECTION).map((f) => f.name);
+    expect(names).toEqual(["slot_date", "status", "id", "created_at", "updated_at"]);
+  });
+
+  it("excludes json fields — not filterable", () => {
+    const names = filterableFields(COLLECTION).map((f) => f.name);
+    expect(names).not.toContain("notes");
+  });
+
+  it("system fields carry the server's operator sets", () => {
+    const fields = filterableFields(COLLECTION);
+    const id = fields.find((f) => f.name === "id")!;
+    expect(id.operators).toEqual([RecordConditionOp.eq, RecordConditionOp.is_in]);
+    const createdAt = fields.find((f) => f.name === "created_at")!;
+    expect(createdAt.operators).toEqual([
+      RecordConditionOp.gt,
+      RecordConditionOp.gte,
+      RecordConditionOp.lt,
+      RecordConditionOp.lte,
+    ]);
+  });
+
+  it("required fields get no null tests; optional ones do", () => {
+    const fields = filterableFields(COLLECTION);
+    const slotDate = fields.find((f) => f.name === "slot_date")!;
+    expect(slotDate.operators).not.toContain(RecordConditionOp.is_null);
+    const status = fields.find((f) => f.name === "status")!;
+    expect(status.operators).toContain(RecordConditionOp.is_null);
+  });
+
+  it("narrows to the caller's readable fields; system fields stay offered", () => {
+    // A field-restricted read grant: the server refuses conditions on
+    // unreadable fields, so the builder must not offer them.
+    const names = filterableFields(COLLECTION, ["status"]).map((f) => f.name);
+    expect(names).toEqual(["status", "id", "created_at", "updated_at"]);
+  });
+
+  it("empty readable_fields means unrestricted (the proto contract)", () => {
+    expect(filterableFields(COLLECTION, []).map((f) => f.name)).toEqual(
+      filterableFields(COLLECTION).map((f) => f.name),
+    );
+  });
+});
+
+describe("isConditionComplete", () => {
+  it("value-less operators are complete without a value", () => {
+    expect(
+      isConditionComplete({ field: "status", op: RecordConditionOp.is_null }),
+    ).toBe(true);
+  });
+
+  it("scalar operators need a value", () => {
+    expect(isConditionComplete({ field: "status", op: RecordConditionOp.eq })).toBe(false);
+    expect(
+      isConditionComplete({ field: "status", op: RecordConditionOp.eq, value: "confirmed" }),
+    ).toBe(true);
+  });
+
+  it("list operators need at least one value", () => {
+    expect(
+      isConditionComplete({ field: "status", op: RecordConditionOp.is_in, values: [] }),
+    ).toBe(false);
+    expect(
+      isConditionComplete({
+        field: "status",
+        op: RecordConditionOp.is_in,
+        values: ["confirmed"],
+      }),
+    ).toBe(true);
+  });
+
+  it("an unspecified operator is never complete", () => {
+    expect(
+      isConditionComplete({
+        field: "status",
+        op: RecordConditionOp.record_condition_op_unspecified,
+        value: "x",
+      }),
+    ).toBe(false);
+  });
+});
+
+describe("buildRecordFilter", () => {
+  it("returns undefined for no complete conditions (absent filter, not empty)", () => {
+    expect(buildRecordFilter([])).toBeUndefined();
+    expect(
+      buildRecordFilter([{ field: "status", op: RecordConditionOp.eq }]),
+    ).toBeUndefined();
+  });
+
+  it("builds proto conditions with scalar values", () => {
+    const filter = buildRecordFilter([
+      { field: "status", op: RecordConditionOp.eq, value: "confirmed" },
+    ])!;
+    expect(filter.conditions).toHaveLength(1);
+    expect(filter.conditions[0].field).toBe("status");
+    expect(filter.conditions[0].op).toBe(RecordConditionOp.eq);
+    expect(filter.conditions[0].value?.kind).toEqual({
+      case: "stringValue",
+      value: "confirmed",
+    });
+  });
+
+  it("builds list values for is_in", () => {
+    const filter = buildRecordFilter([
+      {
+        field: "status",
+        op: RecordConditionOp.is_in,
+        values: ["confirmed", "cancelled"],
+      },
+    ])!;
+    expect(filter.conditions[0].values).toHaveLength(2);
+  });
+
+  it("leaves the value unset for null tests", () => {
+    const filter = buildRecordFilter([
+      { field: "status", op: RecordConditionOp.not_null },
+    ])!;
+    expect(filter.conditions[0].value).toBeUndefined();
+    expect(filter.conditions[0].values).toHaveLength(0);
+  });
+});
+
+describe("formatConditionChip", () => {
+  it("formats scalar, list, and value-less conditions", () => {
+    expect(
+      formatConditionChip({ field: "status", op: RecordConditionOp.eq, value: "confirmed" }),
+    ).toBe("status = confirmed");
+    expect(
+      formatConditionChip({
+        field: "status",
+        op: RecordConditionOp.not_in,
+        values: ["a", "b"],
+      }),
+    ).toBe("status not in [a, b]");
+    expect(formatConditionChip({ field: "notes", op: RecordConditionOp.is_null })).toBe(
+      "notes is empty",
+    );
+  });
+});

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

@@ -0,0 +1,195 @@
+// Tests for the three record mutation hooks and the guarded datastore
+// delete. Mutations are imperative: the promise carries the result, the
+// hook carries isPending/error, and errors preserve the server's
+// relayable message byte-for-byte.
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { RecordEnvelopeSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/record_io_pb";
+import { StigmerContext } from "../../context";
+import { useInsertRecord } from "../useInsertRecord";
+import { useUpdateRecord } from "../useUpdateRecord";
+import { useDeleteRecord } from "../useDeleteRecord";
+import { useDeleteDatastore } from "../useDeleteDatastore";
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+const SCOPE = { org: "acme", datastore: "clinic", collection: "bookings" } as const;
+
+describe("useInsertRecord", () => {
+  beforeEach(() => vi.restoreAllMocks());
+
+  it("inserts and resolves with the server-stamped envelope", async () => {
+    const stamped = create(RecordEnvelopeSchema, { id: "dsr_new" });
+    const insertRecord = vi.fn().mockResolvedValue(stamped);
+    const client = { datastore: { insertRecord } } as never;
+
+    const { result } = renderHook(() => useInsertRecord(), { wrapper: wrapper(client) });
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.insertRecord({
+        ...SCOPE,
+        record: { slot_date: "2026-07-22", slot_time: "09:30:00" },
+      });
+    });
+
+    expect(returned).toBe(stamped);
+    expect(insertRecord).toHaveBeenCalledWith(
+      expect.objectContaining({
+        org: "acme",
+        datastore: "clinic",
+        collection: "bookings",
+        partition: "",
+        record: { slot_date: "2026-07-22", slot_time: "09:30:00" },
+      }),
+    );
+    expect(result.current.error).toBeNull();
+    expect(result.current.isInserting).toBe(false);
+  });
+
+  it("threads the partition (DD-010)", async () => {
+    const insertRecord = vi.fn().mockResolvedValue(create(RecordEnvelopeSchema, {}));
+    const client = { datastore: { insertRecord } } as never;
+    const { result } = renderHook(() => useInsertRecord(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await result.current.insertRecord({ ...SCOPE, partition: "dr-alt", record: {} });
+    });
+
+    expect(insertRecord).toHaveBeenCalledWith(
+      expect.objectContaining({ partition: "dr-alt" }),
+    );
+  });
+
+  it("preserves the constraint violation's message verbatim and rethrows", async () => {
+    const violation = new Error("that slot is already booked");
+    const client = {
+      datastore: { insertRecord: vi.fn().mockRejectedValue(violation) },
+    } as never;
+    const { result } = renderHook(() => useInsertRecord(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await expect(
+        result.current.insertRecord({ ...SCOPE, record: {} }),
+      ).rejects.toThrow("that slot is already booked");
+    });
+
+    expect(result.current.error?.message).toBe("that slot is already booked");
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+  });
+});
+
+describe("useUpdateRecord", () => {
+  beforeEach(() => vi.restoreAllMocks());
+
+  it("submits the partial-merge payload including explicit nulls", async () => {
+    const updateRecord = vi.fn().mockResolvedValue(create(RecordEnvelopeSchema, {}));
+    const client = { datastore: { updateRecord } } as never;
+    const { result } = renderHook(() => useUpdateRecord(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await result.current.updateRecord({
+        ...SCOPE,
+        id: "dsr_1",
+        fields: { patient_phone: "+15550100", notes: null },
+      });
+    });
+
+    expect(updateRecord).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: "dsr_1",
+        // Tri-state: dirty value + explicit clear travel; untouched
+        // fields are absent from the payload entirely.
+        fields: { patient_phone: "+15550100", notes: null },
+      }),
+    );
+  });
+
+  it("surfaces update denials verbatim", async () => {
+    const denial = new Error("you are not allowed to update records in bookings");
+    const client = {
+      datastore: { updateRecord: vi.fn().mockRejectedValue(denial) },
+    } as never;
+    const { result } = renderHook(() => useUpdateRecord(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await expect(
+        result.current.updateRecord({ ...SCOPE, id: "dsr_1", fields: {} }),
+      ).rejects.toThrow();
+    });
+
+    expect(result.current.error?.message).toBe(
+      "you are not allowed to update records in bookings",
+    );
+  });
+});
+
+describe("useDeleteRecord", () => {
+  beforeEach(() => vi.restoreAllMocks());
+
+  it("deletes by id and resolves with the final envelope", async () => {
+    const last = create(RecordEnvelopeSchema, { id: "dsr_1" });
+    const deleteRecord = vi.fn().mockResolvedValue(last);
+    const client = { datastore: { deleteRecord } } as never;
+    const { result } = renderHook(() => useDeleteRecord(), { wrapper: wrapper(client) });
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.deleteRecord({ ...SCOPE, id: "dsr_1" });
+    });
+
+    expect(returned).toBe(last);
+    expect(deleteRecord).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "dsr_1", collection: "bookings" }),
+    );
+  });
+});
+
+describe("useDeleteDatastore", () => {
+  beforeEach(() => vi.restoreAllMocks());
+
+  it("passes the force acknowledgment through", async () => {
+    const deleted = { metadata: { id: "dst_1" } };
+    const del = vi.fn().mockResolvedValue(deleted);
+    const client = { datastore: { delete: del } } as never;
+    const { result } = renderHook(() => useDeleteDatastore(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await result.current.deleteDatastore({ resourceId: "dst_1", force: true });
+    });
+
+    expect(del).toHaveBeenCalledWith({ resourceId: "dst_1", force: true });
+  });
+
+  it("surfaces guard refusals verbatim — the server stays authoritative", async () => {
+    const guard = new Error(
+      'datastore "clinic" holds 214 records across 2 collections; pass force to acknowledge their destruction',
+    );
+    const client = {
+      datastore: { delete: vi.fn().mockRejectedValue(guard) },
+    } as never;
+    const { result } = renderHook(() => useDeleteDatastore(), { wrapper: wrapper(client) });
+
+    await act(async () => {
+      await expect(
+        result.current.deleteDatastore({ resourceId: "dst_1" }),
+      ).rejects.toThrow();
+    });
+
+    expect(result.current.error?.message).toBe(guard.message);
+    expect(result.current.isDeleting).toBe(false);
+  });
+});