@rebasepro/plugin-ai 0.17.3-canary.gdd23447 → 0.18.0

package/src/tests/useEditorAIController.test.ts

@@ -1,98 +0,0 @@
-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/cms", () => ({}));
-
-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/);
-    });
-});

package/src/tests/values.test.ts

@@ -1,87 +0,0 @@
-import { flatMapEntityValues } from "../utils/values";
-
-describe("flatMapEntityValues", () => {
-    it("returns flat object unchanged", () => {
-        const values = { name: "John",
-age: 30 };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({ name: "John",
-age: 30 });
-    });
-
-    it("flattens nested object to dot-notation keys", () => {
-        const values = {
-            address: { city: "NYC",
-zip: "10001" }
-        };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({
-            "address.city": "NYC",
-            "address.zip": "10001"
-        });
-    });
-
-    it("flattens deeply nested objects", () => {
-        const values = {
-            a: { b: { c: { d: "deep" } } }
-        };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({ "a.b.c.d": "deep" });
-    });
-
-    it("returns empty object for empty input", () => {
-        expect(flatMapEntityValues({})).toEqual({});
-    });
-
-    it("returns empty object for null input", () => {
-        expect(flatMapEntityValues(null as unknown as object)).toEqual({});
-    });
-
-    it("returns empty object for undefined input", () => {
-        expect(flatMapEntityValues(undefined as unknown as object)).toEqual({});
-    });
-
-    it("handles mixed nested and flat values", () => {
-        const values = {
-            name: "John",
-            address: { city: "NYC" },
-            active: true
-        };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({
-            name: "John",
-            "address.city": "NYC",
-            active: true
-        });
-    });
-
-    it("handles multiple nested objects", () => {
-        const values = {
-            home: { city: "NYC" },
-            work: { city: "SF" }
-        };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({
-            "home.city": "NYC",
-            "work.city": "SF"
-        });
-    });
-
-    it("handles numeric values in nested objects", () => {
-        const values = {
-            stats: { visits: 100,
-clicks: 50 }
-        };
-        const result = flatMapEntityValues(values);
-        expect(result).toEqual({
-            "stats.visits": 100,
-            "stats.clicks": 50
-        });
-    });
-
-    it("uses custom path prefix", () => {
-        const values = { name: "John" };
-        const result = flatMapEntityValues(values, "user");
-        expect(result).toEqual({ "user.name": "John" });
-    });
-});

package/src/types/data_enhancement_controller.tsx

