@rebasepro/cms 0.17.3 → 0.18.0

package/src/collection_editor/CollectionEditorDialogsContext.tsx

@@ -1,25 +0,0 @@
-import React, { createContext, useContext } from "react";
-
-/**
- * Holds the dialog state + rendering props that ConfigControllerProvider
- * sets and CollectionEditorDialogs reads.
- *
- * This indirection exists because ConfigControllerProvider is a root-scope
- * plugin provider that wraps <RebaseShell>, therefore living ABOVE the admin
- * context providers (CollectionRegistryContext, NavigationStateContext,
- * UrlContext).  The actual dialog components need those contexts, so they
- * must render inside the shell tree.
- */
-export interface CollectionEditorDialogsState {
-    /** Props for the active CollectionEditorDialog, or undefined when closed. */
-    collectionDialogProps: Record<string, any> | undefined;
-    /** Props for the active PropertyFormDialog, or undefined when closed. */
-    propertyDialogProps: Record<string, any> | undefined;
-}
-
-export const CollectionEditorDialogsContext =
-    createContext<CollectionEditorDialogsState | undefined>(undefined);
-
-export function useCollectionEditorDialogsState(): CollectionEditorDialogsState | undefined {
-    return useContext(CollectionEditorDialogsContext);
-}

package/src/collection_editor/ConfigControllerProvider.tsx

