@rebasepro/admin 0.0.1-canary.4f204c2

package/src/collection_editor/api/generateCollectionApi.ts

@@ -0,0 +1,125 @@
+import { EntityCollection } from "@rebasepro/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<EntityCollection>[];
+
+    /** Optional for generate, required for modifications. If provided, modifies this collection */
+    existingCollection?: Partial<EntityCollection>;
+}
+
+/** 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: EntityCollection;
+    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 (e.g., from Firebase Auth)
+     * This is typically `authController.getAuthToken` from `@rebasepro/client-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/admin";
+ * import { buildCollectionGenerationCallback } from "@rebasepro/admin/collection_editor";
+ * import { useFirebaseAuthController } from "@rebasepro/client-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

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

package/src/collection_editor/index.ts

@@ -0,0 +1,63 @@
+// Collection Editor — moved from @rebasepro/studio
+// This module provides the visual schema/collection editor for the CMS.
+//
+// IMPORTANT: Heavy UI components (CollectionEditorDialog, CollectionStudioView,
+// CollectionsStudioView, PropertyForm, PropertyFormDialog) are NOT re-exported
+// here to keep the main CMS bundle lean. Import them from
+// "@rebasepro/admin/collection_editor_ui" instead — they live in a separate chunk
+// that is loaded on demand.
+
+
+export {
+    useCollectionEditorController
+} from "./useCollectionEditorController";
+export {
+    useCollectionsConfigController
+} from "./useCollectionsConfigController";
+export {
+    useLocalCollectionsConfigController
+} from "./useLocalCollectionsConfigController";
+
+export {
+    validateCollectionJson,
+    type CollectionValidationError,
+    type CollectionValidationResult
+} from "./validateCollectionJson";
+
+export type {
+    CollectionsConfigController, DeleteCollectionParams, SaveCollectionParams, UpdateCollectionParams, CollectionsSetupInfo, UpdatePropertiesOrderParams, UpdateKanbanColumnsOrderParams
+} from "./types/config_controller";
+export type {
+    CollectionEditorController
+} from "./types/collection_editor_controller";
+export type {
+    CollectionEditorPermissions, CollectionEditorPermissionsBuilder
+} from "./types/config_permissions";
+export type {
+    CollectionInference
+} from "./types/collection_inference";
+
+export {
+    buildCollectionGenerationCallback,
+    CollectionGenerationApiError,
+    DEFAULT_COLLECTION_GENERATION_ENDPOINT
+} from "./api/generateCollectionApi";
+
+export type {
+    CollectionGenerationCallback,
+    GenerateCollectionRequest,
+    GenerateCollectionResult,
+    CollectionOperation,
+    CollectionOperationType,
+    BuildCollectionGenerationCallbackProps
+} from "./api/generateCollectionApi";
+
+export { MissingReferenceWidget } from "./ui/MissingReferenceWidget";
+
+export * from "./ui/collection_editor/util";
+
+// Re-export types only from heavy UI components (runtime code is in the separate chunk)
+export type { CollectionEditorDialogProps } from "./ui/collection_editor/CollectionEditorDialog";
+export type { CollectionStudioViewProps } from "./ui/collection_editor/CollectionStudioView";
+export type { CollectionsStudioViewProps } from "./ui/collection_editor/CollectionsStudioView";
+export type { PropertyFormProps, OnPropertyChangedParams } from "./ui/collection_editor/PropertyEditView";

package/src/collection_editor/pgColumnToProperty.ts

@@ -0,0 +1,273 @@
+import { EntityCollection, Property, StringProperty, NumberProperty, ArrayProperty, TableColumnInfo, TableMetadata } from "@rebasepro/types";
+import { prettifyIdentifier } from "@rebasepro/utils";
+
+/**
+ * Maps a PostgreSQL column data type to a Rebase property type.
+ */
+function pgTypeToRebaseProperty(column: TableColumnInfo): Property | null {
+    const {
+        column_name,
+        data_type,
+        udt_name,
+        is_nullable,
+        column_default,
+        enum_values
+    } = column;
+
+    const required = is_nullable === "NO";
+    const prettifiedName = prettifyIdentifier(column_name);
+
+    // Detect if this column is a primary key (auto-generated id)
+    const isAutoId = column_default != null && (
+        column_default.includes("nextval") ||
+        column_default.includes("gen_random_uuid") ||
+        column_default.includes("uuid_generate") ||
+        column_default.includes("identity")
+    );
+
+    // USER-DEFINED = PostgreSQL enums
+    if (data_type === "USER-DEFINED" && enum_values && enum_values.length > 0) {
+        return {
+            type: "string",
+            name: prettifiedName,
+            enum: enum_values.map((v: string) => ({ id: v,
+label: prettifyIdentifier(v) })),
+            validation: required ? { required: true } : undefined
+        } as StringProperty;
+    }
+
+    const dt = data_type.toLowerCase();
+    switch (dt) {
+        case "character varying":
+        case "varchar":
+        case "text":
+        case "char":
+        case "character":
+        case "citext": {
+            let colType: "varchar" | "text" | "char" = "varchar";
+            if (dt === "text" || dt === "citext") colType = "text";
+            if (dt === "char" || dt === "character") colType = "char";
+            const prop: StringProperty = {
+                type: "string",
+                name: prettifiedName,
+                columnType: colType,
+                validation: required ? { required: true } : undefined
+            };
+            if (isAutoId) {
+                prop.isId = "manual";
+            }
+            return prop;
+        }
+
+        case "uuid": {
+            const prop: StringProperty = {
+                type: "string",
+                name: prettifiedName,
+                validation: required ? { required: true } : undefined
+            };
+            if (isAutoId) {
+                prop.isId = "uuid";
+            }
+            return prop;
+        }
+
+        case "integer":
+        case "bigint":
+        case "smallint": {
+            const colType = dt === "bigint" ? "bigint" : "integer";
+            const prop: NumberProperty = {
+                type: "number",
+                name: prettifiedName,
+                columnType: colType,
+                validation: {
+                    ...(required ? { required: true } : {}),
+                    integer: true
+                }
+            };
+            if (isAutoId) {
+                prop.isId = "increment";
+            }
+            return prop;
+        }
+
+        case "serial":
+        case "bigserial":
+        case "smallserial": {
+            const colType = dt === "bigserial" ? "bigserial" : "serial";
+            return {
+                type: "number",
+                name: prettifiedName,
+                columnType: colType,
+                isId: "increment",
+                validation: {
+                    ...(required ? { required: true } : {}),
+                    integer: true
+                }
+            } as NumberProperty;
+        }
+
+        case "numeric":
+        case "decimal":
+        case "real":
+        case "double precision": {
+            let colType: "numeric" | "real" | "double precision" = "numeric";
+            if (dt === "real") colType = "real";
+            if (dt === "double precision") colType = "double precision";
+            return {
+                type: "number",
+                name: prettifiedName,
+                columnType: colType,
+                validation: required ? { required: true } : undefined
+            };
+        }
+
+        case "boolean":
+            return {
+                type: "boolean",
+                name: prettifiedName,
+                validation: required ? { required: true } : undefined
+            };
+
+        case "timestamp with time zone":
+        case "timestamp without time zone":
+        case "timestamp":
+        case "timestamptz":
+        case "date":
+        case "time with time zone":
+        case "time without time zone":
+        case "time": {
+            let colType: "timestamp" | "date" | "time" = "timestamp";
+            if (dt.startsWith("date")) colType = "date";
+            if (dt.startsWith("time ") || dt === "time") colType = "time";
+            return {
+                type: "date",
+                name: prettifiedName,
+                columnType: colType,
+                validation: required ? { required: true } : undefined
+            };
+        }
+
+        case "jsonb":
+        case "json":
+            return {
+                type: "map",
+                name: prettifiedName,
+                columnType: dt === "jsonb" ? "jsonb" : "json",
+                keyValue: true,
+                properties: {}
+            };
+
+        case "array":
+        case "ARRAY":
+            return {
+                type: "array",
+                name: prettifiedName,
+                of: { type: "string" }
+            } as ArrayProperty;
+
+        default:
+            // Fallback: treat unknown types as string
+            return {
+                type: "string",
+                name: prettifiedName,
+                validation: required ? { required: true } : undefined
+            };
+    }
+}
+
+/**
+ * Builds a partial EntityCollection from PostgreSQL table metadata.
+ * This is used when creating a new collection from an existing database table.
+ */
+export function buildCollectionFromTableMetadata(
+    tableName: string,
+    metadata: TableMetadata
+): Partial<EntityCollection> {
+    const properties: Record<string, Property> = {};
+    const propertiesOrder: string[] = [];
+    const relations: any[] = []; // In the builder/editor, target can be a string path before hydration
+    const securityRules: any[] = [];
+
+    // Parse columns
+    for (const column of metadata.columns) {
+        const property = pgTypeToRebaseProperty(column);
+        if (property) {
+            // Remove undefined keys so we don't output "validation: undefined"
+            const propRecord = property as unknown as Record<string, unknown>;
+            Object.keys(propRecord).forEach(key => propRecord[key] === undefined && delete propRecord[key]);
+
+            properties[column.column_name] = property;
+            propertiesOrder.push(column.column_name);
+        }
+    }
+
+    // Parse Outgoing Foreign Keys -> Many-to-One / One-to-One
+    if (metadata.foreignKeys) {
+        for (const fk of metadata.foreignKeys) {
+            const relName = fk.column_name.endsWith("_id") ? fk.column_name.substring(0, fk.column_name.length - 3) : fk.column_name;
+            relations.push({
+                id: fk.column_name,
+                relationName: relName,
+                target: fk.foreign_table_name, // Will be hydrated later
+                cardinality: "one",
+                direction: "owning",
+                localKey: fk.column_name
+            });
+        }
+    }
+
+    // Parse Incoming Junctions -> Many-to-Many
+    if (metadata.junctions) {
+        for (const junction of metadata.junctions) {
+            const relName = junction.target_table_name; // E.g., 'roles'
+            relations.push({
+                id: junction.target_table_name + "_relation",
+                relationName: relName,
+                target: junction.target_table_name, // Will be hydrated later
+                cardinality: "many",
+                direction: "owning",
+                through: {
+                    table: junction.junction_table_name,
+                    sourceColumn: junction.source_column_name,
+                    targetColumn: junction.target_column_name
+                }
+            });
+        }
+    }
+
+    // Parse RLS Policies
+    if (metadata.policies) {
+        for (const policy of metadata.policies) {
+            // Attempt to map typical cmds to operations.
+            // Postgres cmd: SELECT, INSERT, UPDATE, DELETE, ALL
+            let operations: string[] = [];
+            switch (policy.cmd) {
+                case "ALL": operations = ["read", "create", "update", "delete"]; break;
+                case "SELECT": operations = ["read"]; break;
+                case "INSERT": operations = ["create"]; break;
+                case "UPDATE": operations = ["update"]; break;
+                case "DELETE": operations = ["delete"]; break;
+            }
+            securityRules.push({
+                name: policy.policy_name,
+                operations,
+                // roles is string[] e.g., ["public", "authenticated"]
+                roles: policy.roles ?? [],
+                qual: policy.qual,
+                with_check: policy.with_check
+            });
+        }
+    }
+
+    const prettifiedName = prettifyIdentifier(tableName);
+
+    return {
+        name: prettifiedName,
+        slug: tableName,
+        table: tableName,
+        properties,
+        propertiesOrder,
+        ...(relations.length > 0 ? { relations } : {}),
+        ...(securityRules.length > 0 ? { securityRules } : {})
+    };
+}

