@rebasepro/cms 0.17.3 → 0.18.0

package/src/collection_editor/validateCollectionJson.ts

@@ -1,440 +0,0 @@
-import { DataType } from "@rebasepro/types";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-/**
- * Valid dataType values for properties
- */
-const VALID_DATA_TYPES = [
-    "string",
-    "number",
-    "boolean",
-    "date",
-    "geopoint",
-    "reference",
-    "relation",
-    "array",
-    "map",
-    "vector",
-    "binary"
-] as const;
-
-/**
- * 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?: AdminCollection;
-}
-
-/**
- * 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 type
-    if (!property.type) {
-        errors.push({
-            path: `${path}.type`,
-            message: "Required field is missing"
-        });
-    } else if (!VALID_DATA_TYPES.includes(property.type as DataType)) {
-        errors.push({
-            path: `${path}.type`,
-            message: `Invalid value "${property.type}", 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.type === "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 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 Record<string, unknown>).properties) {
-                validateProperties((property.oneOf as Record<string, unknown>).properties as Record<string, unknown>, `${path}.oneOf.properties`, errors);
-            }
-        }
-    }
-
-    // Validate map properties
-    if (property.type === "map" && property.properties) {
-        validateProperties(property.properties as Record<string, unknown>, `${path}.properties`, errors);
-    }
-
-    // Validate reference path
-    if (property.type === "reference") {
-        if (property.path !== undefined && typeof property.path !== "string") {
-            errors.push({
-                path: `${path}.path`,
-                message: "Must be a string"
-            });
-        }
-    }
-
-    // Validate relation property
-    if (property.type === "relation") {
-        const link = property.relation as Record<string, unknown> | undefined;
-        if (link !== undefined) {
-            const KINDS = ["belongsTo", "hasOne", "hasMany", "manyToMany", "via"];
-            if (typeof link.kind !== "string" || !KINDS.includes(link.kind)) {
-                errors.push({
-                    path: `${path}.relation.kind`,
-                    message: `Must be one of ${KINDS.join(", ")}`
-                });
-            }
-
-            if (link.target !== undefined && typeof link.target !== "string" && typeof link.target !== "function") {
-                errors.push({
-                    path: `${path}.relation.target`,
-                    message: "Must be a collection slug or a thunk returning a collection"
-                });
-            }
-
-            // Each kind admits exactly one link field. Anything else on it is
-            // a leftover from another shape and would previously have been
-            // silently honoured by whichever consumer read it first.
-            const allowedByKind: Record<string, string[]> = {
-                belongsTo: ["localKey"],
-                hasOne: ["foreignKeyOnTarget", "sourceKey"],
-                hasMany: ["foreignKeyOnTarget", "sourceKey"],
-                manyToMany: ["through"],
-                via: ["joinPath", "cardinality"]
-            };
-            const linkFields = ["localKey", "foreignKeyOnTarget", "sourceKey", "through", "joinPath", "cardinality"];
-            const allowed = allowedByKind[String(link.kind)] ?? [];
-            for (const field of linkFields) {
-                if (link[field] !== undefined && !allowed.includes(field)) {
-                    errors.push({
-                        path: `${path}.relation.${field}`,
-                        message: `Not valid on a "${String(link.kind)}" relation`
-                    });
-                }
-            }
-
-            if (link.kind === "via" && !Array.isArray(link.joinPath)) {
-                errors.push({
-                    path: `${path}.relation.joinPath`,
-                    message: "A `via` relation requires a joinPath array"
-                });
-            }
-        }
-    }
-
-    // Validate vector property
-    if (property.type === "vector") {
-        if (property.dimensions !== undefined && (typeof property.dimensions !== "number" || isNaN(property.dimensions) || property.dimensions <= 0)) {
-            errors.push({
-                path: `${path}.dimensions`,
-                message: "Must be a positive number"
-            });
-        }
-    }
-
-    // Validate storage config for string
-    if (property.type === "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 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 Record<string, unknown>).columnProperty !== undefined &&
-            typeof (collection.kanban 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 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 Record<string, unknown>, errors);
-
-    return {
-        valid: errors.length === 0,
-        errors,
-        collection: errors.length === 0 ? parsed as unknown as AdminCollection : undefined
-    };
-}

package/src/collection_editor_ui.ts

@@ -1,21 +0,0 @@
-// 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";
-
-export { RouterCollectionStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
-export type { RouterCollectionStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionStudioView";
-
-export { RouterCollectionsStudioView } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";
-export type { RouterCollectionsStudioViewProps } from "./collection_editor/ui/collection_editor/RouterCollectionsStudioView";

package/src/components/AdditionalFieldValue.tsx

@@ -1,68 +0,0 @@
-import type { AdditionalFieldDelegate, RebaseContext } from "@rebasepro/cms-types";
-import type { Entity } from "@rebasepro/types";
-import React, { useEffect, useState } from "react";
-
-export interface AdditionalFieldValueProps<M extends Record<string, unknown>> {
-    field: AdditionalFieldDelegate<M>;
-    entity: Entity<M>;
-    context: RebaseContext;
-}
-
-/**
- * Renders an `additionalFields` entry that supplies a `value` rather than a
- * `Builder`.
- *
- * `value` is typed `string | number | Promise<string | number>`, and the promise
- * arm has been part of that type from the start — the CSV export awaits it
- * correctly. Every *renderer* called `.toString()` on the result instead, so an
- * async value drew the literal text `[object Promise]` in the cell: a shape the
- * type promised, that worked in one of its two consumers, and failed silently in
- * the other. That is what made the obvious port of a FireCMS column — one that
- * fetches a title from a subcollection — look supported and not be.
- *
- * Three call sites had the same three lines copied between them (the table cell,
- * the form and the read-only record), which is why the bug reached all three.
- * Now there is one.
- */
-export function AdditionalFieldValue<M extends Record<string, unknown>>({
-    field,
-    entity,
-    context
-}: AdditionalFieldValueProps<M>) {
-
-    const [resolved, setResolved] = useState<string | number | undefined>(() => {
-        const value = field.value?.({ entity, context });
-        // A synchronous value is available on the first render, so it never
-        // flashes empty on its way in.
-        return isPromise(value) ? undefined : value;
-    });
-
-    useEffect(() => {
-        const value = field.value?.({ entity, context });
-        if (!isPromise(value)) {
-            setResolved(value);
-            return;
-        }
-
-        // The row may scroll out, or the record change, before this lands.
-        let live = true;
-        value.then(
-            result => {
-                if (live) setResolved(result);
-            },
-            error => {
-                if (live) setResolved(undefined);
-                console.warn(`[rebase] Additional field "${field.key}" failed to resolve:`, error);
-            }
-        );
-        return () => {
-            live = false;
-        };
-    }, [field, entity, context]);
-
-    return <>{resolved === undefined || resolved === null ? null : String(resolved)}</>;
-}
-
-function isPromise(value: unknown): value is Promise<string | number | undefined> {
-    return typeof (value as Promise<unknown> | undefined)?.then === "function";
-}

package/src/components/AdminModeSyncer.tsx

@@ -1,56 +0,0 @@
-import type { AppView } from "@rebasepro/cms-types";
-import React, { useEffect } from "react";
-import { useLocation } from "react-router";
-;
-import { useUrlController } from "../hooks/navigation/contexts/UrlContext";
-import { useAdminModeController } from "@rebasepro/app";
-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 !== "cms") {
-            setModeRef.current("cms");
-        }
-    }, [location.pathname, urlController, devViews]);
-
-    return null;
-}
-