@@ -1,395 +0,0 @@
-import { useUrlController } from "./_cms_internals";
-import React, { useCallback, useEffect, useMemo, useState } from "react";
-import { Entity, Property, TableMetadata, User } from "@rebasepro/types";
-import { deepEqual as equal } from "fast-equals";
-
-import { CollectionsConfigController } from "./types/config_controller";
-import { useCustomizationController, useRebaseContext, useAuthController, useSnackbarController } from "@rebasepro/app";
-import { getTableName } from "@rebasepro/common";
-import { useNavigate } from "react-router";
-import { CollectionEditorController } from "./types/collection_editor_controller";
-import { CollectionInference } from "./types/collection_inference";
-import { CollectionGenerationCallback } from "./api/generateCollectionApi";
-import { CollectionEditorDialogsContext, CollectionEditorDialogsState } from "./CollectionEditorDialogsContext";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-export const ConfigControllerContext = React.createContext<CollectionsConfigController>({} as CollectionsConfigController);
-export const CollectionEditorContext = React.createContext<CollectionEditorController>({} as CollectionEditorController);
-
-export interface ConfigControllerProviderProps {
-    /**
-     * Controller for managing the collections' config.
-     */
-    collectionConfigController: CollectionsConfigController;
-
-    /**
-     * Callback used to infer the schema from the data.
-     */
-    collectionInference?: CollectionInference;
-
-    extraView?: {
-        View: React.ComponentType<{
-            path: string
-        }>,
-        icon: React.ReactNode
-    };
-
-    pathSuggestions?: string[];
-
-    getUser?: (uid: string) => User | null;
-
-    getData?: (path: string, parentPaths: string[]) => Promise<object[]>;
-
-    onAnalyticsEvent?: (event: string, params?: object) => void;
-
-    /**
-     * Callback function for generating/modifying collections.
-     * The plugin is API-agnostic - the consumer provides the implementation.
-     */
-    generateCollection?: CollectionGenerationCallback;
-
-}
-
-export const ConfigControllerProvider = React.memo(
-    function ConfigControllerProvider({
-        children,
-        collectionConfigController,
-        collectionInference,
-        extraView,
-        getUser,
-        getData,
-        onAnalyticsEvent,
-        pathSuggestions,
-        generateCollection
-    }: ConfigControllerProviderProps & { children?: React.ReactNode }) {
-
-        // Internal: fetch unmapped tables and table columns from the data source
-        const { databaseAdmin } = useRebaseContext();
-        const authController = useAuthController();
-        const [unmappedTables, setUnmappedTables] = useState<string[]>([]);
-
-        useEffect(() => {
-            if (!databaseAdmin?.fetchUnmappedTables || authController.initialLoading || !authController.user) return;
-            const existingPaths = (collectionConfigController.collections ?? []).map(c => getTableName(c) ?? "").filter(Boolean);
-            databaseAdmin.fetchUnmappedTables(existingPaths)
-                .then((tables: string[]) => setUnmappedTables(tables))
-                .catch((e: unknown) => console.warn("Could not fetch unmapped tables:", e));
-        }, [databaseAdmin, authController.initialLoading, authController.user, collectionConfigController.collections]);
-
-        const onFetchTableMetadata = useCallback(async (tableName: string): Promise<TableMetadata | undefined> => {
-            return databaseAdmin?.fetchTableMetadata?.(tableName) as Promise<TableMetadata | undefined>;
-        }, [databaseAdmin]);
-
-        const urlController = useUrlController();
-        const navigate = useNavigate();
-        const snackbarController = useSnackbarController();
-        const { propertyConfigs } = useCustomizationController();
-
-        const [currentDialog, setCurrentDialog] = React.useState<{
-            isNewCollection: boolean,
-            parentCollection?: AdminCollection,
-            editedCollectionId?: string,
-            path?: string,
-            parentCollectionSlugs: string[], parentEntityIds: string[],
-            initialValues?: {
-                path?: string,
-                name?: string
-            },
-            copyFrom?: AdminCollection,
-            redirect: boolean,
-            existingEntities?: Entity[],
-            pathSuggestions?: string[];
-            initialView?: "general" | "display" | "properties";
-            expandKanban?: boolean;
-        }>();
-
-        const [currentPropertyDialog, setCurrentPropertyDialog] = React.useState<{
-            propertyKey?: string,
-            property?: Property,
-            namespace?: string,
-            parentCollection?: AdminCollection,
-            currentPropertiesOrder?: string[],
-            editedCollectionId: string,
-            path?: string,
-            parentCollectionSlugs: string[], parentEntityIds: string[],
-
-            existingEntities?: Entity[];
-            collection?: AdminCollection;
-        }>();
-
-        const editCollection = useCallback(({
-            id,
-            path,
-            parentCollectionSlugs, parentEntityIds,
-            parentCollection,
-            existingEntities,
-            initialView,
-            expandKanban
-        }: {
-            id?: string,
-            path?: string,
-            parentCollectionSlugs: string[], parentEntityIds: string[],
-            parentCollection?: AdminCollection,
-            existingEntities?: Entity[],
-            initialView?: "general" | "display" | "properties",
-            expandKanban?: boolean
-        }) => {
-            console.debug("Edit collection", id, path, parentCollectionSlugs, parentEntityIds, parentCollection);
-            onAnalyticsEvent?.("edit_collection", {
-                id,
-                path
-            });
-            setCurrentDialog({
-                editedCollectionId: id,
-                path,
-                parentCollectionSlugs,
-parentEntityIds,
-                isNewCollection: false,
-                parentCollection,
-                redirect: false,
-                existingEntities,
-                pathSuggestions,
-                initialView,
-                expandKanban
-            });
-        }, [onAnalyticsEvent, pathSuggestions]);
-
-        const editProperty = useCallback(({
-            propertyKey,
-            property,
-            editedCollectionId,
-            currentPropertiesOrder,
-            parentCollectionSlugs, parentEntityIds,
-            collection,
-            existingEntities
-        }: {
-            propertyKey?: string,
-            property?: Property,
-            currentPropertiesOrder?: string[],
-            editedCollectionId: string,
-            parentCollectionSlugs: string[], parentEntityIds: string[],
-            collection: AdminCollection,
-            existingEntities?: Entity[]
-        }) => {
-            console.debug("Edit property", propertyKey, property, editedCollectionId, currentPropertiesOrder, parentCollectionSlugs, parentEntityIds, collection);
-            onAnalyticsEvent?.("edit_property", {
-                propertyKey,
-                editedCollectionId
-            });
-            // namespace is all the path until the last dot
-            const namespace = propertyKey && propertyKey.includes(".")
-                ? propertyKey.substring(0, propertyKey.lastIndexOf("."))
-                : undefined;
-            const propertyKeyWithoutNamespace = propertyKey && propertyKey.includes(".")
-                ? propertyKey.substring(propertyKey.lastIndexOf(".") + 1)
-                : propertyKey;
-            setCurrentPropertyDialog({
-                propertyKey: propertyKeyWithoutNamespace,
-                property,
-                namespace,
-                currentPropertiesOrder,
-                editedCollectionId,
-                parentCollectionSlugs,
-parentEntityIds,
-
-                existingEntities,
-                collection
-            });
-        }, [onAnalyticsEvent]);
-
-        const createCollection = useCallback(({
-            parentCollectionSlugs, parentEntityIds,
-            parentCollection,
-            initialValues,
-            copyFrom,
-            redirect,
-            sourceClick
-        }: {
-            parentCollectionSlugs: string[], parentEntityIds: string[],
-            parentCollection?: AdminCollection
-            initialValues?: {
-                path?: string,
-                name?: string
-            },
-            copyFrom?: AdminCollection,
-            redirect: boolean,
-            sourceClick?: string
-        }) => {
-            console.debug("Create collection", {
-                parentCollectionSlugs,
-parentEntityIds,
-                parentCollection,
-                initialValues,
-                copyFrom,
-                redirect,
-                sourceClick
-            });
-            onAnalyticsEvent?.(copyFrom ? "duplicate_collection" : "create_collection", {
-                parentCollectionSlugs,
-parentEntityIds,
-                parentCollection,
-                initialValues,
-                redirect,
-                sourceClick
-            });
-            setCurrentDialog({
-                isNewCollection: true,
-                parentCollectionSlugs,
-parentEntityIds,
-                parentCollection,
-                initialValues,
-                copyFrom,
-                redirect,
-                pathSuggestions
-            });
-        }, [onAnalyticsEvent, pathSuggestions]);
-
-        // Build the dialog props objects that will be consumed by
-        // CollectionEditorDialogs (rendered inside RebaseShell where admin
-        // contexts are available).
-        const collectionDialogProps = useMemo(() => {
-            if (!currentDialog) return undefined;
-            return {
-                open: true,
-                configController: collectionConfigController,
-                collectionInference,
-                ...currentDialog,
-                getData,
-                extraView,
-                getUser,
-                generateCollection,
-                onAnalyticsEvent,
-                unmappedTables,
-                onFetchTableMetadata,
-                handleClose: (collection?: AdminCollection) => {
-                    if (currentDialog?.redirect) {
-                        if (collection && currentDialog?.isNewCollection && !currentDialog.parentCollectionSlugs.length) {
-                            const url = urlController.buildUrlCollectionPath(collection.slug);
-                            navigate(url);
-                        }
-                    }
-                    setCurrentDialog(undefined);
-                }
-            };
-        }, [
-            currentDialog, collectionConfigController, collectionInference,
-            getData, extraView, getUser, generateCollection,
-            onAnalyticsEvent, unmappedTables, onFetchTableMetadata,
-            urlController, navigate
-        ]);
-
-        const propertyDialogProps = useMemo(() => {
-            if (!currentPropertyDialog) return undefined;
-            return {
-                open: true,
-                includeIdAndName: true,
-                existingProperty: Boolean(currentPropertyDialog.propertyKey),
-                autoUpdateId: !currentPropertyDialog.propertyKey,
-                autoOpenTypeSelect: !currentPropertyDialog.propertyKey,
-                inArray: false,
-                getData: currentPropertyDialog.existingEntities || (getData && currentPropertyDialog.editedCollectionId)
-                    ? async () => {
-                        let data: object[] = [];
-                        if (currentPropertyDialog.existingEntities) {
-                            data = currentPropertyDialog.existingEntities.map(e => e.values);
-                        }
-                        if (getData && currentPropertyDialog.editedCollectionId) {
-                            console.debug("Get data for property, path:", currentPropertyDialog.editedCollectionId);
-                            const resolvedPath = urlController.resolveDatabasePathsFrom(currentPropertyDialog.editedCollectionId!);
-                            const fetchedData = await getData(resolvedPath, []);
-                            data.push(...fetchedData);
-                        }
-                        return data;
-                    }
-                    : undefined,
-                onPropertyChanged: ({
-                    id,
-                    property
-                }: { id?: string; property: Property }) => {
-                    if (!currentPropertyDialog) return;
-                    if (!id) return;
-                    const newProperty = !(currentPropertyDialog.propertyKey);
-                    return collectionConfigController.saveProperty({
-                        path: currentPropertyDialog.editedCollectionId,
-                        property,
-                        propertyKey: id,
-                        newPropertiesOrder: newProperty && currentPropertyDialog.currentPropertiesOrder ? [...currentPropertyDialog.currentPropertiesOrder, id] : undefined,
-                        namespace: currentPropertyDialog.namespace,
-                        parentCollectionSlugs: currentPropertyDialog.parentCollectionSlugs
-                    })
-                        .catch((e: any) => {
-                            console.error(e);
-                            snackbarController.open({
-                                type: "error",
-                                message: "Error persisting property: " + (e.message ?? "Details in the console")
-                            });
-                            return false;
-                        });
-                },
-                onPropertyChangedImmediate: false,
-                onDelete: () => {
-                    if (!currentPropertyDialog.propertyKey) return;
-                    const newPropertiesOrder = currentPropertyDialog.currentPropertiesOrder?.filter((p: string) => p !== currentPropertyDialog.propertyKey);
-                    return collectionConfigController.deleteProperty({
-                        path: currentPropertyDialog.editedCollectionId,
-                        propertyKey: currentPropertyDialog.propertyKey,
-                        namespace: currentPropertyDialog.namespace,
-                        newPropertiesOrder,
-                        parentCollectionSlugs: currentPropertyDialog.parentCollectionSlugs
-                    })
-                        .then(() => {
-                            setCurrentPropertyDialog(undefined);
-                        }).catch((e: any) => {
-                            console.error(e);
-                            snackbarController.open({
-                                type: "error",
-                                message: "Error deleting property: " + (e.message ?? "Details in the console")
-                            });
-                            return false;
-                        });
-                },
-                onError: () => { },
-                onOkClicked: () => {
-                    setCurrentPropertyDialog(undefined);
-                },
-                onCancel: () => {
-                    setCurrentPropertyDialog(undefined);
-                },
-                initialErrors: {},
-                forceShowErrors: false,
-                existingPropertyKeys: currentPropertyDialog.collection?.properties ? Object.keys(currentPropertyDialog.collection.properties) : [],
-                allowDataInference: true,
-                propertyConfigs,
-                property: currentPropertyDialog.property,
-                propertyKey: currentPropertyDialog.propertyKey
-            };
-        }, [currentPropertyDialog, getData, urlController, collectionConfigController, snackbarController, propertyConfigs]);
-
-        const dialogsState: CollectionEditorDialogsState = useMemo(() => ({
-            collectionDialogProps,
-            propertyDialogProps
-        }), [collectionDialogProps, propertyDialogProps]);
-
-        const collectionEditorContextValue = useMemo(() => ({
-            editCollection,
-            createCollection,
-            editProperty,
-            pathSuggestions,
-            configController: collectionConfigController
-        }), [editCollection, createCollection, editProperty, pathSuggestions, collectionConfigController]);
-
-        return (
-            <ConfigControllerContext.Provider value={collectionConfigController}>
-                <CollectionEditorContext.Provider value={collectionEditorContextValue}>
-                    <CollectionEditorDialogsContext.Provider value={dialogsState}>
-                        {children}
-                        {/* Rendered here rather than by each consumer: a
-                            controller that has to ask before it writes needs
-                            somewhere to ask, and this is the one component that
-                            wraps every editor surface. */}
-                        {collectionConfigController.dialog}
-                    </CollectionEditorDialogsContext.Provider>
-                </CollectionEditorContext.Provider>
-            </ConfigControllerContext.Provider>
-        );
-    }, equal);

