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

package/src/tests/properties.test.ts

@@ -0,0 +1,420 @@
+import { getSimplifiedProperties } from "../utils/properties";
+import { Properties } from "@rebasepro/types";
+
+/**
+ * The schema serializer.
+ *
+ * This is the file that decides *what the model is asked to fill*. The service
+ * builds its JSON schema from whatever comes out of here, so a key this
+ * function drops is a field autofill will never write, silently — no error, no
+ * warning, just a form that stays half empty on exactly the collections that
+ * are most tedious to fill by hand.
+ *
+ * It also has to agree with `flatMapEntityValues` about paths. Properties are
+ * keyed on dotted paths (`seo.title`) and values are flattened onto the same
+ * ones; if the two disagree, the model is told a field exists and shown no
+ * value for it, and cheerfully overwrites what the operator already wrote.
+ *
+ * `getFieldId` is mocked to something deterministic — the real one resolves
+ * against the admin field registry, which is not what is under test here.
+ */
+jest.mock("@rebasepro/admin", () => ({
+    getFieldId: (property: { type?: string; admin?: { markdown?: boolean; multiline?: boolean } }) => {
+        if (!property?.type) return undefined;
+        if (property.type === "string" && property.admin?.markdown) return "markdown";
+        if (property.type === "string" && property.admin?.multiline) return "multiline";
+        if (property.type === "string") return "text_field";
+        if (property.type === "number") return "number_field";
+        if (property.type === "boolean") return "switch";
+        if (property.type === "date") return "date_time";
+        if (property.type === "reference") return "reference";
+        return undefined;
+    }
+}));
+
+describe("getSimplifiedProperties — flat properties", () => {
+
+    it("keys each scalar on its own name", () => {
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            stock: { name: "Stock",
+type: "number" }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+
+        expect(Object.keys(out).sort()).toEqual(["stock", "title"]);
+        expect(out.title).toMatchObject({ name: "Title",
+type: "string",
+fieldConfigId: "text_field" });
+    });
+
+    it("carries the description through, because it is what the model is steered by", () => {
+        const properties = {
+            summary: { name: "Summary",
+type: "string",
+description: "One sentence, no marketing" }
+        } as unknown as Properties;
+
+        expect(getSimplifiedProperties(properties, {}).summary.description).toBe("One sentence, no marketing");
+    });
+
+    it("marks disabled and read-only fields, so the service can refuse to fill them", () => {
+        const properties = {
+            slug: { name: "Slug",
+type: "string",
+admin: { disabled: true } },
+            computed: { name: "Computed",
+type: "string",
+admin: { readOnly: true } },
+            normal: { name: "Normal",
+type: "string" }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+        expect(out.slug.disabled).toBe(true);
+        expect(out.computed.disabled).toBe(true);
+        expect(out.normal.disabled).toBe(false);
+    });
+
+    it("flattens enum values to the ids the model must choose between", () => {
+        const asArray = {
+            status: { name: "Status",
+type: "string",
+enum: [{ id: "draft",
+label: "Draft" }, { id: "live",
+label: "Live" }] }
+        } as unknown as Properties;
+        expect(getSimplifiedProperties(asArray, {}).status.enum).toEqual(["draft", "live"]);
+
+        const asObject = {
+            status: { name: "Status",
+type: "string",
+enum: { draft: "Draft",
+live: "Live" } }
+        } as unknown as Properties;
+        expect(getSimplifiedProperties(asObject, {}).status.enum).toEqual(["draft", "live"]);
+    });
+
+    it("distinguishes markdown and multiline, which change how a suggestion is joined", () => {
+        const properties = {
+            body: { name: "Body",
+type: "string",
+admin: { markdown: true } },
+            notes: { name: "Notes",
+type: "string",
+admin: { multiline: true } }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+        expect(out.body.fieldConfigId).toBe("markdown");
+        expect(out.notes.fieldConfigId).toBe("multiline");
+    });
+
+    it("skips a property builder, which is a function with no schema to read", () => {
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            derived: () => ({ name: "Derived",
+type: "string" })
+        } as unknown as Properties;
+
+        expect(Object.keys(getSimplifiedProperties(properties, {}))).toEqual(["title"]);
+    });
+
+    it("drops a property whose type has no field, rather than throwing", () => {
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            weird: { name: "Weird",
+type: "geopoint" }
+        } as unknown as Properties;
+
+        expect(Object.keys(getSimplifiedProperties(properties, {}))).toEqual(["title"]);
+    });
+
+    it("returns nothing for an absent property map", () => {
+        expect(getSimplifiedProperties(undefined as unknown as Properties, {})).toEqual({});
+    });
+});
+
+describe("getSimplifiedProperties — nested maps", () => {
+
+    it("keys children on the dotted path the values are flattened onto", () => {
+        // The contract with `flatMapEntityValues`. If these disagree the model
+        // is told about `seo.title` and shown a value for `seo`, so it treats
+        // every existing value as absent.
+        const properties = {
+            seo: {
+                name: "SEO",
+                type: "map",
+                properties: {
+                    title: { name: "SEO title",
+type: "string" },
+                    description: { name: "SEO description",
+type: "string" }
+                }
+            }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+
+        expect(Object.keys(out).sort()).toEqual(["seo", "seo.description", "seo.title"]);
+        expect(out["seo.title"]).toMatchObject({ name: "SEO title",
+fieldConfigId: "text_field" });
+        // The container itself is described too, so the model knows the grouping.
+        expect(out.seo).toMatchObject({ type: "map",
+fieldConfigId: "group" });
+    });
+
+    it("nests two levels deep", () => {
+        const properties = {
+            meta: {
+                name: "Meta",
+                type: "map",
+                properties: {
+                    seo: {
+                        name: "SEO",
+                        type: "map",
+                        properties: { title: { name: "Title",
+type: "string" } }
+                    }
+                }
+            }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+        expect(out["meta.seo.title"]).toMatchObject({ name: "Title" });
+    });
+
+    it("omits a map that declares no properties", () => {
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            blob: { name: "Blob",
+type: "map" }
+        } as unknown as Properties;
+
+        expect(Object.keys(getSimplifiedProperties(properties, {}))).toEqual(["title"]);
+    });
+
+    it("omits a map whose children are all unfillable", () => {
+        const properties = {
+            refs: {
+                name: "Refs",
+                type: "map",
+                properties: { point: { name: "Point",
+type: "geopoint" } }
+            }
+        } as unknown as Properties;
+
+        expect(getSimplifiedProperties(properties, {})).toEqual({});
+    });
+});
+
+describe("getSimplifiedProperties — arrays", () => {
+
+    it("describes an array of scalars by its element type", () => {
+        // What lets the service offer `{type: "array", items: {type: "string"}}`
+        // for a tags field rather than skipping it.
+        const properties = {
+            tags: { name: "Tags",
+type: "array",
+of: { name: "Tag",
+type: "string" } }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, {});
+        expect(out.tags).toMatchObject({ type: "array",
+fieldConfigId: "repeat" });
+        expect(out.tags.of).toMatchObject({ type: "string",
+fieldConfigId: "text_field" });
+    });
+
+    it("carries the element's enum, so an array of choices stays constrained", () => {
+        const properties = {
+            categories: {
+                name: "Categories",
+                type: "array",
+                of: { name: "Category",
+type: "string",
+enum: [{ id: "a",
+label: "A" }, { id: "b",
+label: "B" }] }
+            }
+        } as unknown as Properties;
+
+        expect(getSimplifiedProperties(properties, {}).categories.of?.enum).toEqual(["a", "b"]);
+    });
+
+    it("marks a disabled array so the service leaves it alone", () => {
+        const properties = {
+            tags: { name: "Tags",
+type: "array",
+admin: { readOnly: true },
+of: { name: "Tag",
+type: "string" } }
+        } as unknown as Properties;
+
+        expect(getSimplifiedProperties(properties, {}).tags.disabled).toBe(true);
+    });
+
+    it("omits an array with neither `of` nor `oneOf`", () => {
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            mystery: { name: "Mystery",
+type: "array" }
+        } as unknown as Properties;
+
+        expect(Object.keys(getSimplifiedProperties(properties, {}))).toEqual(["title"]);
+    });
+});
+
+describe("getSimplifiedProperties — oneOf blocks", () => {
+
+    const blockProperties = {
+        content: {
+            name: "Content",
+            type: "array",
+            oneOf: {
+                typeField: "type",
+                valueField: "value",
+                properties: {
+                    text: { name: "Text",
+type: "string",
+admin: { markdown: true } },
+                    count: { name: "Count",
+type: "number" }
+                }
+            }
+        }
+    } as unknown as Properties;
+
+    it("describes the available block types when the field is empty", () => {
+        const out = getSimplifiedProperties(blockProperties, {});
+        expect(out.content).toMatchObject({ type: "array",
+fieldConfigId: "block" });
+        expect(Object.keys(out.content.oneOf!.properties).sort()).toEqual(["count", "text"]);
+        expect(out.content.oneOf!.typeField).toBe("type");
+        expect(out.content.oneOf!.valueField).toBe("value");
+    });
+
+    it("expands the blocks that already exist, keyed by index", () => {
+        const values = {
+            content: [
+                { type: "text",
+value: "Hello" },
+                { type: "count",
+value: 3 }
+            ]
+        };
+
+        const out = getSimplifiedProperties(blockProperties, values);
+
+        expect(out["content.0.value"]).toMatchObject({ name: "Text",
+fieldConfigId: "markdown" });
+        expect(out["content.1.value"]).toMatchObject({ name: "Count",
+fieldConfigId: "number_field" });
+    });
+
+    it("skips a block whose declared type is not in the schema", () => {
+        // Data can outlive a schema change. An unknown block must not take the
+        // whole collection's serialization down with it.
+        const values = { content: [{ type: "removed_block",
+value: "x" }] };
+        const out = getSimplifiedProperties(blockProperties, values);
+        expect(out.content).toBeDefined();
+        expect(Object.keys(out).filter((k) => k.startsWith("content."))).toEqual([]);
+    });
+
+    it("skips a null entry in the block list", () => {
+        const values = { content: [null, { type: "text",
+value: "Hi" }] };
+        const out = getSimplifiedProperties(blockProperties, values);
+        expect(out["content.1.value"]).toBeDefined();
+    });
+
+    it("defaults the type and value field names when the schema omits them", () => {
+        const properties = {
+            content: {
+                name: "Content",
+                type: "array",
+                oneOf: { properties: { text: { name: "Text",
+type: "string" } } }
+            }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, { content: [{ type: "text",
+value: "Hi" }] });
+        expect(out["content.0.value"]).toMatchObject({ name: "Text" });
+    });
+});
+
+describe("getSimplifiedProperties — the paths it produces", () => {
+
+    it("agrees with the flattened value paths for every shape at once", () => {
+        // The single assertion that catches a drift between this function and
+        // `flatMapEntityValues`: every leaf key the model is told about must be
+        // one the values can actually be keyed on.
+        const properties = {
+            title: { name: "Title",
+type: "string" },
+            seo: {
+                name: "SEO",
+                type: "map",
+                properties: { title: { name: "SEO title",
+type: "string" } }
+            },
+            tags: { name: "Tags",
+type: "array",
+of: { name: "Tag",
+type: "string" } }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, { title: "T",
+seo: { title: "S" } });
+
+        expect(Object.keys(out).sort()).toEqual(["seo", "seo.title", "tags", "title"]);
+        for (const key of Object.keys(out)) {
+            expect(key).toMatch(/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/);
+        }
+    });
+});
+
+describe("getSimplifiedProperties — a known wart", () => {
+
+    it("emits the block's type discriminator as a bare string, not a property", () => {
+        // Pinned rather than fixed, because it is pre-existing and harmless in
+        // effect — but it *is* malformed: the return type says
+        // `Record<string, InputProperty>` and this entry is the raw string
+        // `"text"`. It reaches the service, which skips it via an explicit
+        // `typeof property !== "object"` guard in `planFill` (see the matching
+        // test in saas/backend/functions/ai.test.ts).
+        //
+        // If that guard is ever removed, `property.disabled` and `property.type`
+        // read `undefined` off a string and the key is dropped anyway — so the
+        // worst case is noise on the wire rather than a bad schema. Fixing it
+        // means deciding whether the model benefits from knowing a block's type,
+        // which is a behaviour change, not a cleanup.
+        const properties = {
+            content: {
+                name: "Content",
+                type: "array",
+                oneOf: { properties: { text: { name: "Text",
+type: "string" } } }
+            }
+        } as unknown as Properties;
+
+        const out = getSimplifiedProperties(properties, { content: [{ type: "text",
+value: "Hi" }] });
+
+        expect(Object.keys(out)).toContain("content.0.type");
+        expect(typeof out["content.0.type"]).toBe("string");
+        expect(out["content.0.type"] as unknown).toBe("text");
+        // The entry that carries real schema is the value one, and it is correct.
+        expect(out["content.0.value"]).toMatchObject({ name: "Text",
+type: "string" });
+    });
+});