@@ -1,142 +0,0 @@
-import { EntityValues } from "@rebasepro/types";
-import { EditorAIController } from "@rebasepro/cms";
-
-export type GenerateParams<M extends Record<string, unknown>> = {
-    values: EntityValues<M>;
-    /** Free-text instruction from the operator, if they gave one. */
-    instructions?: string;
-    /** Restrict the run to one field. */
-    propertyKey?: string;
-    propertyInstructions?: string;
-};
-
-/**
- * One field the model wants to write, awaiting the operator's decision.
- *
- * Nothing here has touched the form. That is the entire point of the type: the
- * previous design streamed generated text straight into the live fields, which
- * meant a half-written sentence was indistinguishable from a bug, the
- * operator's own words were overwritten by heuristics that tried to guess
- * whether to append or replace, and there was no way back other than retyping.
- */
-export type ProposedField = {
-    /** Dotted property path, e.g. `seo.title`. */
-    key: string;
-    /** The property's display name, falling back to its key. */
-    label: string;
-    /** What is in the form right now — shown so an overwrite is visible. */
-    currentValue: unknown;
-    /** What the model proposes. Grows while `pending`. */
-    proposed: unknown;
-    /** Still streaming. */
-    pending: boolean;
-    /** Whether Apply will write this one. */
-    selected: boolean;
-};
-
-export type AutofillReview = {
-    status: "generating" | "ready" | "failed";
-    /** Set when `status` is `failed`. */
-    error?: string;
-    /** In arrival order, so the list reads as the model works. */
-    fields: ProposedField[];
-    /** What was asked for, shown back to the operator while they review. */
-    instructions?: string;
-};
-
-export type DataEnhancementController = {
-    /**
-     * Whether autofill can actually be used right now.
-     *
-     * The conjunction of two separate things: the host app allows it for this
-     * collection ({@link DataEnhancementPluginProps.getConfigForPath}), *and*
-     * the service reported itself available. The second half is what the
-     * FireCMS-era plugin lacked — it rendered its button unconditionally
-     * against a host that no longer existed, so every click 404'd.
-     */
-    enabled: boolean;
-
-    /** The run in flight or awaiting review; `null` when there is neither. */
-    review: AutofillReview | null;
-
-    /** Start a run. Opens {@link review}; never writes to the form. */
-    generate: <M extends Record<string, unknown>>(params: GenerateParams<M>) => Promise<void>;
-
-    /** Include or exclude one field from what Apply will write. */
-    toggleField: (key: string) => void;
-
-    /** Select or deselect every field at once. */
-    toggleAll: (selected: boolean) => void;
-
-    /**
-     * Write the selected fields to the form and close the review.
-     *
-     * The only path by which this plugin mutates a record, and it runs once per
-     * run rather than once per token — so it is a single undo step and a single
-     * dirty transition, not hundreds.
-     */
-    applyReview: () => void;
-
-    /** Close the review, writing nothing. The record is untouched. */
-    dismissReview: () => void;
-
-    getSamplePrompts: (entityName: string, input?: string) => Promise<SamplePromptsResult>;
-
-    editorAIController?: EditorAIController;
-};
-
-/** What `GET /status` answers. Everything else is gated on `available`. */
-export type AiStatus = {
-    available: boolean;
-    model?: string;
-    features?: string[];
-};
-
-export type AutofillResult = {
-    /** Every field the service completed, keyed by property path. */
-    suggestions: Record<string, unknown>;
-    usage?: { inputTokens?: number; outputTokens?: number };
-};
-
-export type SamplePrompt = {
-    prompt: string;
-    type: "recent" | "sample";
-};
-
-export type SamplePromptsResult = {
-    prompts: SamplePrompt[];
-};
-
-/**
- * The autofill request body.
- *
- * The property schema travels with every request because the service has no
- * access to the caller's collections — it is a hosted endpoint reachable from
- * any self-hosted admin panel. That is the cost of not putting an LLM
- * dependency in `@rebasepro/server`; had the route lived in the backend it
- * could have read the collection registry and this would be three fields.
- */
-export type AutofillRequest = {
-    entityName: string;
-    entityDescription?: string;
-    values: Record<string, unknown>;
-    properties: Record<string, InputProperty>;
-    propertyKey?: string;
-    propertyInstructions?: string;
-    instructions?: string;
-};
-
-export type InputProperty = {
-    name?: string;
-    description?: string;
-    type: string;
-    fieldConfigId: string;
-    enum?: string[];
-    disabled?: boolean;
-    of?: InputProperty;
-    oneOf?: {
-        properties: Record<string, InputProperty>;
-        typeField?: string;
-        valueField?: string;
-    };
-};

package/src/useDataEnhancementPlugin.tsx

@@ -1,68 +0,0 @@
-import React from "react";
-
-import { CollectionConfig, User } from "@rebasepro/types";
-import { RebasePlugin } from "@rebasepro/cms-types";
-import { DataEnhancementControllerProvider } from "./components/DataEnhancementControllerProvider";
-import { FormEnhanceAction } from "./components/FormEnhanceAction";
-
-export interface DataEnhancementPluginProps {
-
-    /**
-     * Use this function to determine if the data enhancement plugin should be enabled for a given path.
-     * If this function is not provided, the plugin will be enabled for all paths.
-     * If the function returns false, the plugin will be disabled for the given path.
-     *
-     * @param path
-     * @param collection
-     */
-    getConfigForPath?: (props: {
-        path: string,
-        collection: CollectionConfig,
-        user: User | null
-    }) => boolean;
-
-    /**
-     * Base URL of the AI service.
-     *
-     * Defaults to the one Rebase hosts, which is free to use and needs no
-     * configuration. Point it at your own deployment to keep generation inside
-     * your infrastructure — the wire format is documented in `src/api.ts`, and
-     * the reference implementation is `saas/backend/functions/ai.ts`.
-     *
-     * Whatever it points at, the plugin renders nothing until that host's
-     * `GET /status` reports itself available.
-     */
-    endpoint?: string;
-}
-
-/**
- * Use this hook to initialise the data enhancement plugin.
- * This is likely the only hook you will need to use.
- * @param props
- */
-export function useDataEnhancementPlugin(props?: DataEnhancementPluginProps): RebasePlugin {
-
-    const getConfigForPath = props?.getConfigForPath;
-    const endpoint = props?.endpoint;
-
-    return React.useMemo(() => ({
-        key: "data_enhancement",
-        slots: [
-            {
-                slot: "form.actions",
-                Component: FormEnhanceAction,
-                order: 40
-            }
-        ],
-        providers: [
-            {
-                scope: "form" as const,
-                Component: DataEnhancementControllerProvider as React.ComponentType<any>,
-                props: {
-                    getConfigForPath,
-                    endpoint
-                }
-            }
-        ]
-    }), [getConfigForPath, endpoint]);
-}

package/src/utils/properties.ts