package/src/collection_editor/types/collection_editor_controller.tsx

@@ -0,0 +1,64 @@
+import { CollectionEditorPermissionsBuilder } from "./config_permissions";
+import { CollectionsConfigController } from "./config_controller";
+import { Entity, EntityCollection, Property } from "@rebasepro/types";
+
+/**
+ * Controller to open the collection editor dialog.
+ * @group Hooks and utilities
+ */
+export interface CollectionEditorController {
+
+    editCollection: (props: {
+        id?: string,
+        path?: string,
+        parentCollectionIds: string[],
+        parentCollection?: EntityCollection,
+        existingEntities?: Entity<any>[],
+        /**
+         * Initial view to open: "general", "display", or "properties"
+         */
+        initialView?: "general" | "display" | "properties",
+        /**
+         * If true, expand the Kanban configuration section
+         */
+        expandKanban?: boolean
+    }) => void;
+
+    createCollection: (props: {
+        initialValues?: {
+            group?: string,
+            path?: string,
+            name?: string,
+            databaseId?: string
+        },
+        /**
+         * A collection to duplicate from. If provided, the new collection will be
+         * pre-populated with the same properties (but with empty name, path, and id).
+         */
+        copyFrom?: EntityCollection,
+        parentCollectionIds: string[],
+        parentCollection?: EntityCollection,
+        redirect: boolean,
+        sourceClick?: string
+    }) => void;
+
+    editProperty: (props: {
+        propertyKey?: string,
+        property?: Property,
+        currentPropertiesOrder?: string[],
+        editedCollectionId: string,
+        parentCollectionIds: string[],
+        collection: EntityCollection,
+        existingEntities: Entity<any>[]
+    }) => void;
+
+    /**
+     * The config controller that this editor represents.
+     */
+    configController: CollectionsConfigController;
+
+    configPermissions: CollectionEditorPermissionsBuilder;
+
+    pathSuggestions: string[] | undefined;
+
+}

