@rebasepro/admin 0.6.1 → 0.8.0

package/src/types/fields.tsx

@@ -19,7 +19,6 @@ export type DefaultFieldConfig =
     | "multi_number_select"
     | "file_upload"
     | "multi_file_upload"
-    | "reference_as_string"
     | "reference"
     | "multi_references"
     | "relation"
@@ -51,12 +50,8 @@ export interface FieldProps<
     /**
      * Current value of this field, inferred from the property type P
      */
-    value: any;
-
-    /**
-     * Set value of field directly
-     */
-    setValue: (value: any | null, shouldValidate?: boolean) => void;
+    value: InferPropertyType<P> | any;
+    setValue: (value: InferPropertyType<P> | null | any, shouldValidate?: boolean) => void;
 
     /**
      * Set value of a different field directly
@@ -213,7 +208,7 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
 
     savingError?: Error;
 
-    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+    openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
 
     /**
      * This is the underlying formex controller that powers the form.
@@ -223,6 +218,12 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     formex: FormexController<M>;
 
     disabled: boolean;
+
+    /**
+     * Whether the form context is in read-only detail view mode.
+     * Custom entity views can use this to adjust their rendering.
+     */
+    readOnly?: boolean;
 }
 
 /**

package/src/util/dataControllerAdapter.ts

@@ -0,0 +1,93 @@
+/**
+ * Adapts an `EntityTableController<M>` (from @rebasepro/types) to a
+ * `CollectionDataController<T>` (from @rebasepro/ui), bridging the
+ * entity-aware data layer to the headless collection view.
+ */
+
+import { useMemo } from "react";
+import type { Entity, EntityTableController } from "@rebasepro/types";
+import type { CollectionDataController } from "@rebasepro/ui";
+
+/**
+ * Flatten Entity<M> objects to plain row objects.
+ * The headless view works with flat `Record<string, unknown>` rows,
+ * while the entity system uses `{ id, path, values: M }`.
+ *
+ * The flattened row includes `id` and `path` at the top level,
+ * plus all values spread.
+ */
+function flattenEntities<M extends Record<string, unknown>>(
+    entities: Entity<M>[]
+): Array<M & { id: string | number; path: string }> {
+    return entities.map(entity => ({
+        id: entity.id,
+        path: entity.path,
+        ...entity.values
+    }));
+}
+
+/**
+ * React hook that adapts an EntityTableController to a CollectionDataController.
+ *
+ * Usage:
+ * ```tsx
+ * const tableController = useDataTableController({ path, collection });
+ * const dataController = useCollectionDataController(tableController);
+ *
+ * <CollectionView dataController={dataController} ... />
+ * ```
+ */
+export function useCollectionDataController<M extends Record<string, unknown>>(
+    tableController: EntityTableController<M>
+): CollectionDataController<M & { id: string | number; path: string }> {
+    const flatData = useMemo(
+        () => flattenEntities(tableController.data),
+        [tableController.data]
+    );
+
+    return useMemo((): CollectionDataController<M & { id: string | number; path: string }> => ({
+        data: flatData,
+        loading: tableController.dataLoading,
+        noMoreToLoad: tableController.noMoreToLoad,
+        error: tableController.dataLoadingError,
+
+        filterValues: tableController.filterValues as Record<string, [string, unknown]> | undefined,
+        setFilterValues: tableController.setFilterValues as
+            ((values: Record<string, [string, unknown]> | undefined) => void) | undefined,
+
+        sortBy: tableController.sortBy,
+        setSortBy: tableController.setSortBy,
+
+        searchString: tableController.searchString,
+        setSearchString: tableController.setSearchString,
+
+        clearFilter: tableController.clearFilter,
+
+        initialScroll: tableController.initialScroll,
+        onScroll: tableController.onScroll,
+
+        paginationEnabled: tableController.paginationEnabled,
+        pageSize: tableController.pageSize,
+        itemCount: tableController.itemCount,
+        setItemCount: tableController.setItemCount,
+    }), [flatData, tableController]);
+}
+
+/**
+ * Non-hook version for cases where you already have the data
+ * and just need to build a static controller.
+ */
+export function createStaticDataController<T extends Record<string, unknown>>(
+    data: T[],
+    options?: {
+        loading?: boolean;
+        error?: Error;
+    }
+): CollectionDataController<T> {
+    return {
+        data,
+        loading: options?.loading ?? false,
+        noMoreToLoad: true,
+        error: options?.error,
+    };
+}