@@ -1,168 +0,0 @@
-import { getFieldId } from "@rebasepro/cms";
-import { EnumValues, Properties, Property } from "@rebasepro/types";
-import { isPropertyBuilder } from "@rebasepro/common";
-import { InputProperty } from "../types/data_enhancement_controller";
-import { getValueInPath } from "@rebasepro/utils";
-
-export function getSimplifiedProperties<M extends Record<string, any>>(properties: Properties, values: M, path = ""): Record<string, InputProperty> {
-    if (!properties) return {};
-    return Object.entries(properties)
-        .map(([key, property]) => {
-            if (isPropertyBuilder(property)) return {};
-            const fullKey = path ? `${path}.${key}` : key;
-            const valueInPath = getValueInPath(values, fullKey);
-            return getSimplifiedProperty(property, fullKey, valueInPath)
-        })
-        .reduce((a, b) => ({ ...a,
-...b }), {});
-}
-
-function getSimpleProperty(property: Property): InputProperty {
-    const fieldId = getFieldId(property);
-    if (!fieldId) {
-        console.error("No fieldId found for property", property);
-        throw new Error("Field id not found");
-    }
-    return {
-        name: property.name,
-        description: property.description,
-        type: property.type,
-        fieldConfigId: fieldId,
-        enum: "enum" in property && property.enum
-            ? getSimpleEnumValues(property.enum)
-            : undefined,
-        disabled: Boolean(property.admin?.disabled || property.admin?.readOnly)
-    };
-}
-
-function getSimplifiedProperty(property: Property, path: string, value?: unknown): Record<string, InputProperty> {
-    if (isPropertyBuilder(property)) return {};
-    if (property.type === "array") {
-
-        if (property.of && !Array.isArray(property.of) && !isPropertyBuilder(property.of)) {
-            const arrayParentProperty: InputProperty = {
-                name: property.name,
-                description: property.description,
-                type: property.type,
-                fieldConfigId: "repeat",
-                disabled: Boolean(property.admin?.disabled || property.admin?.readOnly),
-                of: getSimpleProperty(property.of as Property)
-            };
-
-            const result = { [path]: arrayParentProperty };
-            // if (Array.isArray(value)) {
-            //     result = {
-            //         ...result,
-            //         ...value
-            //             .map((v, i) => getSimplifiedProperty(property.of, `${path}.${i}`, v))
-            //             .reduce((a, b) => ({ ...a, ...b }), {})
-            //     };
-            // }
-            //
-            // const existingValuesCount = Array.isArray(value) ? value.length : 0;
-            //
-            // const newValuesCount = property.of && !isPropertyBuilder<any, any>(property.of) && (property.of as Property).type === "map" ? 1 : 3;
-            // result = {
-            //     ...result,
-            //     // ...Array.from(Array(newValuesCount))
-            //     //     .map((v, i) => getSimplifiedProperty(property.of, `${path}.${i + existingValuesCount}`, v))
-            //     //     .reduce((a, b) => ({ ...a, ...b }), {})
-            // }
-
-            return result;
-        } else if (property.oneOf) {
-
-            const arrayParentProperty: InputProperty = {
-                name: property.name,
-                description: property.description,
-                type: property.type,
-                fieldConfigId: "block",
-                disabled: Boolean(property.admin?.disabled || property.admin?.readOnly),
-                oneOf: {
-                    typeField: property.oneOf.typeField,
-                    valueField: property.oneOf.valueField,
-                    properties: Object.entries(property.oneOf.properties)
-                        .map(([key, prop]) => ({ [key]: getSimpleProperty(prop) }))
-                        .reduce((a, b) => ({ ...a,
-...b }), {})
-                }
-            };
-
-            if (!Array.isArray(value)) {
-                return { [path]: arrayParentProperty };
-            }
-
-            return value.map((v, i) => {
-                if (v == null) return {};
-                const typeKey = property.oneOf!.typeField ?? "type";
-                const oneOfType = v[typeKey];
-                const valueKey = property.oneOf!.valueField ?? "value";
-                const oneOfValue = v[valueKey];
-                const childProperty = property.oneOf!.properties[oneOfType];
-                if (childProperty === undefined) {
-                    console.error(`No property found for type ${oneOfType}`, property.oneOf!.properties);
-                    return {};
-                }
-                const simplifiedProperty = getSimplifiedProperty(childProperty, `${path}.${i}.${valueKey}`, oneOfValue);
-                return {
-                    [`${path}.${i}.${typeKey}`]: oneOfType,
-                    ...simplifiedProperty
-                };
-            }).reduce((a, b) => ({ ...a,
-...b }), { [path]: arrayParentProperty });
-        }
-    } else if (property.type === "map") {
-        if (property.properties) {
-            const mapProperties: Record<string, InputProperty> = Object.entries(property.properties)
-                .map(([key, childProperty]) => {
-                    const childValue = value && typeof value === "object" ? (value as Record<string, unknown>)[key] : undefined;
-                    return getSimplifiedProperty(childProperty, key, childValue);
-                })
-                .map(o => attachPathToKeys(o, path))
-                .reduce((a, b) => ({ ...a,
-...b }), {});
-
-            if (Object.keys(mapProperties).length === 0) return {};
-            const mapParentProperty: InputProperty = {
-                name: property.name,
-                description: property.description,
-                type: property.type,
-                fieldConfigId: "group",
-                disabled: Boolean(property.admin?.disabled || property.admin?.readOnly)
-            };
-            return {
-                [path]: mapParentProperty,
-                ...mapProperties
-            } as Record<string, InputProperty>;
-        }
-    } else {
-        const fieldId = getFieldId(property);
-        if (!fieldId) {
-            console.warn(`No fieldId found for property ${path} with type ${property.type}`);
-            return {};
-        }
-        return {
-            [path]: getSimpleProperty(property)
-        };
-    }
-    return {};
-}
-
-// attach a path to every key in an object
-function attachPathToKeys(obj: Record<string, InputProperty>, path = ""): Record<string, InputProperty> {
-    return Object.entries(obj)
-        .map(([key, value]) => {
-            const fullKey = path ? `${path}.${key}` : key;
-            return { [fullKey]: value };
-        })
-        .reduce((a, b) => ({ ...a,
-...b }), {});
-}
-
-function getSimpleEnumValues(enumValues: EnumValues): string[] {
-    if (Array.isArray(enumValues))
-        return enumValues.map(v => String(v.id));
-    if (typeof enumValues === "object")
-        return Object.keys(enumValues);
-    throw Error("getSimpleEnumValues: Invalid enumValues");
-}