package/src/tests/review.test.tsx

@@ -258,3 +258,136 @@ describe("autofill review", () => {
         expect(result.current.review).toBeNull();
     });
 });
+
+describe("autofill review — runs that overlap or are abandoned", () => {
+
+    it("does not write into a review the operator already dismissed", async () => {
+        // Closing the dialog mid-generation must not leave late frames landing
+        // in a review that is no longer on screen.
+        mockService(() => streamingResponse([AUTOFILL_BODY]));
+        const { result, setFieldValue } = await mountController();
+        await waitFor(() => expect(result.current.enabled).toBe(true));
+
+        let pending: Promise<void>;
+        act(() => {
+            pending = result.current.generate({ values: {} });
+        });
+        act(() => result.current.dismissReview());
+        await act(async () => {
+            await pending!;
+        });
+
+        expect(result.current.review).toBeNull();
+        expect(setFieldValue).not.toHaveBeenCalled();
+    });
+
+    it("does not let an earlier run's fields leak into a later one", async () => {
+        // Two clicks in quick succession. The first run's frames must not
+        // appear in the second run's review — the operator would be reviewing
+        // proposals for an instruction they replaced.
+        const first = [
+            'event: suggestion\ndata: {"key":"title","value":"FIRST RUN"}',
+            'event: done\ndata: {"suggestions":{"title":"FIRST RUN"}}',
+            ""
+        ].join("\n\n");
+        const second = [
+            'event: suggestion\ndata: {"key":"stock","value":7}',
+            'event: done\ndata: {"suggestions":{"stock":7}}',
+            ""
+        ].join("\n\n");
+
+        let call = 0;
+        (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(streamingResponse([call++ === 0 ? first : second]));
+            }
+            return Promise.resolve({ ok: true,
+status: 200,
+json: async () => ({ prompts: [] }) });
+        });
+
+        const { result } = await mountController();
+        await waitFor(() => expect(result.current.enabled).toBe(true));
+
+        await act(async () => {
+            await result.current.generate({ values: {} });
+        });
+        await act(async () => {
+            await result.current.generate({ values: {} });
+        });
+
+        const keys = result.current.review?.fields.map(f => f.key);
+        expect(keys).toEqual(["stock"]);
+        expect(JSON.stringify(result.current.review)).not.toMatch(/FIRST RUN/);
+    });
+
+    it("applies only the fields that finished, if applied mid-stream", async () => {
+        // The Apply button counts non-pending rows; applying must honour the
+        // same rule, or a half-written sentence lands in the record.
+        mockService(() => streamingResponse([
+            'event: suggestion_delta\ndata: {"key":"title","text":"half a sen"}\n\n' +
+            'event: suggestion\ndata: {"key":"stock","value":9}\n\n'
+        ]));
+        const { result, setFieldValue } = await mountController();
+        await waitFor(() => expect(result.current.enabled).toBe(true));
+
+        await act(async () => {
+            await result.current.generate({ values: {} });
+        });
+
+        // The stream ended without completing `title`, so it is dropped rather
+        // than offered — the only thing held for it is a half-written sentence.
+        expect(result.current.review?.fields.map(f => f.key)).toEqual(["stock"]);
+
+        act(() => result.current.applyReview());
+
+        expect(setFieldValue).toHaveBeenCalledTimes(1);
+        expect(setFieldValue).toHaveBeenCalledWith("stock", 9);
+    });
+
+    it("drops a date the model returned as unparseable rather than storing NaN", 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":"not a date"}\n\nevent: done\ndata: {"suggestions":{}}\n\n'
+            ]));
+        });
+
+        const setFieldValue = jest.fn();
+        const wrapper = ({ children }: { children: React.ReactNode }) => (
+            <DataEnhancementControllerProvider
+                path={"posts"}
+                collection={collection}
+                formContext={{ values: {},
+setFieldValue } as any}
+                {...({} as any)}>
+                {children}
+            </DataEnhancementControllerProvider>
+        );
+        const { result } = renderHook(() => useDataEnhancementController(), { wrapper });
+        await waitFor(() => expect(result.current.enabled).toBe(true));
+
+        await act(async () => {
+            await result.current.generate({ values: {} });
+        });
+        act(() => result.current.applyReview());
+
+        expect(setFieldValue).not.toHaveBeenCalled();
+    });
+});

