@rebasepro/admin 0.10.0 → 0.10.1-canary.0a881d4

package/src/hooks/navigation/useBuildNavigationStateController.tsx

@@ -1,16 +1,18 @@
-import type { AppView, CollectionConfig, NavigationResult, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping } from "@rebasepro/types";
+
+import type { AppView, NavigationResult, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping, AdminCollection } from "@rebasepro/admin-types";
 import { useCallback, useMemo, useRef } from "react";
 
-import { AuthController, RebaseData, CollectionRegistryController, User } from "@rebasepro/types";
-import type { CollectionConfigsBuilder, AppViewsBuilder, EffectiveRoleController } from "@rebasepro/types";
+import { RebaseData, CollectionRegistryController, User } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/admin-types";
+import type { EffectiveRoleController } from "@rebasepro/types";
+import type { CollectionConfigsBuilder, AppViewsBuilder } from "@rebasepro/admin-types";
 import { CollectionRegistry } from "@rebasepro/common";
 
-
 import { useResolvedCollections } from "./useResolvedCollections";
 import { useResolvedViews } from "./useResolvedViews";
 import { useTopLevelNavigation } from "./useTopLevelNavigation";
 
-export type BuildNavigationStateProps<EC extends CollectionConfig, USER extends User> = {
+export type BuildNavigationStateProps<EC extends AdminCollection, USER extends User> = {
     authController: AuthController<USER>;
     collections?: EC[] | CollectionConfigsBuilder<EC>;
     views?: AppView[] | AppViewsBuilder;
@@ -37,7 +39,7 @@ export type BuildNavigationStateProps<EC extends CollectionConfig, USER extends
  *
  * The NavigationStateController type is preserved as a public API.
  */
-export function useBuildNavigationStateController<EC extends CollectionConfig, USER extends User>(
+export function useBuildNavigationStateController<EC extends AdminCollection, USER extends User>(
     props: BuildNavigationStateProps<EC, USER>
 ): NavigationStateController {
 

package/src/hooks/navigation/useBuildUrlController.tsx

@@ -1,6 +1,6 @@
-import type { UrlController, NavigateOptions } from "@rebasepro/types";
+import type { UrlController, NavigateOptions } from "@rebasepro/admin-types";
 import { useCallback, useMemo } from "react";
-import { removeInitialAndTrailingSlashes, resolveCollectionPathIds } from "@rebasepro/common";
+import { removeInitialAndTrailingSlashes, resolveCollectionPathIds } from "@rebasepro/app";
 import { CollectionRegistryController } from "@rebasepro/types";
 import { useNavigate } from "react-router-dom";
 

package/src/hooks/navigation/useNavigationResolution.ts

@@ -1,15 +1,7 @@
-import type {
-    AppView,
-    AppViewsBuilder,
-    AuthCollectionConfig,
-    EntityAction,
-    CollectionConfig,
-    CollectionConfigsBuilder,
-    RebaseContext,
-    RebasePlugin,
-    UserCreationResult
-} from "@rebasepro/types";
-import { type AuthController, type User, type RebaseData } from "@rebasepro/types";
+import type { AuthCollectionConfig } from "@rebasepro/types";
+import type { AppView, AppViewsBuilder, EntityAction, CollectionConfigsBuilder, RebaseContext, RebasePlugin, UserCreationResult, AdminCollection } from "@rebasepro/admin-types";
+import { type User, type RebaseData } from "@rebasepro/types";
+import { type AuthController } from "@rebasepro/admin-types";
 import { canReadCollection } from "@rebasepro/common";
 import { resetPasswordAction } from "../../components/common/default_entity_actions";
 import { CreationResultDialog } from "../../components/admin/CreationResultDialog";
@@ -23,7 +15,7 @@ function isRebaseContext(ctx: unknown): ctx is RebaseContext {
     return typeof ctx === "object" && ctx !== null && "dialogsController" in ctx;
 }
 
-export function filterOutNotAllowedCollections(resolvedCollections: CollectionConfig[], authController: AuthController): CollectionConfig[] {
+export function filterOutNotAllowedCollections(resolvedCollections: AdminCollection[], authController: AuthController): AdminCollection[] {
     return resolvedCollections
         .filter((c) => canReadCollection(c, authController))
         .map((c) => {
@@ -35,8 +27,8 @@ export function filterOutNotAllowedCollections(resolvedCollections: CollectionCo
         });
 }
 
-export function applyPluginModifyCollection(resolvedCollections: CollectionConfig[], modifyCollection: (collection: CollectionConfig) => CollectionConfig): CollectionConfig[] {
-    return resolvedCollections.map((collection): CollectionConfig => {
+export function applyPluginModifyCollection(resolvedCollections: AdminCollection[], modifyCollection: (collection: AdminCollection) => AdminCollection): AdminCollection[] {
+    return resolvedCollections.map((collection): AdminCollection => {
         const modifiedCollection = modifyCollection(collection);
         if (modifiedCollection.childCollections) {
             return {
@@ -64,9 +56,9 @@ export function applyPluginModifyCollection(resolvedCollections: CollectionConfi
  * Skips injection if the collection already has the action/callback present.
  */
 function injectAuthCollectionConfig(
-    collections: CollectionConfig[],
+    collections: AdminCollection[],
     adminPasswordResetSupported: boolean
-): CollectionConfig[] {
+): AdminCollection[] {
     return collections.map((collection) => {
         const authProp = collection.auth;
         if (!authProp) return collection;
@@ -87,7 +79,9 @@ function injectAuthCollectionConfig(
         } else if (typeof resetPref === "object") {
             // An explicitly supplied action is the collection author's own; they
             // own its backend, so the adapter capability doesn't apply.
-            actionToInject = resetPref;
+            // `auth.actions.resetPassword`'s object form is an EntityAction; core
+            // types it as `object` because a server never renders one.
+            actionToInject = resetPref as EntityAction;
         } else if (!adminPasswordResetSupported) {
             actionToInject = undefined;
         } else {
@@ -162,12 +156,12 @@ function injectAuthCollectionConfig(
 }
 
 export async function resolveCollections(
-    collections: undefined | CollectionConfig[] | CollectionConfigsBuilder,
+    collections: undefined | AdminCollection[] | CollectionConfigsBuilder,
     authController: AuthController,
     data: RebaseData,
     plugins: RebasePlugin[] | undefined
-): Promise<CollectionConfig[]> {
-    let resolvedCollections: CollectionConfig[] = [];
+): Promise<AdminCollection[]> {
+    let resolvedCollections: AdminCollection[] = [];
     if (typeof collections === "function") {
         resolvedCollections = await collections({
             user: authController.user,

package/src/hooks/navigation/useResolvedCollections.ts

@@ -1,16 +1,17 @@
-import type { CollectionConfig, RebasePlugin } from "@rebasepro/types";
+
+import type { RebasePlugin, AdminCollection } from "@rebasepro/admin-types";
 import { useRef, useMemo } from "react";
 
-import { AuthController, CollectionRegistryController, RebaseData, User } from "@rebasepro/types";
-import type { CollectionConfigsBuilder } from "@rebasepro/types";
+import { CollectionRegistryController, RebaseData, User } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/admin-types";
+import type { CollectionConfigsBuilder } from "@rebasepro/admin-types";
 import { CollectionRegistry } from "@rebasepro/common";
 
-
 import { resolveCollections } from "./useNavigationResolution";
 import { areCollectionListsEqual } from "./utils";
 import { useAsyncResolver } from "./useAsyncResolver";
 
-export type UseResolvedCollectionsProps<EC extends CollectionConfig, USER extends User> = {
+export type UseResolvedCollectionsProps<EC extends AdminCollection, USER extends User> = {
     authController: AuthController<USER>;
     collections?: EC[] | CollectionConfigsBuilder<EC>;
     data: RebaseData;
@@ -21,7 +22,7 @@ export type UseResolvedCollectionsProps<EC extends CollectionConfig, USER extend
 };
 
 export type UseResolvedCollectionsResult = {
-    collections: CollectionConfig[];
+    collections: AdminCollection[];
     loading: boolean;
     error: Error | undefined;
     refresh: () => void;
@@ -29,7 +30,7 @@ export type UseResolvedCollectionsResult = {
 
 /**
  * Hook that resolves collection props (which may be async builders or arrays)
- * into concrete CollectionConfig[], and registers them with the CollectionRegistry.
+ * into concrete AdminCollection[], and registers them with the CollectionRegistry.
  *
  * When userManagement is provided, the default users collection is always
  * prepended. Developer collections override via generic slug-based dedup
@@ -38,7 +39,7 @@ export type UseResolvedCollectionsResult = {
  * Uses refs for potentially-unstable dependencies (driver, authController,
  * plugins) to avoid re-triggering effects when their object identity changes.
  */
-export function useResolvedCollections<EC extends CollectionConfig, USER extends User>(
+export function useResolvedCollections<EC extends AdminCollection, USER extends User>(
     props: UseResolvedCollectionsProps<EC, USER>
 ): UseResolvedCollectionsResult {
 
@@ -66,7 +67,7 @@ export function useResolvedCollections<EC extends CollectionConfig, USER extends
     const pluginsRef = useRef(plugins);
     pluginsRef.current = plugins;
 
-    const { data: collections, loading, error, refresh } = useAsyncResolver<CollectionConfig[]>({
+    const { data: collections, loading, error, refresh } = useAsyncResolver<AdminCollection[]>({
         resolver: async () => {
             const resolved = await resolveCollections(
                 collectionsProp,

package/src/hooks/navigation/useResolvedViews.tsx

@@ -1,5 +1,6 @@
 
-import type { AppView, AppViewsBuilder, EffectiveRoleController, RebasePlugin } from "@rebasepro/types";
+import type { EffectiveRoleController } from "@rebasepro/types";
+import type { AppView, AppViewsBuilder, RebasePlugin } from "@rebasepro/admin-types";
 import { useMemo, useRef } from "react";
 
 /**
@@ -17,7 +18,8 @@ function viewSlugsEqual(a: AppView[] | undefined, b: AppView[] | undefined): boo
     return true;
 }
 
-import type { AuthController, RebaseData, User } from "@rebasepro/types";
+import type { RebaseData, User } from "@rebasepro/types";
+import type { AuthController } from "@rebasepro/admin-types";
 
 import { resolveAppViews } from "./useNavigationResolution";
 import { useAsyncResolver } from "./useAsyncResolver";

package/src/hooks/navigation/useTopLevelNavigation.ts

@@ -1,4 +1,5 @@
-import type { AppView, UrlController, CollectionConfig, RebasePlugin, NavigationEntry, NavigationGroupMapping, NavigationResult } from "@rebasepro/types";
+
+import type { AppView, UrlController, RebasePlugin, NavigationEntry, NavigationGroupMapping, NavigationResult, AdminCollection } from "@rebasepro/admin-types";
 import { useCallback, useMemo, useRef } from "react";
 import { deepEqual as equal } from "fast-equals";
 
@@ -8,7 +9,7 @@ import { CollectionRegistry } from "@rebasepro/common";
 import { computeNavigationGroups, getGroup, NAVIGATION_ADMIN_GROUP_NAME, NAVIGATION_DEFAULT_GROUP_NAME } from "./utils";
 
 export type UseTopLevelNavigationProps = {
-    collections: CollectionConfig[];
+    collections: AdminCollection[];
     views: AppView[] | undefined;
     adminViews: AppView[] | undefined;
     plugins?: RebasePlugin[];

package/src/hooks/navigation/utils.ts

@@ -1,4 +1,5 @@
-import type { AppView, CollectionConfig, RebasePlugin, NavigationGroupMapping } from "@rebasepro/types";
+
+import type { AppView, RebasePlugin, NavigationGroupMapping, AdminCollection } from "@rebasepro/admin-types";
 
 import { getSubcollections } from "@rebasepro/common";
 import { deepEqual as equal } from "fast-equals";
@@ -6,7 +7,7 @@ import { deepEqual as equal } from "fast-equals";
 export const NAVIGATION_DEFAULT_GROUP_NAME = "Views";
 export const NAVIGATION_ADMIN_GROUP_NAME = "Admin";
 
-export function getGroup(collectionOrView: CollectionConfig | AppView) {
+export function getGroup(collectionOrView: AdminCollection | AppView) {
     const trimmed = collectionOrView.group?.trim();
     if (!trimmed || trimmed === "") {
         return NAVIGATION_DEFAULT_GROUP_NAME;
@@ -21,7 +22,7 @@ export function computeNavigationGroups({
     plugins
 }: {
     navigationGroupMappings?: NavigationGroupMapping[],
-    collections?: CollectionConfig[],
+    collections?: AdminCollection[],
     views?: AppView[],
     plugins?: RebasePlugin[]
 }): NavigationGroupMapping[] {
@@ -146,7 +147,7 @@ export function computeNavigationGroups({
     return result;
 }
 
-export function areCollectionListsEqual(a: CollectionConfig[], b: CollectionConfig[], visitedSlugs: string[] = []) {
+export function areCollectionListsEqual(a: AdminCollection[], b: AdminCollection[], visitedSlugs: string[] = []) {
     if (a.length !== b.length) {
         return false;
     }
@@ -157,7 +158,7 @@ export function areCollectionListsEqual(a: CollectionConfig[], b: CollectionConf
     return aSorted.every((value, index) => areCollectionsEqual(value, bSorted[index], visitedSlugs));
 }
 
-export function areCollectionsEqual(a: CollectionConfig, b: CollectionConfig, visitedSlugs: string[] = []) {
+export function areCollectionsEqual(a: AdminCollection, b: AdminCollection, visitedSlugs: string[] = []) {
     if (a.slug !== b.slug) {
         return false;
     }

package/src/hooks/useBreadcrumbsController.tsx

@@ -1,6 +1,6 @@
 import { useContext } from "react";
 import { BreadcrumbContext } from "../contexts/BreacrumbsContext";
-import { BreadcrumbEntry, BreadcrumbsController } from "@rebasepro/types";
+import { BreadcrumbEntry, BreadcrumbsController } from "@rebasepro/admin-types";
 
 export type { BreadcrumbEntry, BreadcrumbsController };
 

package/src/hooks/useBuildSidePanel.tsx

@@ -1,15 +1,12 @@
-import type { CollectionConfig } from "@rebasepro/types";
-import type { CustomizationController, SidePanelBindingProps, SideDialogPanelProps, SideDialogsController, SidePanelController, UrlController, NavigationStateController, Property } from "@rebasepro/types";
+
+import type { Property } from "@rebasepro/types";
+import type { CustomizationController, SidePanelBindingProps, SideDialogPanelProps, SideDialogsController, SidePanelController, UrlController, NavigationStateController, AdminCollection } from "@rebasepro/admin-types";
 import { useCallback, useEffect, useRef, useMemo } from "react";
-import { AuthController, CollectionRegistryController } from "@rebasepro/types";
+import { CollectionRegistryController } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/admin-types";
 import { useLocation } from "react-router-dom";
-import {
-    getNavigationEntriesFromPath,
-    NavigationViewInternal,
-    removeInitialAndTrailingSlashes,
-    removeTrailingSlash,
-    resolveDefaultSelectedView
-} from "@rebasepro/common";
+import { NavigationViewInternal } from "@rebasepro/app";
+import { getNavigationEntriesFromPath, removeInitialAndTrailingSlashes, removeTrailingSlash, resolveDefaultSelectedView } from "@rebasepro/app";
 import { resolvedSelectedEntityView } from "../util/resolutions";
 import { ADDITIONAL_TAB_WIDTH, CONTAINER_FULL_WIDTH, FORM_CONTAINER_WIDTH } from "@rebasepro/app";
 import { useCustomizationController, useLargeLayout, useComponentOverride, CollectionScopeProvider } from "@rebasepro/app";
@@ -73,7 +70,7 @@ export function getEntityViewWidth(props: SidePanelBindingProps<any>, small: boo
 
 const collectionViewWidthCache: { [key: string]: string } = {};
 
-function calculateCollectionDesiredWidth(collection: CollectionConfig<any>): string {
+function calculateCollectionDesiredWidth(collection: AdminCollection<any>): string {
     if (collectionViewWidthCache[collection.slug]) {
         return collectionViewWidthCache[collection.slug];
     }
@@ -240,7 +237,7 @@ width: newWidth };
     }), [close, open, replace]);
 };
 
-export function buildSidePanelsFromUrl(path: string, collections: CollectionConfig[], newFlag: boolean): SidePanelBindingProps<any>[] {
+export function buildSidePanelsFromUrl(path: string, collections: AdminCollection[], newFlag: boolean): SidePanelBindingProps<any>[] {
 
     const navigationViewsForPath: NavigationViewInternal<any>[] = getNavigationEntriesFromPath({
         path,

package/src/hooks/useCMSContext.tsx

@@ -1,17 +1,21 @@
 import { useMemo } from "react";
 import { useRebaseContext } from "@rebasepro/app";
+import type {
+    User
+} from "@rebasepro/types";
 import type {
     AuthController,
     RebaseContext,
     SideDialogsController,
-    SidePanelController,
-    User
+    SidePanelController
+} from "@rebasepro/admin-types";
+import type {
+    CollectionRegistryController
 } from "@rebasepro/types";
 import type {
-    CollectionRegistryController,
     NavigationStateController,
     UrlController
-} from "@rebasepro/types";
+} from "@rebasepro/admin-types";
 import { useSidePanel } from "./useSidePanel";
 import { useSideDialogsController } from "./useSideDialogsController";
 import {

package/src/hooks/useResolvedNavigationFrom.tsx

@@ -1,7 +1,9 @@
-import type { CollectionConfig, EntityCustomView } from "@rebasepro/types";
-import { Entity, RebaseContext, User } from "@rebasepro/types";
+
+import type { EntityCustomView, AdminCollection } from "@rebasepro/admin-types";
+import { Entity, User } from "@rebasepro/types";
+import { RebaseContext } from "@rebasepro/admin-types";
 import { useEffect, useState, useMemo } from "react";
-import { getNavigationEntriesFromPath } from "@rebasepro/common";
+import { getNavigationEntriesFromPath } from "@rebasepro/app";
 import { useCMSContext } from "./useCMSContext";
 
 /**
@@ -22,7 +24,7 @@ export interface ResolvedNavigationEntity<M extends Record<string, unknown>> {
     entity: Entity<M>;
     entityId: string | number;
     path: string;
-    parentCollection: CollectionConfig<M>;
+    parentCollection: AdminCollection<M>;
 }
 
 /**
@@ -32,7 +34,7 @@ export interface ResolvedNavigationEntity<M extends Record<string, unknown>> {
 export interface ResolvedNavigationCollection<M extends Record<string, unknown>> {
     type: "collection";
     path: string;
-    collection: CollectionConfig<M>;
+    collection: AdminCollection<M>;
 }
 
 /**

package/src/hooks/useResolvedUsers.ts

@@ -0,0 +1,143 @@
+import { useEffect, useState } from "react";
+import type { User } from "@rebasepro/types";
+import { useAuthController, useRebaseClient } from "@rebasepro/app";
+
+/**
+ * Resolves the auth users behind `userSelect` values.
+ *
+ * A collection view can ask for dozens of ids at once — one per row — so
+ * lookups are coalesced into a single `GET /api/users?ids=…` per tick and
+ * cached per base URL. Ids that resolve to nothing are remembered too, so a
+ * dangling reference is not retried on every render.
+ */
+
+interface UserCache {
+    users: Map<string, User | null>;
+    pending: Map<string, Promise<void>>;
+    queue: Set<string>;
+    flush?: ReturnType<typeof setTimeout>;
+}
+
+const caches = new Map<string, UserCache>();
+
+function getCache(baseUrl: string): UserCache {
+    let cache = caches.get(baseUrl);
+    if (!cache) {
+        cache = { users: new Map(),
+pending: new Map(),
+queue: new Set() };
+        caches.set(baseUrl, cache);
+    }
+    return cache;
+}
+
+async function fetchUsers(baseUrl: string, ids: string[], token: string | undefined): Promise<Map<string, User | null>> {
+    const resolved = new Map<string, User | null>();
+    for (const id of ids) resolved.set(id, null);
+
+    const params = new URLSearchParams({ ids: ids.join(",") });
+    const response = await fetch(`${baseUrl}/api/users?${params}`, {
+        headers: token ? { Authorization: `Bearer ${token}` } : {}
+    });
+    if (!response.ok) {
+        // A non-admin viewer gets a 403 here. Treat it as "unresolvable" rather
+        // than an error: callers fall back to showing the raw value.
+        return resolved;
+    }
+    const data = await response.json();
+    const rows: Record<string, unknown>[] = data.users ?? data.data ?? [];
+    for (const row of rows) {
+        const uid = (row.uid as string) ?? (row.id as string);
+        if (!uid) continue;
+        resolved.set(uid, {
+            uid,
+            email: (row.email as string) ?? "",
+            displayName: (row.displayName as string) ?? (row.display_name as string) ?? null,
+            photoURL: (row.photoURL as string) ?? (row.photo_url as string) ?? null,
+            providerId: "custom",
+            isAnonymous: false,
+            roles: (row.roles as string[]) ?? []
+        });
+    }
+    return resolved;
+}
+
+function requestUser(
+    baseUrl: string,
+    uid: string,
+    getAuthToken: (() => Promise<string | undefined>) | undefined
+): Promise<void> {
+    const cache = getCache(baseUrl);
+    const existing = cache.pending.get(uid);
+    if (existing) return existing;
+
+    cache.queue.add(uid);
+
+    const promise = new Promise<void>((resolve, reject) => {
+        if (cache.flush) clearTimeout(cache.flush);
+        cache.flush = setTimeout(async () => {
+            const ids = [...cache.queue];
+            cache.queue.clear();
+            cache.flush = undefined;
+            try {
+                const token = await getAuthToken?.();
+                const resolved = await fetchUsers(baseUrl, ids, token);
+                for (const id of ids) {
+                    cache.users.set(id, resolved.get(id) ?? null);
+                    cache.pending.delete(id);
+                }
+                resolve();
+            } catch (error) {
+                for (const id of ids) cache.pending.delete(id);
+                reject(error);
+            }
+        }, 0);
+    });
+
+    cache.pending.set(uid, promise);
+    return promise;
+}
+
+/**
+ * The auth user behind a `userSelect` value, or `null` while it is loading or
+ * when it cannot be resolved.
+ */
+export function useResolvedUser(uid: string | undefined): User | null {
+    const client = useRebaseClient<{ baseUrl?: string }>();
+    const { getAuthToken } = useAuthController();
+    const baseUrl = client?.baseUrl;
+
+    const [user, setUser] = useState<User | null>(() =>
+        (baseUrl && uid) ? getCache(baseUrl).users.get(uid) ?? null : null);
+
+    useEffect(() => {
+        if (!baseUrl || !uid) {
+            setUser(null);
+            return;
+        }
+        const cache = getCache(baseUrl);
+        if (cache.users.has(uid)) {
+            setUser(cache.users.get(uid) ?? null);
+            return;
+        }
+
+        let active = true;
+        requestUser(baseUrl, uid, getAuthToken)
+            .then(() => {
+                if (active) setUser(getCache(baseUrl).users.get(uid) ?? null);
+            })
+            .catch(() => {
+                if (active) setUser(null);
+            });
+        return () => {
+            active = false;
+        };
+    }, [baseUrl, uid, getAuthToken]);
+
+    return user;
+}
+
+/** Human-readable label for a resolved user. */
+export function getUserLabel(user: User): string {
+    return user.displayName || user.email || user.uid;
+}

package/src/hooks/useSelectionDialog.tsx

@@ -1,8 +1,9 @@
 import { SelectionProps, SelectionTableBinding } from "../components/ReferenceTable/SelectionTableBinding";
-import type { CollectionConfig } from "@rebasepro/types";
+
 import { useCallback, useMemo } from "react";
 import { useSideDialogsController } from "./useSideDialogsController";
 import { useCollectionRegistryController } from "./navigation/contexts/CollectionRegistryContext";
+import type { AdminCollection } from "@rebasepro/admin-types";
 
 /**
  * This hook is used to open a side dialog that allows the selection
@@ -26,7 +27,7 @@ export function useSelectionDialog<M extends Record<string, unknown>>(referenceD
         if (referenceDialogProps.path) {
             let usedCollection = referenceDialogProps.collection;
             if (!usedCollection)
-                usedCollection = navigation.getCollection(referenceDialogProps.path) as CollectionConfig<M> | undefined;
+                usedCollection = navigation.getCollection(referenceDialogProps.path) as AdminCollection<M> | undefined;
             if (!usedCollection)
                 throw Error("Not able to resolve the collection in useSelectionDialog. Make sure a collection is registered in path " + referenceDialogProps.path);
             sideDialogsController.open({

package/src/hooks/useSideDialogsController.tsx

@@ -18,7 +18,7 @@ import { useContext } from "react";
  *
  * @group Hooks and utilities
  */
-import { SideDialogPanelProps, SideDialogsController } from "@rebasepro/types";
+import { SideDialogPanelProps, SideDialogsController } from "@rebasepro/admin-types";
 
 export type { SideDialogPanelProps, SideDialogsController };
 

package/src/hooks/useSidePanel.tsx

@@ -1,4 +1,4 @@
-import type { SidePanelController } from "@rebasepro/types";
+import type { SidePanelController } from "@rebasepro/admin-types";
 import React, { useContext } from "react";
 
 export const SidePanelControllerContext = React.createContext<SidePanelController>({} as SidePanelController);

package/src/index.ts

@@ -89,7 +89,8 @@ export {
     getDefaultPropertiesOrder,
     // Preview utilities (moved from @rebasepro/app — property-aware logic belongs in CMS)
     getEntityPreviewKeys,
-    getEntityTitlePropertyKey
+    getEntityTitlePropertyKey,
+    getEntityTitlePropertyKeyForEntity
 } from "./util";
 
 // Headless collection view adapters

package/src/preview/PropertyPreview.tsx

@@ -56,8 +56,8 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
 
     if (property === null) {
         content = <EmptyValue/>;
-    } else if (property.ui?.Preview) {
-        const ResolvedPreview = resolveComponentRef(property.ui.Preview) as React.ComponentType<PropertyPreviewProps<Property>> | undefined;
+    } else if (property.admin?.Preview) {
+        const ResolvedPreview = resolveComponentRef(property.admin.Preview) as React.ComponentType<PropertyPreviewProps<Property>> | undefined;
         if (ResolvedPreview) {
             content = <Suspense fallback={null}>
                 {createElement(ResolvedPreview,
@@ -68,7 +68,7 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
                         size,
                         height,
                         width,
-                        customProps: property.ui?.customProps
+                        customProps: property.admin?.customProps
                     })}
             </Suspense>;
         }
@@ -86,20 +86,20 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
                     size={props.size}
                     fill={fill}
                     storagePathOrDownloadUrl={filePath}/>;
-            } else if (stringProperty.ui?.url) {
-                if (typeof stringProperty.ui?.url === "boolean")
+            } else if (stringProperty.admin?.urlPreview) {
+                if (typeof stringProperty.admin?.urlPreview === "boolean")
                     content =
                         <UrlComponentPreview size={props.size}
                             url={value}
                             fill={fill}/>;
-                else if (typeof stringProperty.ui?.url === "string")
+                else if (typeof stringProperty.admin?.urlPreview === "string")
                     content =
                         <UrlComponentPreview size={props.size}
                             url={value}
                             interactive={interactive}
                             fill={fill}
-                            previewType={stringProperty.ui?.url}/>;
-            } else if (stringProperty.ui?.markdown) {
+                            previewType={stringProperty.admin?.urlPreview}/>;
+            } else if (stringProperty.admin?.markdown) {
                 content = <Markdown source={value} size={"small"}/>;
             } else if (stringProperty.userSelect) {
                 content = <UserPreview
@@ -194,7 +194,7 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
             if (typeof value === "object" && value !== null && "isEntityReference" in value && (value as EntityReference).isEntityReference()) {
                 content = <ReferencePreview
                     disabled={!property.path}
-                    previewProperties={property.ui?.previewProperties}
+                    previewProperties={property.admin?.previewProperties}
                     includeId={property.includeId}
                     includeEntityLink={property.includeEntityLink}
                     size={props.size}
@@ -223,7 +223,7 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
                                 key={`preview_rel_${propertyKey}_${index}`}>
                                 <RelationPreview
                                     disabled={!property.relation}
-                                    previewProperties={property.ui?.previewProperties}
+                                    previewProperties={property.admin?.previewProperties}
                                     includeId={property.includeId}
                                     includeEntityLink={property.includeEntityLink}
                                     size={"small"}
@@ -241,7 +241,7 @@ export const PropertyPreview = React.memo(function PropertyPreview<P extends Pro
             if (relationValue) {
                 content = <RelationPreview
                     disabled={!property.relation}
-                    previewProperties={property.ui?.previewProperties}
+                    previewProperties={property.admin?.previewProperties}
                     includeId={property.includeId}
                     includeEntityLink={property.includeEntityLink}
                     size={props.size}