package/src/collection_editor/_cms_internals.ts

@@ -1,41 +0,0 @@
-/**
- * Internal re-exports for the collection editor module.
- * This avoids circular imports by pointing directly at source files
- * rather than going through the admin barrel (index.ts).
- */
-
-// Hooks
-export { useCollectionRegistryController } from "../hooks/navigation/contexts/CollectionRegistryContext";
-export { useNavigationStateController } from "../hooks/navigation/contexts/NavigationStateContext";
-export { useUrlController } from "../hooks/navigation/contexts/UrlContext";
-export { useSidePanel } from "../hooks/useSidePanel";
-export { useBreadcrumbsController } from "../hooks/useBreadcrumbsController";
-
-// Components
-export { FieldCaption } from "../components/FieldCaption";
-export { SearchIconsView } from "../components/SearchIconsView";
-export { PropertyConfigBadge } from "../components/PropertyConfigBadge";
-export { CollectionTableBinding } from "../components/CollectionTableBinding";
-export { VirtualTableInput } from "@rebasepro/ui";
-export { ArrayContainer } from "../components/ArrayContainer";
-export type { ArrayEntryParams } from "../components/ArrayContainer";
-export { useSelectionController } from "../components/CollectionViewBinding/useSelectionController";
-
-// Data import
-export { ImportFileUpload } from "../data_import/components/ImportFileUpload";
-export { ImportSaveInProgress } from "../data_import/components/ImportSaveInProgress";
-export { useImportConfig } from "../data_import/hooks/useImportConfig";
-export { getInferenceType } from "../data_import/utils/get_import_inference_type";
-export { convertDataToEntity } from "../data_import/utils/data";
-export type { ImportConfig } from "../data_import/types";
-
-// Data import components
-export { DataNewPropertiesMapping } from "../data_import/components/DataNewPropertiesMapping";
-export { ImportNewPropertyFieldPreview } from "../data_import/components/ImportNewPropertyFieldPreview";
-
-// Field config utilities
-export { getFieldConfig, getFieldId, getDefaultFieldConfig, getDefaultFieldId, DEFAULT_FIELD_CONFIGS } from "../components/field_configs";
-
-// Property & resolution utilities
-export { getPropertyInPath, getResolvedPropertyInPath, getDefaultPropertiesOrder, getPropertiesWithPropertiesOrder } from "../util/property_utils";
-export { resolveEntityAction, resolveEntityView } from "../util/resolutions";