package/src/collection_editor/types/collection_inference.ts

@@ -0,0 +1,17 @@
+import { EntityCollection, FilterValues } from "@rebasepro/types";
+
+/**
+ * This function is used to infer the configuration of a collection given its path.
+ * @param path - The path of the collection
+ * @param parentCollectionPaths - Array of parent collection paths for subcollections
+ * @param databaseId - Optional database ID for multi-database setups
+ * @param initialFilter - Optional filter values from the collection configuration
+ * @param initialSort - Optional sort configuration from the collection
+ */
+export type CollectionInference = (
+    path: string,
+    parentCollectionPaths: string[],
+    databaseId?: string,
+    initialFilter?: FilterValues<string>,
+    initialSort?: [string, "asc" | "desc"]
+) => Promise<Partial<EntityCollection> | null>;

package/src/collection_editor/types/config_controller.tsx

@@ -0,0 +1,109 @@
+import { EntityCollection, NavigationGroupMapping, Property } from "@rebasepro/types";
+
+export interface CollectionsSetupInfo {
+    status: "ongoing" | "complete" | "error";
+    error: string | null;
+}
+
+/**
+ * Use this controller to access the configuration that is stored externally,
+ * and not defined in code.
+ */
+export interface CollectionsConfigController {
+
+    loading: boolean;
+
+    collections?: EntityCollection[];
+
+    /**
+     * If true, the configuration cannot be modified.
+     * Use readOnlyReason to explain why.
+     */
+    readOnly?: boolean;
+
+    /**
+     * Reason why the configuration is read-only.
+     */
+    readOnlyReason?: string;
+
+    /**
+     * Status information about the automatic collections setup process.
+     * Stored in the project config document at `collectionsSetup`.
+     */
+    collectionsSetup?: CollectionsSetupInfo;
+
+    getCollection: (id: string) => EntityCollection;
+
+    saveCollection: <M extends { [Key: string]: any }>(params: SaveCollectionParams<M>) => Promise<void>;
+    updateCollection: <M extends { [Key: string]: any }>(params: UpdateCollectionParams<M>) => Promise<void>;
+
+    saveProperty: (params: SavePropertyParams) => Promise<void>;
+    deleteProperty: (params: DeletePropertyParams) => Promise<void>;
+
+    deleteCollection: (props: DeleteCollectionParams) => Promise<void>;
+
+    /**
+     * Update the properties order of a collection (used for column reordering).
+     */
+    updatePropertiesOrder: (params: UpdatePropertiesOrderParams) => Promise<void>;
+
+    /**
+     * Update the Kanban columns order for a collection.
+     */
+    updateKanbanColumnsOrder: (params: UpdateKanbanColumnsOrderParams) => Promise<void>;
+
+    navigationEntries: NavigationGroupMapping[];
+    saveNavigationEntries: (entries: NavigationGroupMapping[]) => Promise<void>;
+
+}
+
+export type UpdateCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string,
+    collectionData: Partial<EntityCollection<M>>,
+    previousId?: string,
+    parentCollectionIds?: string[]
+}
+
+export type SaveCollectionParams<M extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string,
+    collectionData: EntityCollection<M>,
+    previousId?: string,
+    parentCollectionIds?: string[]
+}
+
+export type SavePropertyParams = {
+    path: string,
+    propertyKey: string,
+    namespace?: string,
+    newPropertiesOrder?: string[],
+    property: Property,
+    parentCollectionIds?: string[]
+}
+
+export type DeletePropertyParams = {
+    path: string,
+    propertyKey: string,
+    namespace?: string,
+    newPropertiesOrder?: string[],
+    parentCollectionIds?: string[]
+}
+
+export type DeleteCollectionParams = {
+    id: string,
+    parentCollectionIds?: string[]
+}
+
+export type UpdatePropertiesOrderParams = {
+    fullPath: string;
+    parentCollectionIds: string[];
+    collection: EntityCollection;
+    newPropertiesOrder: string[];
+}
+
+export type UpdateKanbanColumnsOrderParams = {
+    fullPath: string;
+    parentCollectionIds: string[];
+    collection: EntityCollection;
+    kanbanColumnProperty: string;
+    newColumnsOrder: string[];
+}

package/src/collection_editor/types/config_permissions.ts

@@ -0,0 +1,20 @@
+import { EntityCollection } from "@rebasepro/types";
+
+export type CollectionEditorPermissionsBuilder<USER = any, EC extends EntityCollection = EntityCollection> = (params: { user: USER | null, collection?: EC }) => CollectionEditorPermissions;
+
+export type CollectionEditorPermissions = {
+    /**
+     * Is the user allowed to create new collections.
+     */
+    createCollections: boolean;
+
+    /**
+     * Is the user allowed to modify this collection
+     */
+    editCollections: boolean;
+
+    /**
+     * Is the user allowed to delete this collection
+     */
+    deleteCollections: boolean;
+}