package/src/utils/values.ts

@@ -1,72 +0,0 @@
-import { InputProperty } from "../types/data_enhancement_controller";
-
-/**
- * Flatten a record onto the dotted paths the property map uses.
- *
- * The two halves of an autofill request have to be keyed the same way: the
- * service decides a field is empty by looking up `values[key]` for every `key`
- * in `properties`, so a value filed under a key the property map has never
- * heard of is a value the service cannot see.
- *
- * Only plain objects are containers. This used to recurse into anything
- * `typeof value === "object"`, which is both an array and a `Date` — so
- * `tags: ["a", "b"]` was sent as `tags.0`/`tags.1` while the property map still
- * called it `tags`, and a `Date` disappeared entirely (`Object.entries(date)` is
- * `[]`). Both then read as empty on the far side and came back in the review
- * pre-ticked to replace a value the record already had. `getSimplifiedProperties`
- * names an array by its own path and never descends into one, so neither does
- * this.
- */
-export function flatMapEntityValues<M extends object>(values: M, path = ""): Record<string, unknown> {
-    if (!values) return {};
-    return Object.entries(values).flatMap(([key, value]) => {
-        const currentPath = path ? `${path}.${key}` : key;
-        if (isPlainObject(value)) {
-            return flatMapEntityValues(value, currentPath);
-        } else {
-            return { [currentPath]: value };
-        }
-    }).reduce((acc, curr) => ({ ...acc,
-...curr }), {});
-}
-
-/**
- * A container, as opposed to a leaf value.
- *
- * Arrays, dates, files and every other class instance are values in their own
- * right — a map property is the only thing whose children are separate fields.
- */
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-    if (value === null || typeof value !== "object") return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-
-/**
- * Drop the values of properties the panel will not let anyone edit.
- *
- * A `readOnly` or `disabled` property is already excluded from what the service
- * may fill, but the values map was built from the whole record, and the prompt
- * includes every value it is given as context. So a field marked read-only
- * because a backend hook owns it — an internal note, a customer id — was still
- * being transmitted and pasted into the prompt. The collection config lives
- * here, so this is the honest place to decide it: disabled means neither
- * fillable nor context.
- *
- * Prefixes match too: a disabled map takes its children with it.
- */
-export function omitDisabledValues(
-    values: Record<string, unknown>,
-    properties: Record<string, InputProperty>
-): Record<string, unknown> {
-    const disabled = Object.entries(properties ?? {})
-        // A property map can carry a non-object at a path (see the `oneOf`
-        // branch of `getSimplifiedProperty`), and `"disabled" in aString` throws.
-        .filter(([, property]) => property && typeof property === "object" && property.disabled)
-        .map(([key]) => key);
-    if (disabled.length === 0) return values;
-    return Object.fromEntries(
-        Object.entries(values).filter(([key]) =>
-            !disabled.some((prefix) => key === prefix || key.startsWith(`${prefix}.`)))
-    );
-}

package/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />