@rebasepro/admin 0.0.1-canary.4f204c2

package/src/collection_editor/useLocalCollectionsConfigController.tsx

@@ -0,0 +1,120 @@
+import { CollectionsConfigController, SaveCollectionParams, UpdateCollectionParams, DeleteCollectionParams, SavePropertyParams, DeletePropertyParams, UpdatePropertiesOrderParams } from "./types/config_controller";
+import { EntityCollection, Properties } from "@rebasepro/types";
+import { getSubcollections } from "@rebasepro/common";
+
+
+import React, { useMemo } from "react";
+export function useLocalCollectionsConfigController(
+    clientOrUrl: any,
+    baseCollections: EntityCollection[] = [],
+    options?: {
+        readOnly?: boolean;
+        getAuthToken?: () => Promise<string | null>;
+    }
+): CollectionsConfigController {
+
+    const parsedCollections = baseCollections;
+
+    const request = async (endpoint: string, payload: Record<string, unknown>) => {
+        console.log("dispatching dev server request", endpoint, payload);
+        try {
+            let token = options?.getAuthToken ? await options.getAuthToken() : null;
+            let baseUrl = typeof clientOrUrl === "string" ? clientOrUrl : "";
+
+            if (typeof clientOrUrl === "object" && clientOrUrl !== null) {
+                baseUrl = clientOrUrl.baseUrl || baseUrl;
+                if (!token && clientOrUrl.resolveToken) {
+                    token = await clientOrUrl.resolveToken();
+                }
+            }
+
+            const headers: Record<string, string> = { "Content-Type": "application/json" };
+            if (token) {
+                headers["Authorization"] = `Bearer ${token}`;
+            }
+
+            const response = await fetch(`${baseUrl.replace(/\/$/, "")}/api/schema-editor${endpoint}`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(payload)
+            });
+            console.log("dev server response", endpoint, response.status);
+            if (!response.ok) {
+                const text = await response.text();
+                let err: Record<string, unknown> = {};
+                try {
+                    err = JSON.parse(text);
+                } catch (e) {
+                    // ignore json parse error
+                }
+
+                if (Object.keys(err).length === 0) {
+                    err = { message: text };
+                }
+                console.error("dev server error payload:", err);
+                const errObj = err.error as Record<string, unknown> | string | undefined;
+                const errMessage = typeof errObj === "object" && errObj !== null
+                    ? (errObj.message as string)
+                    : (typeof errObj === "string" ? errObj : (err.message as string | undefined));
+                throw new Error(errMessage || "Error communicating with local dev server");
+            }
+        } catch (e) {
+            console.error("fetch request failed", e);
+            throw e;
+        }
+    };
+
+    return useMemo(() => ({
+        loading: false,
+        readOnly: options?.readOnly ?? false,
+        readOnlyReason: "Local collection editing is only available in development mode.",
+        collections: parsedCollections,
+        getCollection: (id: string) => {
+            const found = parsedCollections.find(c => (c as EntityCollection & { id?: string }).id === id || c.slug === id);
+            if (found) return found;
+            throw Error(`Collection ${id} not found in local mode`);
+        },
+
+        saveCollection: async ({ id, collectionData }: SaveCollectionParams) => {
+            await request("/collection/save", { collectionId: id,
+collectionData });
+        },
+        updateCollection: async ({ id, collectionData }: UpdateCollectionParams) => {
+            await request("/collection/save", { collectionId: id,
+collectionData });
+        },
+        deleteCollection: async ({ id }: DeleteCollectionParams) => {
+            await request("/collection/delete", { collectionId: id });
+        },
+
+        saveProperty: async ({ path, propertyKey, property, newPropertiesOrder }: SavePropertyParams) => {
+            await request("/property/save", { collectionId: path,
+propertyKey,
+propertyConfig: property });
+            if (newPropertiesOrder) {
+                await request("/collection/save", { collectionId: path,
+collectionData: { propertiesOrder: newPropertiesOrder } });
+            }
+        },
+        deleteProperty: async ({ path, propertyKey, newPropertiesOrder }: DeletePropertyParams) => {
+            await request("/property/delete", { collectionId: path,
+propertyKey });
+            if (newPropertiesOrder) {
+                await request("/collection/save", { collectionId: path,
+collectionData: { propertiesOrder: newPropertiesOrder } });
+            }
+        },
+
+        updatePropertiesOrder: async ({ collection, fullPath, newPropertiesOrder }: UpdatePropertiesOrderParams) => {
+            const collectionId = (collection as EntityCollection & { id?: string }).id || fullPath.split("/").pop();
+            await request("/collection/save", { collectionId,
+collectionData: { propertiesOrder: newPropertiesOrder } });
+        },
+        updateKanbanColumnsOrder: async () => {
+            // Kanban order mapping logic can be added later if needed natively.
+        },
+
+        navigationEntries: [],
+        saveNavigationEntries: async () => { }
+    }), [clientOrUrl, parsedCollections, options?.readOnly, options?.getAuthToken]);
+}

