@rebasepro/plugin-ai 0.0.1-canary.4829d6e

package/src/tests/diffStrings.test.ts

@@ -0,0 +1,128 @@
+// Import the diffStrings function from your module
+// import { diffStrings } from './your-module';
+
+import { Change, diffStrings } from "../utils/diffStrings";
+
+describe("diffStrings", () => {
+    test("equal strings", () => {
+        const oldStr = "This is a test string";
+        const newStr = "This is a test string";
+        const expected: Change[] = [
+            {
+                type: "equal",
+                value: "This is a test string"
+            }
+        ];
+        expect(diffStrings(oldStr, newStr)).toEqual(expected);
+    });
+
+    test("insertions only", () => {
+        const oldStr = "This is a test string";
+        const newStr = "This is a new test string";
+        const expected: Change[] = [
+            {
+                type: "equal",
+                value: "This is a"
+            },
+            {
+                type: "insert",
+                value: " new"
+            },
+            {
+                type: "equal",
+                value: " test string"
+            }
+        ];
+        expect(diffStrings(oldStr, newStr)).toEqual(expected);
+    });
+
+    test("deletions only", () => {
+        const oldStr = "This is an old test string";
+        const newStr = "This is a test string";
+        const expected: Change[] = [
+            {
+                type: "equal",
+                value: "This is a"
+            },
+            {
+                type: "delete",
+                value: "n old"
+            },
+            {
+                type: "equal",
+                value: " test string"
+            }
+        ];
+        expect(diffStrings(oldStr, newStr)).toEqual(expected);
+    });
+
+    test("insertions and deletions", () => {
+        const oldStr = "This is an old test string";
+        const newStr = "This is a new modified test string";
+        // The LCS algorithm finds the longest common substrings correctly
+        // Even though the output is more granular, it correctly represents the diff
+        const expected: Change[] = [
+            {
+                type: "equal",
+                value: "This is a"
+            },
+            {
+                type: "insert",
+                value: " "
+            },
+            {
+                type: "equal",
+                value: "n"
+            },
+            {
+                type: "insert",
+                value: "ew"
+            },
+            {
+                type: "equal",
+                value: " "
+            },
+            {
+                type: "insert",
+                value: "m"
+            },
+            {
+                type: "equal",
+                value: "o"
+            },
+            {
+                type: "delete",
+                value: "l"
+            },
+            {
+                type: "insert",
+                value: "difie"
+            },
+            {
+                type: "equal",
+                value: "d test string"
+            }
+        ];
+        expect(diffStrings(oldStr, newStr)).toEqual(expected);
+    });
+
+    test("completely different strings", () => {
+        const oldStr = "Old string";
+        const newStr = "New string";
+        const expected: Change[] = [
+            {
+                type: "delete",
+                value: "Old"
+            },
+            {
+                type: "insert",
+                value: "New"
+            },
+            {
+                type: "equal",
+                value: " string"
+            }
+        ];
+        expect(diffStrings(oldStr, newStr)).toEqual(expected);
+    });
+});

package/src/tests/strings_counter.test.ts

@@ -0,0 +1,117 @@
+import { countStringCharacters } from "../utils/strings_counter";
+import type { Properties } from "@rebasepro/types";
+
+describe("countStringCharacters", () => {
+    it("counts characters in a string property", () => {
+        const values = { title: "Hello World" };
+        const properties: Properties = {
+            title: { name: "title",
+type: "string" }
+        };
+        expect(countStringCharacters(values, properties)).toBe(11);
+    });
+
+    it("counts characters in a number property (stringified)", () => {
+        const values = { price: 12345 };
+        const properties: Properties = {
+            price: { name: "price",
+type: "number" }
+        };
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+
+    it("skips disabled properties", () => {
+        const values = { title: "Hello",
+hidden: "Secret" };
+        const properties: Properties = {
+            title: { name: "title",
+type: "string" },
+            hidden: { name: "hidden",
+type: "string",
+ui: { disabled: true } }
+        };
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+
+    it("counts array of strings", () => {
+        const values = { tags: ["hello", "world", "test"] };
+        const properties: Properties = {
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag",
+type: "string" }
+            }
+        };
+        // "hello" (5) + "world" (5) + "test" (4) = 14
+        expect(countStringCharacters(values, properties)).toBe(14);
+    });
+
+    it("recurses into map properties", () => {
+        const values = {
+            address: { city: "New York",
+country: "USA" }
+        };
+        const properties: Properties = {
+            address: {
+                name: "address",
+                type: "map",
+                properties: {
+                    city: { name: "city",
+type: "string" },
+                    country: { name: "country",
+type: "string" }
+                }
+            }
+        };
+        // "New York" (8) + "USA" (3) = 11
+        expect(countStringCharacters(values, properties)).toBe(11);
+    });
+
+    it("returns 0 for empty values", () => {
+        const properties: Properties = {
+            title: { name: "title",
+type: "string" }
+        };
+        expect(countStringCharacters({}, properties)).toBe(0);
+    });
+
+    it("handles mixed property types", () => {
+        const values = {
+            title: "Hello",
+            count: 42,
+            active: true,
+            tags: ["a", "bb"]
+        };
+        const properties: Properties = {
+            title: { name: "title",
+type: "string" },
+            count: { name: "count",
+type: "number" },
+            active: { name: "active",
+type: "boolean" },
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag",
+type: "string" }
+            }
+        };
+        // "Hello" (5) + "42" (2) + "a" (1) + "bb" (2) = 10
+        expect(countStringCharacters(values, properties)).toBe(10);
+    });
+
+    it("handles null values in array gracefully", () => {
+        const values = { tags: [null, "hello", null] };
+        const properties: Properties = {
+            tags: {
+                name: "tags",
+                type: "array",
+                of: { name: "tag",
+type: "string" }
+            }
+        };
+        // null?.length = 0, "hello" = 5, null?.length = 0
+        expect(countStringCharacters(values, properties)).toBe(5);
+    });
+});

