@rebasepro/plugin-ai 0.17.3 → 0.18.0

package/src/tests/properties.test.ts

@@ -1,420 +0,0 @@
-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/cms", () => ({
-    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/request_agreement.test.ts

@@ -1,240 +0,0 @@
-import { Properties } from "@rebasepro/types";
-import { getValueInPath } from "@rebasepro/utils";
-
-import { getSimplifiedProperties } from "../utils/properties";
-import { flatMapEntityValues, omitDisabledValues } from "../utils/values";
-import { InputProperty } from "../types/data_enhancement_controller";
-
-/**
- * The two halves of an autofill request have to be keyed the same way.
- *
- * "Autofill only fills blanks" is not enforced anywhere in this package. It is
- * enforced on the service, by omitting already-filled fields from the JSON
- * schema the model answers into — and the service decides a field is filled by
- * looking up `values[key]` for each `key` of `properties`. So the guard is only
- * as true as the agreement between the two maps this file checks.
- *
- * That is why these tests build *both* maps from one record and then replay the
- * service's own decision over them, rather than testing either map alone. Every
- * assertion here passed against a client that flattened `tags: ["a","b"]` into
- * `tags.0`/`tags.1` and dropped `Date` values entirely — as long as it was the
- * flattener, or the property map, that was looked at in isolation.
- *
- * `getFieldId` is mocked deterministically; the real one resolves against the
- * admin field registry, which is not what is under test.
- */
-jest.mock("@rebasepro/cms", () => ({
-    getFieldId: (property: { type?: string }) => {
-        if (!property?.type) return undefined;
-        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";
-        return undefined;
-    }
-}));
-
-// ---------------------------------------------------------------------------
-// The service's side of the contract, reproduced.
-//
-// Copied from `saas/backend/functions/ai.ts` (`alreadyFilled`, `scalarSchema`,
-// `propertySchema`, `planFill`). It lives in another repository and cannot be
-// imported, so it is mirrored — and mirrored *including* the JSON round trip,
-// because the difference between a `Date` object and the ISO string a `Date`
-// serialises to is exactly the difference between "this field is empty" and
-// "this field is filled" over there.
-// ---------------------------------------------------------------------------
-
-function alreadyFilled(value: unknown): boolean {
-    if (value === null || value === undefined) return false;
-    if (typeof value === "string") return value.trim().length > 0;
-    if (Array.isArray(value)) return value.length > 0;
-    if (typeof value === "object") return Object.keys(value as object).length > 0;
-    return true;
-}
-
-function scalarSchema(property: InputProperty): object | undefined {
-    if (property.enum && property.enum.length > 0) return { type: "string",
-enum: property.enum };
-    switch (property.type) {
-        case "string":
-            return { type: "string" };
-        case "number":
-            return { type: "number" };
-        case "boolean":
-            return { type: "boolean" };
-        case "date":
-            return { type: "string",
-format: "date-time" };
-        default:
-            return undefined;
-    }
-}
-
-function propertySchema(property: InputProperty): object | undefined {
-    if (property.disabled) return undefined;
-    if (property.type === "array") {
-        const items = property.of ? scalarSchema(property.of) : undefined;
-        return items ? { type: "array",
-items } : undefined;
-    }
-    return scalarSchema(property);
-}
-
-/** The keys the service would offer the model, given one request body. */
-function plannedFillKeys(request: { properties: Record<string, InputProperty>, values: Record<string, unknown> }): string[] {
-    // As the service receives it: JSON, not the client's live objects.
-    const values = JSON.parse(JSON.stringify(request.values)) as Record<string, unknown>;
-    return Object.entries(request.properties)
-        .filter(([key, property]) => {
-            if (!property || typeof property !== "object") return false;
-            if (alreadyFilled(values[key])) return false;
-            return Boolean(propertySchema(property));
-        })
-        .map(([key]) => key);
-}
-
-/** What the client puts on the wire, built the way the provider builds it. */
-function requestFor(properties: Properties, record: Record<string, unknown>) {
-    const simplified = getSimplifiedProperties(properties, record);
-    return {
-        properties: simplified,
-        values: omitDisabledValues(flatMapEntityValues(record), simplified)
-    };
-}
-
-const POST_PROPERTIES: Properties = {
-    title: { name: "Title",
-type: "string" },
-    summary: { name: "Summary",
-type: "string" },
-    tags: {
-        name: "Tags",
-        type: "array",
-        of: { name: "Tag",
-type: "string" }
-    },
-    published_at: { name: "Published at",
-type: "date" },
-    seo: {
-        name: "SEO",
-        type: "map",
-        properties: {
-            title: { name: "SEO title",
-type: "string" },
-            description: { name: "SEO description",
-type: "string" }
-        }
-    },
-    internal_notes: {
-        name: "Internal notes",
-        type: "string",
-        admin: { readOnly: true }
-    }
-} as Properties;
-
-/** A published post: five tags, a publication date, one genuinely empty field. */
-const PUBLISHED_POST = {
-    title: "Hello",
-    tags: ["news", "launch"],
-    published_at: new Date("2026-01-01T00:00:00.000Z"),
-    seo: { title: "Hello — SEO" },
-    internal_notes: "written by a backend hook"
-};
-
-describe("the request the client sends", () => {
-
-    it("keys an array and a date exactly as the property map names them", () => {
-        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
-
-        expect(Object.keys(properties)).toEqual(expect.arrayContaining(["tags", "published_at"]));
-        expect(values.tags).toEqual(["news", "launch"]);
-        expect(values.published_at).toEqual(new Date("2026-01-01T00:00:00.000Z"));
-        // The whole key set, because the old shapes — `tags.0`, `tags.1`, and no
-        // `published_at` at all — are absences a per-key assertion would miss.
-        expect(Object.keys(values).sort()).toEqual(["published_at", "seo.title", "tags", "title"]);
-    });
-
-    it("still descends into a map, which is the one container with its own fields", () => {
-        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
-        expect(Object.keys(properties)).toContain("seo.title");
-        expect(values["seo.title"]).toBe("Hello — SEO");
-    });
-
-    it("offers the model only the fields that are actually empty", () => {
-        // The whole invariant, end to end. `tags` and `published_at` used to be
-        // in this list, so a populated tag list and a set publication date
-        // arrived in the review pre-ticked for replacement.
-        expect(plannedFillKeys(requestFor(POST_PROPERTIES, PUBLISHED_POST)))
-            .toEqual(["summary", "seo.description"]);
-    });
-
-    it("offers every field of an empty record", () => {
-        // The other direction: the agreement must not be bought by hiding
-        // fillable fields. `internal_notes` is absent because it is read-only,
-        // and `seo` because a map is a container, not a field.
-        expect(plannedFillKeys(requestFor(POST_PROPERTIES, {})))
-            .toEqual(["title", "summary", "tags", "published_at", "seo.title", "seo.description"]);
-    });
-
-    it("carries a value for every fillable property the record has filled", () => {
-        // The drift check, stated as a rule rather than a list: whatever a
-        // future property type does to either map, a value the operator can see
-        // in the form must reach the service under the key the service will
-        // look it up by.
-        const { properties, values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
-        const onTheWire = JSON.parse(JSON.stringify(values)) as Record<string, unknown>;
-
-        for (const [key, property] of Object.entries(properties)) {
-            if (!propertySchema(property)) continue; // not a field the service fills
-            if (!alreadyFilled(getValueInPath(PUBLISHED_POST, key))) continue;
-            expect({ key,
-filled: alreadyFilled(onTheWire[key]) }).toEqual({ key,
-filled: true });
-        }
-    });
-
-    it("does not transmit the value of a read-only property", () => {
-        // `disabled` already means "the service may not fill this". It has to
-        // mean "and it is not context either": the prompt includes every value
-        // it is given, so a field owned by a backend hook was being pasted into
-        // it verbatim.
-        const { values } = requestFor(POST_PROPERTIES, PUBLISHED_POST);
-        expect(values).not.toHaveProperty("internal_notes");
-        expect(JSON.stringify(values)).not.toContain("backend hook");
-    });
-
-    it("takes the children of a disabled map with it", () => {
-        const properties = {
-            audit: {
-                name: "Audit",
-                type: "map",
-                admin: { disabled: true },
-                properties: {
-                    author: { name: "Author",
-type: "string" }
-                }
-            }
-        } as Properties;
-        const { values } = requestFor(properties, { audit: { author: "root" } });
-        expect(values).toEqual({});
-    });
-});
-
-describe("omitDisabledValues", () => {
-
-    it("leaves a record alone when nothing is disabled", () => {
-        const values = { a: 1,
-b: 2 };
-        expect(omitDisabledValues(values, { a: { type: "number",
-fieldConfigId: "number_field" } })).toBe(values);
-    });
-
-    it("survives a property map carrying a non-object at a path", () => {
-        // `getSimplifiedProperty` writes a raw type string at
-        // `${path}.${i}.${typeField}` for `oneOf` arrays, and `"disabled" in
-        // aString` throws.
-        const properties = { "blocks.0.type": "images" } as unknown as Record<string, InputProperty>;
-        expect(() => omitDisabledValues({ "blocks.0.type": "images" }, properties)).not.toThrow();
-    });
-});