package/src/tests/useEditorAIController.test.ts

@@ -0,0 +1,98 @@
+import { TextEncoder, TextDecoder } from "util";
+Object.assign(global, { TextEncoder,
+TextDecoder });
+
+import { renderHook } from "@testing-library/react";
+import { useEditorAIController } from "../editor/useEditorAIController";
+
+/**
+ * The editor's inline continuation.
+ *
+ * Small, but it was the FireCMS-era code that demanded a Firebase ID token and
+ * threw `"Firebase token is required"` without one — in a Rebase app there is
+ * no such thing. The property worth pinning is that it now needs no token at
+ * all, and that its streamed deltas reach the editor in order.
+ */
+jest.mock("@rebasepro/admin", () => ({}));
+
+function streamingResponse(chunks: string[]): any {
+    const encoder = new TextEncoder();
+    let i = 0;
+    return {
+        ok: true,
+        status: 200,
+        body: {
+            getReader: () => ({
+                read: async () => i < chunks.length
+                    ? { done: false,
+value: encoder.encode(chunks[i++]) }
+                    : { done: true,
+value: undefined }
+            })
+        }
+    };
+}
+
+afterEach(() => jest.restoreAllMocks());
+
+describe("useEditorAIController", () => {
+
+    it("streams deltas in order and resolves with the whole continuation", async () => {
+        (global as any).fetch = jest.fn().mockResolvedValue(streamingResponse([
+            'event: delta\ndata: {"text":"made of "}\n\n',
+            'event: delta\ndata: {"text":"stainless steel"}\n\n',
+            "event: done\ndata: {}\n\n"
+        ]));
+
+        const { result } = renderHook(() => useEditorAIController());
+        const seen: string[] = [];
+        const text = await result.current.autocomplete("The burrs are ", " Ships worldwide.", d => seen.push(d));
+
+        expect(seen).toEqual(["made of ", "stainless steel"]);
+        expect(text).toBe("made of stainless steel");
+    });
+
+    it("needs no auth token — it does not send one, and does not demand one", async () => {
+        const fetchMock = jest.fn().mockResolvedValue(streamingResponse(["event: done\ndata: {}\n\n"]));
+        (global as any).fetch = fetchMock;
+
+        const { result } = renderHook(() => useEditorAIController());
+        await expect(result.current.autocomplete("a", "b", () => undefined)).resolves.toBe("");
+
+        const [, init] = fetchMock.mock.calls[0];
+        expect(init.headers).toEqual({ "Content-Type": "application/json" });
+        expect(JSON.stringify(init)).not.toMatch(/Bearer|Basic|token/i);
+    });
+
+    it("sends the caret context the editor gave it", async () => {
+        const fetchMock = jest.fn().mockResolvedValue(streamingResponse(["event: done\ndata: {}\n\n"]));
+        (global as any).fetch = fetchMock;
+
+        const { result } = renderHook(() => useEditorAIController());
+        await result.current.autocomplete("before", "after", () => undefined);
+
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ textBefore: "before",
+textAfter: "after" });
+    });
+
+    it("honours a custom endpoint, so a self-hoster can proxy it", async () => {
+        const fetchMock = jest.fn().mockResolvedValue(streamingResponse(["event: done\ndata: {}\n\n"]));
+        (global as any).fetch = fetchMock;
+
+        const { result } = renderHook(() => useEditorAIController({ endpoint: "https://ai.example.com" }));
+        await result.current.autocomplete("a", "b", () => undefined);
+
+        expect(fetchMock.mock.calls[0][0]).toBe("https://ai.example.com/autocomplete");
+    });
+
+    it("surfaces the service's message when it refuses", async () => {
+        (global as any).fetch = jest.fn().mockResolvedValue({
+            ok: false,
+            status: 429,
+            json: async () => ({ error: { message: "The free AI quota for today has been used up." } })
+        });
+
+        const { result } = renderHook(() => useEditorAIController());
+        await expect(result.current.autocomplete("a", "b", () => undefined)).rejects.toThrow(/quota for today/);
+    });
+});