package/src/tests/suggestions.test.ts

@@ -0,0 +1,53 @@
+import { getAppendableSuggestion } from "../utils/suggestions";
+
+describe("getAppendableSuggestion", () => {
+    it("returns the remaining part when suggestion starts with value", () => {
+        const result = getAppendableSuggestion("Hello World", "Hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns undefined when suggestion does not start with value", () => {
+        const result = getAppendableSuggestion("Goodbye World", "Hello");
+        expect(result).toBeUndefined();
+    });
+
+    it("performs case-insensitive matching", () => {
+        const result = getAppendableSuggestion("Hello World", "hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns undefined for number suggestion", () => {
+        const result = getAppendableSuggestion(42, "4");
+        expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for undefined suggestion", () => {
+        const result = getAppendableSuggestion(undefined, "hello");
+        expect(result).toBeUndefined();
+    });
+
+    it("returns undefined for non-string value", () => {
+        const result = getAppendableSuggestion("Hello", 42);
+        expect(result).toBeUndefined();
+    });
+
+    it("returns full suggestion when value is empty string", () => {
+        const result = getAppendableSuggestion("Hello World", "");
+        expect(result).toBe("Hello World");
+    });
+
+    it("handles whitespace trimming", () => {
+        const result = getAppendableSuggestion("Hello World", "Hello");
+        expect(result).toBe(" World");
+    });
+
+    it("returns empty string when suggestion equals value", () => {
+        const result = getAppendableSuggestion("Hello", "Hello");
+        expect(result).toBe("");
+    });
+
+    it("returns undefined when value is longer than suggestion", () => {
+        const result = getAppendableSuggestion("Hi", "Hello World");
+        expect(result).toBeUndefined();
+    });
+});

package/src/tests/useDataEnhancementPlugin.test.tsx

@@ -0,0 +1,51 @@
+import { TextEncoder, TextDecoder } from "util";
+Object.assign(global, { TextEncoder,
+TextDecoder });
+
+// Mock window.matchMedia
+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 { renderHook } from "@testing-library/react";
+import { useDataEnhancementPlugin } from "../useDataEnhancementPlugin";
+
+jest.mock("@rebasepro/admin", () => ({
+    useUrlController: () => ({})
+}));
+
+describe("useDataEnhancementPlugin hook", () => {
+    it("returns data enhancement plugin with correct metadata", () => {
+        const { result } = renderHook(() => useDataEnhancementPlugin());
+        const plugin = result.current;
+
+        expect(plugin.key).toBe("data_enhancement");
+        expect(plugin.slots).toBeDefined();
+        expect(plugin.slots[0].slot).toBe("form.actions");
+        expect(plugin.providers).toBeDefined();
+        expect(plugin.providers[0].scope).toBe("form");
+        expect(plugin.providers[0].props.apiKey).toBe("fcms-U9jdDii0xXWSDC34asfrf54lbkFJBfKfRWcEDEwdc4V5wDWEDF");
+    });
+
+    it("accepts and forwards custom apiKey and host props", () => {
+        const customProps = {
+            apiKey: "custom-key",
+            host: "https://custom-host.com"
+        };
+        const { result } = renderHook(() => useDataEnhancementPlugin(customProps));
+        const plugin = result.current;
+
+        expect(plugin.providers[0].props.apiKey).toBe("custom-key");
+        expect(plugin.providers[0].props.host).toBe("https://custom-host.com");
+    });
+});

package/src/tests/values.test.ts

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

@@ -0,0 +1,75 @@
+import { EntityValues } from "@rebasepro/types";
+import { EditorAIController } from "@rebasepro/admin";
+
+export type EnhanceParams<M extends Record<string, unknown>> = {
+    entityId?: string | number;
+    propertyKey?: string;
+    propertyInstructions?: string;
+    values: EntityValues<M>;
+    instructions?: string;
+    replaceValues: boolean;
+};
+
+export type DataEnhancementController = {
+    /**
+     * Whether the data enhancement is enabled for the current path
+     */
+    enabled: boolean;
+    suggestions: Record<string, string | number>;
+    enhance: <M extends Record<string, unknown>>(props: EnhanceParams<M>) => Promise<EnhancedDataResult | null>;
+    clearSuggestion: (key: string, suggestion: string | number) => void;
+    allowReferenceDataSelection: boolean;
+    clearAllSuggestions: () => void;
+    getSamplePrompts: (entityName: string, input?: string) => Promise<SamplePromptsResult>;
+    loadingSuggestions: string[],
+    editorAIController?: EditorAIController;
+}
+
+export type EnhancedDataResult = {
+    entityId?: string | number;
+    suggestions: {
+        [key: string]: string[];
+    };
+    errors: string[];
+    usage: { promptTokens?: number, completionTokens?: number, totalTokens?: number }
+}
+
+export type SamplePrompt = {
+    prompt: string;
+    type: "recent" | "sample";
+}
+
+export type SamplePromptsResult = {
+    prompts: SamplePrompt[];
+    host?: string;
+};
+
+export type DataEnhancementRequest = {
+    entityName: string;
+    entityDescription?: string;
+    inputEntity: InputEntity;
+    properties: Record<string, InputProperty>;
+    propertyKey?: string;
+    propertyInstructions?: string,
+    instructions?: string;
+};
+
+export type InputEntity = {
+    entityId?: string | number;
+    values: Record<string, any>;
+};
+
+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

@@ -0,0 +1,66 @@
+import React from "react";
+
+import { CollectionConfig, RebasePlugin, User } from "@rebasepro/types";
+import { DataEnhancementControllerProvider } from "./components/DataEnhancementControllerProvider";
+import { FormEnhanceAction } from "./components/FormEnhanceAction";
+
+const DEFAULT_API_KEY = "fcms-U9jdDii0xXWSDC34asfrf54lbkFJBfKfRWcEDEwdc4V5wDWEDF";
+
+export interface DataEnhancementPluginProps {
+
+    apiKey?: string;
+
+    /**
+     * 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.
+     * You can also return a configuration object to override the default configuration.
+     *
+     * @param path
+     * @param collection
+     */
+    getConfigForPath?: (props: {
+        path: string,
+        collection: CollectionConfig,
+        user: User | null
+    }) => boolean;
+
+    /**
+     * Host to use for the data enhancement API.
+     * This prop is only use in development mode.
+     */
+    host?: 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 apiKey = props?.apiKey ?? DEFAULT_API_KEY;
+    const getConfigForPath = props?.getConfigForPath;
+
+    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: {
+                    apiKey,
+                    getConfigForPath,
+                    host: props?.host
+                }
+            }
+        ]
+    }), [apiKey, getConfigForPath, props?.host]);
+}