package/src/collection_editor/api/generateCollectionApi.ts

@@ -1,126 +0,0 @@
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-export interface GenerateCollectionRequest {
-    /** User's natural language description of what they want */
-    prompt: string;
-
-    /** Other collections in the project (for context/relationships). Limit to 30. */
-    existingCollections: Partial<AdminCollection>[];
-
-    /** Optional for generate, required for modifications. If provided, modifies this collection */
-    existingCollection?: Partial<AdminCollection>;
-}
-
-/** Operation types for modifying a collection */
-export type CollectionOperationType = "add" | "modify" | "delete";
-
-/** A single operation describing what changed */
-export interface CollectionOperation {
-    op: CollectionOperationType;
-    path: string;
-    value?: unknown;
-}
-
-/** Result from collection generation, including optional delta operations */
-export interface GenerateCollectionResult {
-    collection: AdminCollection;
-    operations?: CollectionOperation[];
-}
-
-/**
- * Callback type for generating or modifying a collection.
- * The plugin is API-agnostic - consumers implement the actual API call.
- */
-export type CollectionGenerationCallback = (
-    request: GenerateCollectionRequest
-) => Promise<GenerateCollectionResult>;
-
-export class CollectionGenerationApiError extends Error {
-    public code?: string;
-
-    constructor(message: string, code?: string) {
-        super(message);
-        this.code = code;
-        this.name = "CollectionGenerationApiError";
-    }
-}
-
-/**
- * Default endpoint for AI collection generation
- */
-export const DEFAULT_COLLECTION_GENERATION_ENDPOINT = "https://api.rebase.pro/collections/generate";
-
-/**
- * Props for building a collection generation callback
- */
-export interface BuildCollectionGenerationCallbackProps {
-    /**
-     * Function to get the auth token.
-     * This is typically `authController.getAuthToken` from `@rebasepro/client`
-     * (or `@rebasepro/firebase` if using Firebase).
-     */
-    getAuthToken: () => Promise<string>;
-
-    /**
-     * Optional custom API endpoint for collection generation.
-     * Defaults to the Rebase SaaS API endpoint.
-     */
-    apiEndpoint?: string;
-}
-
-/**
- * Build a callback for AI collection generation.
- * This helper allows self-hosted Rebase users to enable the AI collection
- * generation feature.
- *
- * @example
- * ```tsx
- * import { RebaseCMS } from "@rebasepro/cms";
- * import { buildCollectionGenerationCallback } from "@rebasepro/cms/collection_editor";
- * import { useFirebaseAuthController } from "@rebasepro/firebase";
- *
- * const authController = useFirebaseAuthController({ firebaseApp });
- *
- * export function App() {
- *     return (
- *         <RebaseCMS
- *             collectionEditor={{
- *                 generateCollection: buildCollectionGenerationCallback({
- *                     getAuthToken: authController.getAuthToken
- *                 })
- *             }}
- *         />
- *     );
- * }
- * ```
- */
-export function buildCollectionGenerationCallback({
-    getAuthToken,
-    apiEndpoint = DEFAULT_COLLECTION_GENERATION_ENDPOINT
-}: BuildCollectionGenerationCallbackProps): CollectionGenerationCallback {
-    return async (request) => {
-        const token = await getAuthToken();
-        const response = await fetch(apiEndpoint, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${token}`
-            },
-            body: JSON.stringify(request)
-        });
-
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new CollectionGenerationApiError(
-                errorData.error || "Failed to generate collection",
-                errorData.code
-            );
-        }
-
-        const data = await response.json();
-        return {
-            collection: data.data.collection,
-            operations: data.data.operations
-        };
-    };
-}

package/src/collection_editor/api/index.ts

@@ -1 +0,0 @@
-export * from "./generateCollectionApi";