@stigmer/react 3.11.1-dev.20260812192248 → 3.12.1

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

@@ -1,169 +0,0 @@
-// 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

@@ -1,195 +0,0 @@
-// 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);
-  });
-});