@rebasepro/plugin-ai 0.12.1-canary.gf5f1d39 → 0.13.0

package/src/tests/AutofillReviewDialog.test.tsx

@@ -0,0 +1,340 @@
+import { TextEncoder, TextDecoder } from "util";
+Object.assign(global, { TextEncoder,
+TextDecoder });
+
+if (typeof window !== "undefined") {
+    Object.defineProperty(window, "matchMedia", {
+        writable: true,
+        value: jest.fn().mockImplementation(query => ({
+            matches: false,
+            media: query,
+            onchange: null,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            dispatchEvent: jest.fn()
+        }))
+    });
+}
+
+import React from "react";
+import { act, render, screen, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import {
+    DataEnhancementControllerProvider,
+    useDataEnhancementController
+} from "../components/DataEnhancementControllerProvider";
+import { AutofillReviewDialog } from "../components/AutofillReviewDialog";
+import { DataEnhancementController } from "../types/data_enhancement_controller";
+
+/**
+ * The review surface.
+ *
+ * The controller's behaviour is covered in `review.test.tsx`; this is about
+ * what the operator can actually see and press. The two things worth proving
+ * here are that a proposal which would overwrite existing content *says so* —
+ * a review that hides what it is about to destroy is worse than no review — and
+ * that the Apply button's count matches what Apply will really write.
+ */
+
+jest.mock("@rebasepro/admin", () => ({
+    getFieldId: (property: { type?: string }) => (property?.type === "string" ? "text_field" : "number_field")
+}));
+
+const COLLECTION = {
+    name: "Products",
+    singularName: "Product",
+    properties: {
+        title: { type: "string",
+name: "Title" },
+        stock: { type: "number",
+name: "Stock" }
+    }
+} as any;
+
+function streamingResponse(body: string): any {
+    const encoder = new TextEncoder();
+    let sent = false;
+    return {
+        ok: true,
+        status: 200,
+        body: {
+            getReader: () => ({
+                read: async () => {
+                    if (sent) return { done: true,
+value: undefined };
+                    sent = true;
+                    return { done: false,
+value: encoder.encode(body) };
+                }
+            })
+        }
+    };
+}
+
+const FULL_RUN = [
+    'event: suggestion\ndata: {"key":"title","value":"Blue widget"}',
+    'event: suggestion\ndata: {"key":"stock","value":42}',
+    'event: done\ndata: {"suggestions":{"title":"Blue widget","stock":42}}',
+    ""
+].join("\n\n");
+
+function mockService(autofillBody: string | (() => any)) {
+    (global as any).fetch = jest.fn((url: string) => {
+        if (String(url).endsWith("/status")) {
+            return Promise.resolve({ ok: true,
+status: 200,
+json: async () => ({ available: true }) });
+        }
+        if (String(url).endsWith("/autofill")) {
+            return Promise.resolve(typeof autofillBody === "string" ? streamingResponse(autofillBody) : autofillBody());
+        }
+        return Promise.resolve({ ok: true,
+status: 200,
+json: async () => ({ prompts: [] }) });
+    });
+}
+
+let controller: DataEnhancementController;
+
+function Capture() {
+    controller = useDataEnhancementController();
+    return null;
+}
+
+async function mount(formValues: Record<string, unknown> = {}) {
+    const setFieldValue = jest.fn();
+    const formContext = { values: formValues,
+setFieldValue } as any;
+
+    render(
+        <DataEnhancementControllerProvider
+            path={"products"}
+            collection={COLLECTION}
+            formContext={formContext}
+            {...({} as any)}>
+            <Capture/>
+            <AutofillReviewDialog/>
+        </DataEnhancementControllerProvider>
+    );
+
+    // Let the /status probe resolve so the controller reports enabled.
+    await act(async () => {
+        await Promise.resolve();
+    });
+
+    return { setFieldValue };
+}
+
+async function runAutofill(values: Record<string, unknown> = {}) {
+    await act(async () => {
+        await controller.generate({ values });
+    });
+}
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+describe("AutofillReviewDialog", () => {
+
+    it("renders nothing until a run has produced something to review", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        expect(screen.queryByText(/Review autofill/i)).toBeNull();
+    });
+
+    it("lists each proposed field with its label and value", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        await runAutofill();
+
+        expect(screen.getByText("Review autofill")).toBeTruthy();
+        expect(screen.getByText("Title")).toBeTruthy();
+        expect(screen.getByText("Blue widget")).toBeTruthy();
+        expect(screen.getByText("Stock")).toBeTruthy();
+        expect(screen.getByText("42")).toBeTruthy();
+    });
+
+    it("says so when a proposal would overwrite something already written", async () => {
+        // The property that makes this a review rather than a preview. Hiding
+        // what is about to be destroyed is worse than not offering a review.
+        mockService(FULL_RUN);
+        await mount({ title: "Hand grinder" });
+        await runAutofill({ title: "Hand grinder" });
+
+        expect(screen.getAllByText(/replaces the current value/i).length).toBe(1);
+        expect(screen.getByText("Hand grinder")).toBeTruthy();
+    });
+
+    it("does not claim a replacement for a field that was empty", async () => {
+        mockService(FULL_RUN);
+        await mount({ title: "" });
+        await runAutofill({ title: "" });
+
+        expect(screen.queryByText(/replaces the current value/i)).toBeNull();
+    });
+
+    it("counts only the fields Apply will actually write", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        await runAutofill();
+
+        expect(screen.getByRole("button", { name: /Apply 2 fields/i })).toBeTruthy();
+
+        const user = userEvent.setup();
+        const rows = screen.getAllByRole("checkbox");
+        // The first checkbox is "select all"; the next two are the fields.
+        await act(async () => {
+            await user.click(rows[rows.length - 1]);
+        });
+
+        expect(screen.getByRole("button", { name: /Apply 1 field/i })).toBeTruthy();
+    });
+
+    it("writes only the ticked fields when Apply is pressed", async () => {
+        mockService(FULL_RUN);
+        const { setFieldValue } = await mount();
+        await runAutofill();
+
+        const user = userEvent.setup();
+        const boxes = screen.getAllByRole("checkbox");
+        await act(async () => {
+            await user.click(boxes[boxes.length - 1]);
+        });
+        await act(async () => {
+            await user.click(screen.getByRole("button", { name: /Apply 1 field/i }));
+        });
+
+        expect(setFieldValue).toHaveBeenCalledTimes(1);
+        expect(setFieldValue).toHaveBeenCalledWith("title", "Blue widget");
+    });
+
+    it("writes nothing when Discard is pressed, and closes", async () => {
+        mockService(FULL_RUN);
+        const { setFieldValue } = await mount({ title: "Original" });
+        await runAutofill({ title: "Original" });
+
+        const user = userEvent.setup();
+        await act(async () => {
+            await user.click(screen.getByRole("button", { name: /Discard/i }));
+        });
+
+        expect(setFieldValue).not.toHaveBeenCalled();
+        expect(screen.queryByText("Review autofill")).toBeNull();
+    });
+
+    it("disables Apply when nothing is ticked", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        await runAutofill();
+
+        const user = userEvent.setup();
+        await act(async () => {
+            await user.click(screen.getAllByRole("checkbox")[0]);
+        });
+
+        const apply = screen.getByRole("button", { name: /Apply 0 fields/i });
+        expect(apply.hasAttribute("disabled")).toBe(true);
+    });
+
+    it("shows the instruction back to the operator while they review", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        await act(async () => {
+            await controller.generate({ values: {},
+instructions: "A burr grinder for travel" });
+        });
+
+        expect(screen.getByText(/A burr grinder for travel/)).toBeTruthy();
+    });
+
+    it("keeps what arrived when a run fails part-way, and explains", async () => {
+        // A run that produced one good field and then broke should still let
+        // the operator take the one.
+        mockService([
+            'event: suggestion\ndata: {"key":"title","value":"Blue widget"}',
+            'event: error\ndata: {"message":"quota exhausted"}',
+            ""
+        ].join("\n\n"));
+        await mount();
+        await runAutofill();
+
+        expect(screen.getByText(/quota exhausted/)).toBeTruthy();
+        expect(screen.getByText("Blue widget")).toBeTruthy();
+        expect(screen.getByRole("button", { name: /Apply 1 field/i })).toBeTruthy();
+    });
+
+    it("explains an empty result rather than showing a blank dialog", async () => {
+        mockService('event: done\ndata: {"suggestions":{}}\n\n');
+        await mount();
+        await runAutofill();
+
+        expect(screen.getByText(/Nothing to fill in/i)).toBeTruthy();
+        expect(screen.getByRole("button", { name: /Apply 0 fields/i })).toBeTruthy();
+    });
+
+    it("offers select-all only when there is more than one field", async () => {
+        mockService('event: suggestion\ndata: {"key":"title","value":"Only one"}\n\nevent: done\ndata: {"suggestions":{"title":"Only one"}}\n\n');
+        await mount();
+        await runAutofill();
+
+        expect(screen.queryByText(/Select all|Deselect all/i)).toBeNull();
+        expect(screen.getAllByRole("checkbox").length).toBe(1);
+    });
+
+    it("toggles every row at once", async () => {
+        mockService(FULL_RUN);
+        await mount();
+        await runAutofill();
+
+        const user = userEvent.setup();
+        await act(async () => {
+            await user.click(screen.getByText(/Deselect all/i));
+        });
+
+        expect(screen.getByRole("button", { name: /Apply 0 fields/i })).toBeTruthy();
+        expect(screen.getByText(/Select all/i)).toBeTruthy();
+    });
+
+    it("renders a date proposal readably rather than as an ISO string", async () => {
+        const collection = {
+            name: "Posts",
+            singularName: "Post",
+            properties: { publishedAt: { type: "date",
+name: "Published at" } }
+        } as any;
+
+        (global as any).fetch = jest.fn((url: string) => {
+            if (String(url).endsWith("/status")) return Promise.resolve({ ok: true,
+status: 200,
+json: async () => ({ available: true }) });
+            return Promise.resolve(streamingResponse(
+                'event: suggestion\ndata: {"key":"publishedAt","value":"2026-08-03T10:00:00.000Z"}\n\nevent: done\ndata: {"suggestions":{}}\n\n'
+            ));
+        });
+
+        const setFieldValue = jest.fn();
+        render(
+            <DataEnhancementControllerProvider
+                path={"posts"}
+                collection={collection}
+                formContext={{ values: {},
+setFieldValue } as any}
+                {...({} as any)}>
+                <Capture/>
+                <AutofillReviewDialog/>
+            </DataEnhancementControllerProvider>
+        );
+        await act(async () => {
+            await Promise.resolve();
+        });
+        await runAutofill();
+
+        // Not the raw ISO string — the row shows a locale-formatted date, which
+        // is only possible because the controller coerced it to a Date first.
+        expect(screen.queryByText("2026-08-03T10:00:00.000Z")).toBeNull();
+        const row = screen.getByText("Published at").closest("label[class*=\"flex\"]");
+        expect(within(row as HTMLElement).getByText(/2026/)).toBeTruthy();
+    });
+});