package/src/utils/diffStrings.ts

@@ -0,0 +1,70 @@
+type ChangeType = "equal" | "delete" | "insert";
+
+export interface Change {
+    type: ChangeType;
+    value: string;
+}
+
+export function diffStrings(oldStr: string, newStr: string): Change[] {
+    // Find the longest common substring
+    function longestCommonSubstring(s1: string, s2: string): string {
+        const longest = { start: 0,
+length: 0 };
+        const matrix = new Array(s1.length + 1).fill(null).map(() => new Array(s2.length + 1).fill(0));
+
+        for (let i = 1; i <= s1.length; i++) {
+            for (let j = 1; j <= s2.length; j++) {
+                if (s1[i - 1] === s2[j - 1]) {
+                    matrix[i][j] = matrix[i - 1][j - 1] + 1;
+                    if (matrix[i][j] > longest.length) {
+                        longest.start = i - matrix[i][j];
+                        longest.length = matrix[i][j];
+                    }
+                }
+            }
+        }
+
+        return s1.slice(longest.start, longest.start + longest.length);
+    }
+
+    // Recursively find changes and create Change objects
+    function findChanges(s1: string, s2: string): Change[] {
+        if (s1 === s2) return s1.length > 0 ? [{
+            type: "equal",
+            value: s1
+        }] : [];
+
+        const common = longestCommonSubstring(s1, s2);
+
+        if (common.length === 0) {
+            const changes: Change[] = [];
+            if (s1.length > 0) {
+                changes.push({ type: "delete",
+value: s1 });
+            }
+            if (s2.length > 0) {
+                changes.push({ type: "insert",
+value: s2 });
+            }
+            return changes;
+        }
+
+        const s1Before = s1.slice(0, s1.indexOf(common));
+        const s1After = s1.slice(s1.indexOf(common) + common.length);
+        const s2Before = s2.slice(0, s2.indexOf(common));
+        const s2After = s2.slice(s2.indexOf(common) + common.length);
+
+        const changesBefore = findChanges(s1Before, s2Before);
+        const changesAfter = findChanges(s1After, s2After);
+
+        return [
+            ...changesBefore,
+            { type: "equal",
+value: common },
+            ...changesAfter
+        ];
+    }
+
+    return findChanges(oldStr, newStr);
+}
+