package/src/collection_editor/validateCollectionJson.ts

@@ -0,0 +1,379 @@
+import { EntityCollection } from "@rebasepro/types";
+
+/**
+ * Valid dataType values for properties
+ */
+const VALID_DATA_TYPES = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "geopoint",
+    "reference",
+    "array",
+    "map"
+] as const;
+
+type DataType = typeof VALID_DATA_TYPES[number];
+
+/**
+ * Validation error with path and message
+ */
+export interface CollectionValidationError {
+    path: string;
+    message: string;
+}
+
+/**
+ * Result of collection JSON validation
+ */
+export interface CollectionValidationResult {
+    valid: boolean;
+    errors: CollectionValidationError[];
+    collection?: EntityCollection;
+}
+
+/**
+ * Validates a property object recursively
+ */
+function validateProperty(
+    property: Record<string, unknown>,
+    path: string,
+    errors: CollectionValidationError[]
+): void {
+    if (typeof property !== "object" || property === null) {
+        errors.push({
+            path,
+            message: "Property must be an object"
+        });
+        return;
+    }
+
+    // Check dataType
+    if (!property.dataType) {
+        errors.push({
+            path: `${path}.dataType`,
+            message: "Required field is missing"
+        });
+    } else if (!VALID_DATA_TYPES.includes(property.dataType as DataType)) {
+        errors.push({
+            path: `${path}.dataType`,
+            message: `Invalid value "${property.dataType}", expected one of: ${VALID_DATA_TYPES.join(", ")}`
+        });
+    }
+
+    // Validate name if present
+    if (property.name !== undefined && typeof property.name !== "string") {
+        errors.push({
+            path: `${path}.name`,
+            message: "Must be a string"
+        });
+    }
+
+    // Validate array "of" property
+    if (property.dataType === "array") {
+        if (property.of) {
+            if (Array.isArray(property.of)) {
+                property.of.forEach((ofProp: Record<string, unknown>, index: number) => {
+                    validateProperty(ofProp, `${path}.of[${index}]`, errors);
+                });
+            } else {
+                validateProperty(property.of as unknown as Record<string, unknown>, `${path}.of`, errors);
+            }
+        }
+        // oneOf validation
+        if (property.oneOf) {
+            if (typeof property.oneOf !== "object") {
+                errors.push({
+                    path: `${path}.oneOf`,
+                    message: "Must be an object"
+                });
+            } else if ((property.oneOf as unknown as Record<string, unknown>).properties) {
+                validateProperties((property.oneOf as unknown as Record<string, unknown>).properties as unknown as Record<string, unknown>, `${path}.oneOf.properties`, errors);
+            }
+        }
+    }
+
+    // Validate map properties
+    if (property.dataType === "map" && property.properties) {
+        validateProperties(property.properties as unknown as Record<string, unknown>, `${path}.properties`, errors);
+    }
+
+    // Validate reference path
+    if (property.dataType === "reference") {
+        if (property.path !== undefined && typeof property.path !== "string") {
+            errors.push({
+                path: `${path}.path`,
+                message: "Must be a string"
+            });
+        }
+    }
+
+    // Validate storage config for string
+    if (property.dataType === "string" && property.storage) {
+        if (typeof property.storage !== "object") {
+            errors.push({
+                path: `${path}.storage`,
+                message: "Must be an object"
+            });
+        }
+    }
+
+    // Validate enum if present
+    if (property.enum !== undefined) {
+        if (!Array.isArray(property.enum) && typeof property.enum !== "object") {
+            errors.push({
+                path: `${path}.enum`,
+                message: "Must be an array or object"
+            });
+        }
+    }
+}
+
+/**
+ * Validates a properties object (collection of property definitions)
+ */
+function validateProperties(
+    properties: Record<string, unknown>,
+    path: string,
+    errors: CollectionValidationError[]
+): void {
+    if (typeof properties !== "object" || properties === null) {
+        errors.push({
+            path,
+            message: "Must be an object"
+        });
+        return;
+    }
+
+    for (const [key, property] of Object.entries(properties)) {
+        validateProperty(property as unknown as Record<string, unknown>, `${path}.${key}`, errors);
+    }
+}
+
+/**
+ * Validates optional collection fields
+ */
+function validateOptionalFields(
+    collection: Record<string, unknown>,
+    errors: CollectionValidationError[]
+): void {
+    // String fields
+    const stringFields = [
+        "singularName",
+        "description",
+        "group",
+        "databaseId"
+    ];
+    for (const field of stringFields) {
+        if (collection[field] !== undefined && typeof collection[field] !== "string") {
+            errors.push({
+                path: field,
+                message: "Must be a string"
+            });
+        }
+    }
+
+    // Boolean fields
+    const booleanFields = [
+
+        "selectionEnabled",
+        "inlineEditing",
+        "hideFromNavigation",
+        "hideIdFromForm",
+        "hideIdFromCollection",
+        "formAutoSave",
+        "alwaysApplyDefaultValues",
+        "includeJsonView",
+        "history"
+    ];
+    for (const field of booleanFields) {
+        if (collection[field] !== undefined && typeof collection[field] !== "boolean") {
+            errors.push({
+                path: field,
+                message: "Must be a boolean"
+            });
+        }
+    }
+
+    // Icon can be string or object (React node)
+    if (collection.icon !== undefined &&
+        typeof collection.icon !== "string" &&
+        typeof collection.icon !== "object") {
+        errors.push({
+            path: "icon",
+            message: "Must be a string (icon key) or object"
+        });
+    }
+
+    // propertiesOrder must be array of strings
+    if (collection.propertiesOrder !== undefined) {
+        if (!Array.isArray(collection.propertiesOrder)) {
+            errors.push({
+                path: "propertiesOrder",
+                message: "Must be an array of strings"
+            });
+        } else if (!collection.propertiesOrder.every((item: unknown) => typeof item === "string")) {
+            errors.push({
+                path: "propertiesOrder",
+                message: "All items must be strings"
+            });
+        }
+    }
+
+    // subcollections must be array
+    if (collection.subcollections !== undefined) {
+        if (!Array.isArray(collection.subcollections)) {
+            errors.push({
+                path: "subcollections",
+                message: "Must be an array"
+            });
+        } else {
+            collection.subcollections.forEach((sub: Record<string, unknown>, index: number) => {
+                const subErrors: CollectionValidationError[] = [];
+                validateCollectionObject(sub, subErrors);
+                subErrors.forEach(err => {
+                    errors.push({
+                        path: `subcollections[${index}].${err.path}`,
+                        message: err.message
+                    });
+                });
+            });
+        }
+    }
+
+    // defaultViewMode validation
+    const validViewModes = ["table", "cards", "kanban"];
+    if (collection.defaultViewMode !== undefined) {
+        if (!validViewModes.includes(collection.defaultViewMode as string)) {
+            errors.push({
+                path: "defaultViewMode",
+                message: `Invalid value, expected one of: ${validViewModes.join(", ")}`
+            });
+        }
+    }
+
+    // kanban config validation
+    if (collection.kanban !== undefined) {
+        if (typeof collection.kanban !== "object" || collection.kanban === null) {
+            errors.push({
+                path: "kanban",
+                message: "Must be an object"
+            });
+        } else if ((collection.kanban as unknown as Record<string, unknown>).columnProperty !== undefined &&
+            typeof (collection.kanban as unknown as Record<string, unknown>).columnProperty !== "string") {
+            errors.push({
+                path: "kanban.columnProperty",
+                message: "Must be a string"
+            });
+        }
+    }
+}
+
+/**
+ * Validates a collection object
+ */
+function validateCollectionObject(
+    collection: Record<string, unknown>,
+    errors: CollectionValidationError[]
+): void {
+    // Required fields
+    if (!collection.id) {
+        errors.push({
+            path: "id",
+            message: "Required field is missing"
+        });
+    } else if (typeof collection.id !== "string") {
+        errors.push({
+            path: "id",
+            message: "Must be a string"
+        });
+    }
+
+    if (!collection.name) {
+        errors.push({
+            path: "name",
+            message: "Required field is missing"
+        });
+    } else if (typeof collection.name !== "string") {
+        errors.push({
+            path: "name",
+            message: "Must be a string"
+        });
+    }
+
+    if (!collection.path) {
+        errors.push({
+            path: "path",
+            message: "Required field is missing"
+        });
+    } else if (typeof collection.path !== "string") {
+        errors.push({
+            path: "path",
+            message: "Must be a string"
+        });
+    }
+
+    // Properties validation
+    if (collection.properties !== undefined) {
+        validateProperties(collection.properties as unknown as Record<string, unknown>, "properties", errors);
+    }
+
+    // Optional fields
+    validateOptionalFields(collection, errors);
+}
+
+/**
+ * Validates a JSON string representing a collection configuration.
+ * Returns detailed validation errors if the JSON is invalid or doesn't match
+ * the expected collection schema.
+ */
+export function validateCollectionJson(jsonString: string): CollectionValidationResult {
+    const errors: CollectionValidationError[] = [];
+
+    // Try to parse JSON
+    let parsed: Record<string, unknown>;
+    try {
+        parsed = JSON.parse(jsonString);
+    } catch (e: unknown) {
+        // Try to extract line/column info from the error
+        const message_ = e instanceof Error ? e.message : String(e);
+        const match = message_.match(/position (\d+)/);
+        let message = "Invalid JSON syntax";
+        if (match) {
+            const position = parseInt(match[1], 10);
+            const lines = jsonString.substring(0, position).split("\n");
+            const line = lines.length;
+            const column = lines[lines.length - 1].length + 1;
+            message = `Invalid JSON syntax at line ${line}, column ${column}: ${message_}`;
+        } else {
+            message = `Invalid JSON syntax: ${message_}`;
+        }
+        return {
+            valid: false,
+            errors: [{
+                path: "",
+                message
+            }]
+        };
+    }
+
+    // Validate collection structure
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        return {
+            valid: false,
+            errors: [{
+                path: "",
+                message: "Collection must be an object"
+            }]
+        };
+    }
+
+    validateCollectionObject(parsed as unknown as Record<string, unknown>, errors);
+
+    return {
+        valid: errors.length === 0,
+        errors,
+        collection: errors.length === 0 ? parsed as unknown as EntityCollection : undefined
+    };
+}