package/src/tests/api.test.ts

@@ -0,0 +1,283 @@
+import { TextEncoder, TextDecoder } from "util";
+Object.assign(global, { TextEncoder,
+TextDecoder });
+
+import {
+    DEFAULT_AI_ENDPOINT,
+    autocompleteStream,
+    autofillStream,
+    fetchAiStatus,
+    fetchPromptSuggestions
+} from "../api";
+import { AutofillRequest } from "../types/data_enhancement_controller";
+
+/**
+ * The transport.
+ *
+ * This exists because of what it replaced. The old client split each network
+ * chunk on the literal `"&$# "` and `JSON.parse`d the pieces — so a delimiter
+ * landing across two reads corrupted the parse, and reads land wherever the
+ * network puts them. The central test below therefore re-delivers the same
+ * response one byte at a time and asserts the result is identical to
+ * delivering it whole. Anything that only ever feeds a complete body would
+ * have passed against the old code too.
+ */
+
+/** A `Response` whose body yields exactly the chunks given, in order. */
+function streamingResponse(chunks: string[], ok = true): any {
+    const encoder = new TextEncoder();
+    let i = 0;
+    return {
+        ok,
+        status: ok ? 200 : 500,
+        body: {
+            getReader: () => ({
+                read: async () =>
+                    i < chunks.length
+                        ? { done: false,
+value: encoder.encode(chunks[i++]) }
+                        : { done: true,
+value: undefined }
+            })
+        }
+    };
+}
+
+function jsonResponse(body: unknown, ok = true, status = 200): any {
+    return { ok,
+status,
+json: async () => body };
+}
+
+/** Split a string into fixed-size pieces, to force boundaries anywhere. */
+function chunked(body: string, size: number): string[] {
+    const out: string[] = [];
+    for (let i = 0; i < body.length; i += size) out.push(body.slice(i, i + size));
+    return out;
+}
+
+const REQUEST: AutofillRequest = {
+    entityName: "Product",
+    values: {},
+    properties: { title: { type: "string",
+fieldConfigId: "text_field" } }
+};
+
+const BODY = [
+    "event: suggestion_delta",
+    'data: {"key":"title","text":"Blue "}',
+    "",
+    "event: suggestion_delta",
+    'data: {"key":"title","text":"widget"}',
+    "",
+    "event: suggestion",
+    'data: {"key":"title","value":"Blue widget"}',
+    "",
+    "event: suggestion",
+    'data: {"key":"stock","value":42}',
+    "",
+    "event: done",
+    'data: {"suggestions":{"title":"Blue widget","stock":42},"usage":{"outputTokens":9}}',
+    "",
+    ""
+].join("\n");
+
+async function runAutofill(chunks: string[]) {
+    (global as any).fetch = jest.fn().mockResolvedValue(streamingResponse(chunks));
+    const deltas: [string, string][] = [];
+    const values: [string, unknown][] = [];
+    const result = await autofillStream({
+        request: REQUEST,
+        onDelta: (k, t) => deltas.push([k, t]),
+        onValue: (k, v) => values.push([k, v])
+    });
+    return { deltas,
+values,
+result };
+}
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+describe("autofillStream", () => {
+    it("reads deltas, values and the final result", async () => {
+        const { deltas, values, result } = await runAutofill([BODY]);
+        expect(deltas).toEqual([
+            ["title", "Blue "],
+            ["title", "widget"]
+        ]);
+        expect(values).toEqual([
+            ["title", "Blue widget"],
+            ["stock", 42]
+        ]);
+        expect(result.suggestions).toEqual({ title: "Blue widget",
+stock: 42 });
+        expect(result.usage).toEqual({ outputTokens: 9 });
+    });
+
+    it("produces identical results at every chunk boundary", async () => {
+        const whole = await runAutofill([BODY]);
+        for (let size = 1; size <= BODY.length; size++) {
+            const split = await runAutofill(chunked(BODY, size));
+            expect(split.deltas).toEqual(whole.deltas);
+            expect(split.values).toEqual(whole.values);
+            expect(split.result).toEqual(whole.result);
+        }
+    });
+
+    it("handles CRLF record separators", async () => {
+        // Proxies rewrite line endings, and a four-character separator sliced as
+        // if it were two leaves a stray newline that eats the next `event:`.
+        const { values } = await runAutofill([BODY.replace(/\n/g, "\r\n")]);
+        expect(values).toEqual([
+            ["title", "Blue widget"],
+            ["stock", 42]
+        ]);
+    });
+
+    it("ignores keep-alive comments", async () => {
+        const withComments = ":keep-alive\n\n" + BODY;
+        const { result } = await runAutofill([withComments]);
+        expect(result.suggestions).toEqual({ title: "Blue widget",
+stock: 42 });
+    });
+
+    it("joins a multi-line data field", async () => {
+        const body = 'event: suggestion\ndata: {"key":"body",\ndata: "value":"two lines"}\n\n';
+        const { values } = await runAutofill([body]);
+        expect(values).toEqual([["body", "two lines"]]);
+    });
+
+    it("keeps going past one malformed record", async () => {
+        // A single bad frame must not discard fields that arrived correctly.
+        const body = "event: suggestion\ndata: {not json\n\n" + BODY;
+        const { values } = await runAutofill([body]);
+        expect(values).toEqual([
+            ["title", "Blue widget"],
+            ["stock", 42]
+        ]);
+    });
+
+    it("throws the message carried on an error event", async () => {
+        (global as any).fetch = jest.fn().mockResolvedValue(
+            streamingResponse(['event: error\ndata: {"message":"quota exhausted"}\n\n'])
+        );
+        await expect(
+            autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined })
+        ).rejects.toThrow("quota exhausted");
+    });
+
+    it("surfaces the server's error envelope on a non-2xx", async () => {
+        // `{ error: { message } }` is the control plane's contract. Reading it
+        // is the difference between telling the operator the quota reset time
+        // and telling them "Request failed with status 429".
+        (global as any).fetch = jest.fn().mockResolvedValue(
+            jsonResponse({ error: { message: "The free AI quota for today has been used up.",
+code: "upstream_error" } }, false, 429)
+        );
+        await expect(
+            autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined })
+        ).rejects.toThrow(/quota for today/);
+    });
+
+    it("sends no credentials of any kind", async () => {
+        // The FireCMS-era client sent the tenant's JWT as `Authorization: Basic`
+        // plus a hardcoded `fcms-…` key. No external service could verify the
+        // former, and the latter shipped in the published package.
+        const fetchMock = jest.fn().mockResolvedValue(streamingResponse([BODY]));
+        (global as any).fetch = fetchMock;
+        await autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined });
+        const [, init] = fetchMock.mock.calls[0];
+        expect(init.headers).toEqual({ "Content-Type": "application/json" });
+        expect(JSON.stringify(init)).not.toMatch(/fcms-|Bearer|Basic/);
+    });
+
+    it("posts to the hosted endpoint by default and to an override when given", async () => {
+        const fetchMock = jest.fn().mockResolvedValue(streamingResponse([BODY]));
+        (global as any).fetch = fetchMock;
+
+        await autofillStream({ request: REQUEST,
+onDelta: () => undefined,
+onValue: () => undefined });
+        expect(fetchMock.mock.calls[0][0]).toBe(`${DEFAULT_AI_ENDPOINT}/autofill`);
+
+        await autofillStream({
+            request: REQUEST,
+            endpoint: "https://ai.example.com/",
+            onDelta: () => undefined,
+            onValue: () => undefined
+        });
+        // Trailing slash trimmed — otherwise the override 404s on `//autofill`.
+        expect(fetchMock.mock.calls[1][0]).toBe("https://ai.example.com/autofill");
+    });
+});
+
+describe("autocompleteStream", () => {
+    it("concatenates deltas and returns the full continuation", async () => {
+        const body = [
+            'event: delta\ndata: {"text":"the quick "}',
+            'event: delta\ndata: {"text":"brown fox"}',
+            "event: done\ndata: {}",
+            ""
+        ].join("\n\n");
+        (global as any).fetch = jest.fn().mockResolvedValue(streamingResponse(chunked(body, 7)));
+
+        const seen: string[] = [];
+        const text = await autocompleteStream({
+            textBefore: "I saw ",
+            textAfter: "",
+            onDelta: (t) => seen.push(t)
+        });
+
+        expect(seen.join("")).toBe("the quick brown fox");
+        expect(text).toBe("the quick brown fox");
+    });
+});
+
+describe("fetchAiStatus", () => {
+    it("reports available when the service says so", async () => {
+        (global as any).fetch = jest.fn().mockResolvedValue(
+            jsonResponse({ available: true,
+model: "claude-opus-5",
+features: ["autofill"] })
+        );
+        await expect(fetchAiStatus({})).resolves.toEqual({
+            available: true,
+            model: "claude-opus-5",
+            features: ["autofill"]
+        });
+    });
+
+    it("reports unavailable rather than throwing when the service errors", async () => {
+        // This value decides whether a button renders. Any doubt must resolve to
+        // "no button" — that is the whole fix for the 404-on-click failure.
+        (global as any).fetch = jest.fn().mockResolvedValue(jsonResponse({}, false, 503));
+        await expect(fetchAiStatus({})).resolves.toEqual({ available: false });
+    });
+});
+
+describe("fetchPromptSuggestions", () => {
+    it("maps the service's prompts", async () => {
+        (global as any).fetch = jest.fn().mockResolvedValue(jsonResponse({ prompts: ["A blue widget", "A red one"] }));
+        await expect(fetchPromptSuggestions({ entityName: "Product" })).resolves.toEqual({
+            prompts: [
+                { prompt: "A blue widget",
+type: "sample" },
+                { prompt: "A red one",
+type: "sample" }
+            ]
+        });
+    });
+
+    it("degrades to no suggestions instead of failing the menu", async () => {
+        (global as any).fetch = jest.fn().mockRejectedValue(new Error("offline"));
+        await expect(fetchPromptSuggestions({ entityName: "Product" })).resolves.toEqual({ prompts: [] });
+    });
+});