package/src/util/navigation_utils.ts

@@ -31,7 +31,7 @@ export function navigateToEntity({
 }:
 
     {
-        openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
+        openEntityMode?: "side_panel" | "full_screen" | "split" | "dialog";
         collection?: EntityCollection;
         entityId?: string | number;
         selectedTab?: string;

package/src/util/previews.ts

@@ -8,6 +8,25 @@ function isHiddenProperty(property: Property | undefined): boolean {
     return Boolean(property.ui?.hideFromCollection);
 }
 
+/**
+ * Returns true when the property holds file-storage content (single image,
+ * array of images, generic upload, …).  These properties are rendered by the
+ * dedicated image-slot and should NOT appear as regular preview columns.
+ */
+function isStorageProperty(property: Property | undefined): boolean {
+    if (!property) return false;
+    // Single string with storage config
+    if (property.type === "string" && property.storage) return true;
+    // String displayed as image URL
+    if (property.type === "string" && property.ui?.url === "image") return true;
+    // Array whose inner element has storage config or image URL
+    if (property.type === "array" && property.of && !Array.isArray(property.of)) {
+        const inner = property.of;
+        if (inner.type === "string" && (inner.storage || inner.ui?.url === "image")) return true;
+    }
+    return false;
+}
+
 export function getEntityPreviewKeys(
     authController: AuthController,
     targetCollection: EntityCollection<any>,
@@ -33,6 +52,7 @@ export function getEntityPreviewKeys(
             .filter(key => {
                 const property = targetCollection.properties[key];
                 return property && !isPropertyBuilder(property) && !isReferenceProperty(property) && !isHiddenProperty(property)
+                    && !isStorageProperty(property as Property)
                     && (hasExplicitOrder || !isRelationProperty(property));
             }).slice(0, limit);
     }

package/src/util/propertyConfigMapper.ts

@@ -0,0 +1,134 @@
+/**
+ * Maps a Rebase `Property` (from @rebasepro/types) to a `CollectionPropertyConfig`
+ * (from @rebasepro/ui), stripping all entity-specific fields and keeping only
+ * the UI-relevant subset.
+ *
+ * This is the bridge between the entity-aware and headless layers.
+ */
+
+import type { Property, Properties, EnumValues, EnumValueConfig } from "@rebasepro/types";
+import type { CollectionPropertyConfig, CollectionEnumValueConfig } from "@rebasepro/ui";
+
+/**
+ * Map Rebase property types to headless-supported types.
+ * `vector` and `binary` are not directly renderable, so we fall back to `string`.
+ */
+const TYPE_MAP: Record<string, CollectionPropertyConfig["type"]> = {
+    string: "string",
+    number: "number",
+    boolean: "boolean",
+    date: "date",
+    geopoint: "geopoint",
+    reference: "reference",
+    relation: "relation",
+    array: "array",
+    map: "map",
+    vector: "string",   // vectors display as text
+    binary: "string",   // binary displays as text
+};
+
+/**
+ * Convert a single Property to a CollectionPropertyConfig.
+ */
+export function mapPropertyToConfig(property: Property): CollectionPropertyConfig {
+    const base: CollectionPropertyConfig = {
+        type: TYPE_MAP[property.type] ?? "string",
+        name: property.name,
+        description: property.description,
+        columnWidth: property.ui?.columnWidth,
+        hideFromCollection: property.ui?.hideFromCollection,
+    };
+
+    // String-specific
+    if (property.type === "string") {
+        if (property.enum) {
+            base.enum = mapEnumValues(property.enum);
+        }
+        if (property.ui?.multiline) base.multiline = true;
+        if (property.ui?.previewAsTag) base.previewAsTag = true;
+        if (property.ui?.url) base.url = property.ui.url;
+        if (property.ui?.markdown) base.markdown = true;
+        if (property.storage) base.storage = true;
+        if (property.email) base.email = true;
+    }
+
+    // Number-specific
+    if (property.type === "number" && property.enum) {
+        base.enum = mapEnumValues(property.enum);
+    }
+
+    // Array-specific
+    if (property.type === "array" && property.of && !Array.isArray(property.of)) {
+        base.of = mapPropertyToConfig(property.of);
+    }
+
+    // Map-specific
+    if (property.type === "map" && property.properties) {
+        base.properties = mapPropertiesToConfigs(property.properties);
+        if (property.propertiesOrder) {
+            base.propertiesOrder = property.propertiesOrder;
+        }
+    }
+
+    // Date-specific
+    if (property.type === "date" && property.mode) {
+        base.mode = property.mode;
+    }
+
+    // Custom preview component
+    if (property.ui?.Preview) {
+        // The connected wrapper will handle this by injecting via cellRenderer override
+        // We don't copy it here because Preview may reference entity-aware components
+    }
+
+    return base;
+}
+
+/**
+ * Convert a Properties record to a CollectionPropertyConfig record.
+ */
+export function mapPropertiesToConfigs(
+    properties: Properties
+): Record<string, CollectionPropertyConfig> {
+    const result: Record<string, CollectionPropertyConfig> = {};
+    for (const [key, property] of Object.entries(properties)) {
+        result[key] = mapPropertyToConfig(property);
+    }
+    return result;
+}
+
+/**
+ * Convert Rebase EnumValues to CollectionEnumValueConfig format.
+ * Handles both array form (EnumValueConfig[]) and record form.
+ */
+function mapEnumValues(
+    enumValues: EnumValues | undefined
+): Record<string, CollectionEnumValueConfig> | Map<string | number, CollectionEnumValueConfig> | undefined {
+    if (!enumValues) return undefined;
+
+    // Array form: EnumValueConfig[]
+    if (Array.isArray(enumValues)) {
+        const result: Record<string, CollectionEnumValueConfig> = {};
+        for (const item of enumValues) {
+            result[String(item.id)] = normalizeEnumValueConfig(item);
+        }
+        return result;
+    }
+
+    // Record form: Record<string | number, string | EnumValueConfig>
+    const result: Record<string, CollectionEnumValueConfig> = {};
+    for (const [key, value] of Object.entries(enumValues)) {
+        result[key] = typeof value === "string"
+            ? value
+            : normalizeEnumValueConfig(value);
+    }
+    return result;
+}
+
+function normalizeEnumValueConfig(config: EnumValueConfig): CollectionEnumValueConfig {
+    return {
+        label: config.label,
+        color: typeof config.color === "string" ? config.color : undefined,
+        disabled: config.disabled,
+    };
+}

package/src/util/property_utils.tsx

@@ -1,6 +1,6 @@
 
 import type { Properties } from "@rebasepro/types";
-import type { EntityCollection, MapProperty, Property, PropertyConfig, StringProperty } from "@rebasepro/types";
+import type { EntityCollection, MapProperty, Property, PropertyConfig } from "@rebasepro/types";
 import React from "react";
 
 import { isPropertyBuilder } from "@rebasepro/common";
@@ -75,7 +75,6 @@ function getDefaultIconForProperty(property: Property): LucideIcon {
             if (property.ui?.url) return GlobeIcon;
             if (property.email) return MailIcon;
             if (property.ui?.multiline || property.ui?.markdown) return AlignLeftIcon;
-            if ((property as StringProperty).reference) return LinkIcon;
             return TextIcon;
         }
         case "number":