package/src/collection_editor_ui.ts

@@ -0,0 +1,15 @@
+// Collection Editor UI — separate entry point for dynamic import / code splitting.
+// This file is the target of dynamic import() calls from CollectionEditorDialogs.tsx
+// so that the heavy collection editor UI code is split into its own chunk.
+
+export { CollectionEditorDialog } from "./collection_editor/ui/collection_editor/CollectionEditorDialog";
+export type { CollectionEditorDialogProps } from "./collection_editor/ui/collection_editor/CollectionEditorDialog";
+
+export { PropertyFormDialog, PropertyForm } from "./collection_editor/ui/collection_editor/PropertyEditView";
+export type { PropertyFormProps, OnPropertyChangedParams } from "./collection_editor/ui/collection_editor/PropertyEditView";
+
+export { CollectionStudioView } from "./collection_editor/ui/collection_editor/CollectionStudioView";
+export type { CollectionStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionStudioView";
+
+export { CollectionsStudioView } from "./collection_editor/ui/collection_editor/CollectionsStudioView";
+export type { CollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/CollectionsStudioView";

package/src/components/AdminModeSyncer.tsx

@@ -0,0 +1,56 @@
+import type { AppView } from "@rebasepro/types";
+import React, { useEffect } from "react";
+import { useLocation } from "react-router-dom";
+;
+import { useUrlController } from "../hooks";
+import { useAdminModeController } from "@rebasepro/core";
+export interface AdminModeSyncerProps {
+    /**
+     * Map of views designated as 'Studio' views.
+     * Navigating to any of these views will automatically flag the admin mode as "studio".
+     */
+    devViews?: AppView[];
+}
+
+/**
+ * A highly customizable utility component that observes react-router routes and
+ * actively shifts the internal Rebase `adminModeController` context to match
+ * the user's active window segment (e.g., Content vs Studio mode).
+ *
+ * Placing this anywhere safely inside the Rebase layout automatically triggers
+ * UI mode synchronization.
+ */
+export function AdminModeSyncer({ devViews }: AdminModeSyncerProps) {
+    const location = useLocation();
+    const urlController = useUrlController();
+    const adminModeController = useAdminModeController();
+
+    // Keep track of the current mode using a ref to avoid adding it to the dependency array
+    const currentModeRef = React.useRef(adminModeController.mode);
+    currentModeRef.current = adminModeController.mode;
+
+    // Stable ref for setMode so it doesn't trigger the effect
+    const setModeRef = React.useRef(adminModeController.setMode);
+    setModeRef.current = adminModeController.setMode;
+
+    useEffect(() => {
+        const path = location.pathname;
+        const isContentRoute = urlController.isUrlCollectionPath(path) || path === urlController.basePath;
+
+        // Check both devViews slugs AND the studio home path (/s or basePath/s)
+        const studioHomePath = urlController.basePath === "/" ? "/s" : `${urlController.basePath}/s`;
+        const isStudioRoute = path === studioHomePath || path.startsWith(studioHomePath + "/") || devViews?.some(view => {
+            const viewPath = urlController.buildAppUrlPath(view.slug);
+            return path.startsWith(`${viewPath}/`) || path === viewPath;
+        });
+
+        if (isStudioRoute && currentModeRef.current !== "studio") {
+            setModeRef.current("studio");
+        } else if (isContentRoute && currentModeRef.current !== "content") {
+            setModeRef.current("content");
+        }
+    }, [location.pathname, urlController, devViews]);
+
+    return null;
+}
+