@rebasepro/core 0.0.1-canary.eae7889 → 0.1.0

package/src/core/Rebase.tsx

@@ -116,20 +116,21 @@ export function Rebase<USER extends User>(props: RebaseProps<USER>) {
         }
 
         // 2. Auto-derive from the client's WebSocket connection (Rebase backend)
-        const ws = (client as any)?.ws;
-        if (ws && typeof ws.executeSql === "function") {
+        const ws = client?.ws;
+        if (ws && typeof (ws as Record<string, unknown>).executeSql === "function") {
+            const wsAdmin = ws as import("@rebasepro/types").DatabaseAdmin;
             return {
-                executeSql: ws.executeSql.bind(ws),
-                fetchAvailableDatabases: ws.fetchAvailableDatabases?.bind(ws),
-                fetchAvailableRoles: ws.fetchAvailableRoles?.bind(ws),
-                fetchCurrentDatabase: ws.fetchCurrentDatabase?.bind(ws),
-                fetchUnmappedTables: ws.fetchUnmappedTables?.bind(ws),
-                fetchTableMetadata: ws.fetchTableMetadata?.bind(ws),
+                executeSql: wsAdmin.executeSql!.bind(wsAdmin),
+                fetchAvailableDatabases: wsAdmin.fetchAvailableDatabases?.bind(wsAdmin),
+                fetchAvailableRoles: wsAdmin.fetchAvailableRoles?.bind(wsAdmin),
+                fetchCurrentDatabase: wsAdmin.fetchCurrentDatabase?.bind(wsAdmin),
+                fetchUnmappedTables: wsAdmin.fetchUnmappedTables?.bind(wsAdmin),
+                fetchTableMetadata: wsAdmin.fetchTableMetadata?.bind(wsAdmin),
                 // Branch admin capabilities
-                ...(typeof ws.createBranch === "function" ? {
-                    createBranch: ws.createBranch.bind(ws),
-                    deleteBranch: ws.deleteBranch.bind(ws),
-                    listBranches: ws.listBranches.bind(ws)
+                ...(typeof wsAdmin.createBranch === "function" ? {
+                    createBranch: wsAdmin.createBranch.bind(wsAdmin),
+                    deleteBranch: wsAdmin.deleteBranch!.bind(wsAdmin),
+                    listBranches: wsAdmin.listBranches!.bind(wsAdmin)
                 } : {})
             };
         }
@@ -224,7 +225,7 @@ export function Rebase<USER extends User>(props: RebaseProps<USER>) {
         </RebaseI18nProvider>
     );
 
-    const resolvedApiUrl = apiUrl ?? (client as any)?.baseUrl;
+    const resolvedApiUrl = apiUrl ?? client?.baseUrl;
 
     if (resolvedApiUrl) {
         return (
@@ -255,7 +256,12 @@ function RebaseInternal({
     }) : children;
 
     const plugins = customizationController.plugins;
-    if (!loading && plugins && plugins.length > 0) {
+    const authController = context.authController;
+    const authReady = !loading
+        && !authController.authLoading
+        && (Boolean(authController.user) || authController.loginSkipped);
+
+    if (authReady && plugins && plugins.length > 0) {
         return (
             <PluginProviderStack
                 plugins={plugins}

package/src/hooks/data/useRelationSelector.tsx

@@ -22,7 +22,7 @@ export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
     /**
      * Force filter to be applied to the relation search
      */
-    forceFilter?: FilterValues<string>;
+    fixedFilter?: FilterValues<string>;
     /**
      * Page size for pagination
      */
@@ -60,7 +60,7 @@ export function useRelationSelector<M extends Record<string, any> = any>(
     {
         path,
         collection,
-        forceFilter,
+        fixedFilter,
         pageSize = DEFAULT_PAGE_SIZE,
         getLabelFromEntity,
         getDescriptionFromEntity,
@@ -138,10 +138,10 @@ export function useRelationSelector<M extends Record<string, any> = any>(
         setError(undefined);
         setLoading(true);
 
-        // Convert forceFilter to PostgREST where clause
+        // Convert fixedFilter to PostgREST where clause
         const whereMap: Record<string, string> = {};
-        if (forceFilter) {
-            Object.entries(forceFilter).forEach(([key, value]) => {
+        if (fixedFilter) {
+            Object.entries(fixedFilter).forEach(([key, value]) => {
                 if (value && Array.isArray(value)) {
                     const [op, val] = value;
                     const postgrestOp = op === "==" ? "eq" : op === "!=" ? "neq" : op === ">" ? "gt" : op === ">=" ? "gte" : op === "<" ? "lt" : op === "<=" ? "lte" : op === "in" ? "in" : op === "not-in" ? "nin" : op === "array-contains" ? "cs" : op === "array-contains-any" ? "csa" : "eq";
@@ -196,7 +196,7 @@ export function useRelationSelector<M extends Record<string, any> = any>(
         }
 
         unsubscribeRef.current = unsubscribe || null;
-    }, [dataClient, path, forceFilter, limit, currentSearch, entityToRelationItem, cleanupSubscription, setLoading]);
+    }, [dataClient, path, fixedFilter, limit, currentSearch, entityToRelationItem, cleanupSubscription, setLoading]);
 
     // Search function with debouncing
     const search = useCallback((searchString: string) => {

package/src/hooks/index.tsx

@@ -45,3 +45,4 @@ export * from "./useRebaseClient";
 
 export * from "./useAnalyticsController";
 export * from "./useUserConfigurationPersistence";
+export * from "./useResolvedComponent";

package/src/hooks/useCollapsedGroups.ts

@@ -7,10 +7,18 @@ const STORAGE_KEY_PREFIX = "rebase-collapsed-groups";
  * with localStorage persistence. Automatically cleans up stale group entries
  * when groups are removed from the navigation.
  *
+ * Groups that have never been toggled by the user fall back to
+ * `defaults[groupName]` (driven by `collapsedByDefault` in config).
+ *
  * @param groupNames - Array of group names to track
  * @param namespace - Namespace for localStorage key (e.g., "home", "drawer") to allow independent state
+ * @param defaults - Optional map of group name → collapsed boolean from config
  */
-export function useCollapsedGroups(groupNames: string[], namespace = "default") {
+export function useCollapsedGroups(
+    groupNames: string[],
+    namespace = "default",
+    defaults?: Record<string, boolean>
+) {
     const storageKey = `${STORAGE_KEY_PREFIX}-${namespace}`;
 
     // Load collapsed groups from localStorage on mount
@@ -57,13 +65,23 @@ export function useCollapsedGroups(groupNames: string[], namespace = "default")
     }, [groupNames]);
 
     const isGroupCollapsed = useCallback((name: string) => {
-        return !!collapsedGroups[name];
-    }, [collapsedGroups]);
+        // If the user has explicitly toggled this group, use that value
+        if (name in collapsedGroups) {
+            return collapsedGroups[name];
+        }
+        // Otherwise fall back to the config default
+        return defaults?.[name] ?? false;
+    }, [collapsedGroups, defaults]);
 
     const toggleGroupCollapsed = useCallback((name: string) => {
-        setCollapsedGroups(prev => ({ ...prev,
-[name]: !prev[name] }));
-    }, []);
+        setCollapsedGroups(prev => {
+            // Resolve current effective state (explicit or default)
+            const currentlyCollapsed = name in prev
+                ? prev[name]
+                : (defaults?.[name] ?? false);
+            return { ...prev, [name]: !currentlyCollapsed };
+        });
+    }, [defaults]);
 
     return useMemo(() => ({
         isGroupCollapsed,
@@ -71,3 +89,27 @@ export function useCollapsedGroups(groupNames: string[], namespace = "default")
     }), [isGroupCollapsed, toggleGroupCollapsed]);
 }
 
+/**
+ * Build a defaults map from navigationGroupMappings for a given namespace.
+ * Returns a Record<groupName, collapsed> that can be passed to useCollapsedGroups.
+ */
+export function buildCollapsedDefaults(
+    mappings: Array<{ name: string; collapsedByDefault?: boolean | { drawer?: boolean; home?: boolean } }> | undefined,
+    namespace: "drawer" | "home"
+): Record<string, boolean> {
+    if (!mappings) return {};
+    const result: Record<string, boolean> = {};
+    for (const mapping of mappings) {
+        const val = mapping.collapsedByDefault;
+        if (val === undefined) continue;
+        if (typeof val === "boolean") {
+            result[mapping.name] = val;
+        } else {
+            const ns = val[namespace];
+            if (ns !== undefined) {
+                result[mapping.name] = ns;
+            }
+        }
+    }
+    return result;
+}

package/src/hooks/useRebaseContext.tsx

@@ -1,5 +1,6 @@
 import { AuthController, RebaseContext, User } from "@rebasepro/types";
 import { useAuthController } from "./useAuthController";
+import { useRebaseClient } from "./useRebaseClient";
 import { useData } from "./data/useData";
 import { useStorageSource } from "./useStorageSource";
 import { useSnackbarController } from "./useSnackbarController";
@@ -11,9 +12,7 @@ import { useEffectiveRoleController } from "./useEffectiveRoleController";
 import React, { useEffect, useContext } from "react";
 import { useInternalUserManagementController } from "./useInternalUserManagementController";
 
-// Temporary context for databaseAdmin - assuming we might add one, or we need to get it from Rebase.tsx.
-// Wait, `databaseAdmin` hasn't been added to a context yet. Let's add it to a context in Rebase.tsx later.
-// Let's create a placeholder for databaseAdmin context access.
+// DatabaseAdmin is provided by <Rebase> via DatabaseAdminContext.
 import { DatabaseAdminContext } from "../contexts/DatabaseAdminContext";
 
 /**
@@ -27,6 +26,8 @@ import { DatabaseAdminContext } from "../contexts/DatabaseAdminContext";
  */
 export const useRebaseContext = <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>(): RebaseContext<USER, AuthControllerType> => {
 
+    const client = useRebaseClient<any>();
+
     const authController = useAuthController<USER, AuthControllerType>();
     const data = useData();
     const storageSource = useStorageSource();
@@ -52,7 +53,8 @@ export const useRebaseContext = <USER extends User = User, AuthControllerType ex
         analyticsController,
         userManagement,
         effectiveRoleController,
-        databaseAdmin
+        databaseAdmin,
+        client: client! // Client should be provided
     });
 
     React.useEffect(() => {
@@ -67,9 +69,12 @@ export const useRebaseContext = <USER extends User = User, AuthControllerType ex
             analyticsController,
             userManagement,
             effectiveRoleController,
-            databaseAdmin
+            databaseAdmin,
+            client: client!
         };
-    }, [authController, dialogsController, effectiveRoleController, data, databaseAdmin]);
+    }, [authController, data, storageSource, snackbarController, userConfigPersistence,
+        dialogsController, customizationController, analyticsController, userManagement,
+        effectiveRoleController, databaseAdmin, client]);
 
     return rebaseContextRef.current;
 }

package/src/hooks/useResolvedComponent.tsx

@@ -0,0 +1,157 @@
+import React, { lazy, useMemo } from "react";
+import type { ComponentRef, LazyComponentRef } from "@rebasepro/types";
+import { isLazyComponentRef } from "@rebasepro/types";
+
+/**
+ * Internal cache for resolved lazy components.
+ *
+ * `React.lazy()` must return the SAME wrapper across renders — if we call
+ * `lazy(loader)` on every render, React will treat each result as a new
+ * component type and unmount/remount on each render cycle.
+ *
+ * This WeakMap keeps a stable mapping from a `ComponentRef` (object/function)
+ * to the `React.lazy()` wrapper it produced. Strings are keyed by a separate
+ * plain Map since they can't be WeakMap keys.
+ */
+const lazyCache = new WeakMap<object | Function, React.ComponentType<any>>();
+
+/**
+ * Resolves a `ComponentRef` into a renderable `React.ComponentType`.
+ *
+ * This hook handles all three forms of `ComponentRef`:
+ *
+ * 1. **`LazyComponentRef`** (produced by the Vite plugin from string paths):
+ *    Wraps the lazy loader with `React.lazy()` for automatic code-splitting.
+ *
+ * 2. **`() => Promise<{ default: ComponentType }>`** (manual lazy import):
+ *    Also wraps with `React.lazy()`. Distinguished from regular components
+ *    by checking that the function has no parameters and is not a known
+ *    React internal (no `$$typeof`).
+ *
+ * 3. **Direct `React.ComponentType`**:
+ *    Returned as-is.
+ *
+ * If the ref is `undefined` or a raw string (which should never happen at
+ * runtime in the browser since the Vite plugin transforms strings), returns `undefined`.
+ *
+ * The returned component is stable across re-renders as long as the `ref`
+ * is referentially stable.
+ *
+ * **Usage:** Wrap the rendered component in `<Suspense>` to handle the
+ * loading state of lazy components.
+ *
+ * @example
+ * ```tsx
+ * const ResolvedField = useResolvedComponent(property.ui?.Field);
+ * if (!ResolvedField) return null;
+ * return (
+ *     <Suspense fallback={<CircularProgress />}>
+ *         <ResolvedField {...fieldProps} />
+ *     </Suspense>
+ * );
+ * ```
+ */
+export function useResolvedComponent<P = unknown>(
+    ref: ComponentRef<P> | undefined
+): React.ComponentType<P> | undefined {
+    return useMemo(() => resolveComponentRef(ref), [ref]);
+}
+
+/**
+ * Wraps a loader function with `React.lazy()`, caching the result so the
+ * same loader always returns the same lazy component identity.
+ */
+function getOrCreateLazy<P>(
+    key: object | Function,
+    loader: () => Promise<{ default: React.ComponentType<P> }>
+): React.ComponentType<P> {
+    const cached = lazyCache.get(key);
+    if (cached) return cached as React.ComponentType<P>;
+
+    const LazyComponent = lazy(loader) as unknown as React.ComponentType<P>;
+    lazyCache.set(key, LazyComponent);
+    return LazyComponent;
+}
+
+/**
+ * Pure function version of the resolver, for use outside React components.
+ * Same resolution logic as `useResolvedComponent`.
+ *
+ * Results are cached per reference identity — calling this multiple times
+ * with the same `ref` object returns the same `React.ComponentType`.
+ */
+export function resolveComponentRef<P = unknown>(
+    ref: ComponentRef<P> | undefined
+): React.ComponentType<P> | undefined {
+    if (ref == null) return undefined;
+
+    // 1. String — should not happen at runtime (Vite transforms them).
+    //    Log a warning and bail out.
+    if (typeof ref === "string") {
+        console.warn(
+            `[Rebase] Encountered a raw string ComponentRef ("${ref}") at runtime. ` +
+            "This usually means the Vite transform plugin did not process this file. " +
+            "Ensure the file is inside the configured collectionsDir."
+        );
+        return undefined;
+    }
+
+    // 2. LazyComponentRef — produced by the Vite plugin from string paths.
+    //    The object has { __rebaseLazy: true, load: () => import(...) }.
+    if (isLazyComponentRef(ref)) {
+        return getOrCreateLazy<P>(
+            ref as unknown as object,
+            () => (ref as LazyComponentRef<P>).load()
+        );
+    }
+
+    // 3. Function — either a React component or a lazy import loader.
+    if (typeof ref === "function") {
+        const fn = ref as Function;
+
+        // Class components (React.Component / PureComponent) have this flag
+        if (fn.prototype?.isReactComponent) {
+            return ref as React.ComponentType<P>;
+        }
+
+        // React internals (forwardRef, memo, etc.) carry $$typeof
+        if ("$$typeof" in fn) {
+            return ref as React.ComponentType<P>;
+        }
+
+        // A function with declared parameters (fn.length > 0) is a regular
+        // component that accepts props — return as-is.
+        if (fn.length > 0) {
+            return ref as React.ComponentType<P>;
+        }
+
+        // Zero-parameter function — could be a React component with no props
+        // OR a lazy loader `() => import(...)`. We distinguish by checking
+        // if `fn.name` looks like a component (starts with uppercase) or is
+        // an anonymous arrow.
+        //
+        // Convention: named function components always start with an
+        // uppercase letter. Dynamic import wrappers are typically anonymous
+        // arrows or have lowercase names.
+        const name = fn.name;
+        if (name && /^[A-Z]/.test(name)) {
+            // Named component (e.g. `function MyField() { ... }`) — return as-is
+            return ref as React.ComponentType<P>;
+        }
+
+        // Treat as a lazy loader — wrap with React.lazy, cached by identity.
+        return getOrCreateLazy<P>(
+            fn,
+            ref as () => Promise<{ default: React.ComponentType<P> }>
+        );
+    }
+
+    // 4. React wrapper objects (React.forwardRef, React.memo) —
+    //    These are objects with $$typeof but are not functions.
+    if (typeof ref === "object" && "$$typeof" in (ref as object)) {
+        return ref as unknown as React.ComponentType<P>;
+    }
+
+    // 5. Unknown shape — return undefined to be safe
+    return undefined;
+}

package/src/hooks/useStudioBridge.tsx

@@ -42,7 +42,8 @@ const NOOP_COLLECTION_REGISTRY: CollectionRegistryController = {
     getCollection: () => undefined,
     getRawCollection: () => undefined,
     getParentReferencesFromPath: () => [],
-    getParentCollectionIds: () => [],
+    getParentCollectionSlugs: () => [],
+    getParentEntityIds: () => [],
     convertIdsToPaths: () => [],
     initialised: false
 };

package/src/locales/de.ts

@@ -44,6 +44,7 @@ export const de: RebaseTranslations = {
     all_entries_loaded: "Alle {{count}} Einträge geladen",
     create_your_first_entry: "Erstellen Sie Ihren ersten Eintrag",
     no_results_filter_sort: "Keine Ergebnisse mit angewendetem Filter/Sortierung",
+    no_results_search: "Keine Ergebnisse gefunden für \"{{search}}\"",
     add: "Hinzufügen",
     remove: "Entfernen",
     multiple_entities: "Mehrere Entitäten",
@@ -127,6 +128,9 @@ export const de: RebaseTranslations = {
     delete_user_confirmation: "Sind Sie sicher, dass Sie diesen Benutzer löschen möchten?",
     create_your_users_and_roles: "Erstellen Sie Ihre Benutzer und Rollen",
     no_users_or_roles_defined: "Sie haben keine Benutzer oder Rollen definiert. Sie können Standardrollen erstellen und den aktuellen Benutzer als Administrator hinzufügen.",
+    no_permission_to_view_users: "Sie haben keine Berechtigung, Benutzer anzuzeigen",
+    no_permission_to_view_roles: "Sie haben keine Berechtigung, Rollen anzuzeigen",
+    no_permission_description: "Wenden Sie sich an einen Administrator, wenn Sie Zugang zu diesem Bereich benötigen.",
     save_before_changing_schema: "Sie müssen das Dokument speichern, bevor Sie das Schema ändern können",
     edit_schema_for_this_form: "Schema für dieses Formular bearbeiten",
     no_permissions_to_edit_collection: "Sie haben keine Berechtigung, diese Sammlung zu bearbeiten",

package/src/locales/en.ts

@@ -52,6 +52,7 @@ export const en: RebaseTranslations = {
     all_entries_loaded: "All {{count}} entries loaded",
     create_your_first_entry: "Create your first entry",
     no_results_filter_sort: "No results with the applied filter/sort",
+    no_results_search: "No results found for \"{{search}}\"",
     add: "Add",
     remove: "Remove",
     multiple_entities: "Multiple entities",
@@ -487,6 +488,11 @@ export const en: RebaseTranslations = {
     reset_password: "Reset Password",
     reset_password_success: "Password reset successfully",
     reset_password_confirmation: "Are you sure you want to reset this user's password?",
+
+    /** Permission-denied empty states */
+    no_permission_to_view_users: "You don't have permission to view users",
+    no_permission_to_view_roles: "You don't have permission to view roles",
+    no_permission_description: "Contact an administrator if you need access to this section.",
     error_resetting_password: "Error resetting password",
 
     /** Editor table-bubble */

package/src/locales/es.ts

@@ -52,6 +52,7 @@ export const es: RebaseTranslations = {
     all_entries_loaded: "Todas las {{count}} entradas cargadas",
     create_your_first_entry: "Crea tu primera entrada",
     no_results_filter_sort: "No hay resultados con el filtro/orden aplicado",
+    no_results_search: "No se encontraron resultados para \"{{search}}\"",
     add: "Añadir",
     remove: "Quitar",
     multiple_entities: "Múltiples entidades",
@@ -133,6 +134,9 @@ export const es: RebaseTranslations = {
     delete_user_confirmation: "¿Estás seguro de que quieres eliminar a este usuario?",
     create_your_users_and_roles: "Crea tus usuarios y roles",
     no_users_or_roles_defined: "No tienes usuarios ni roles. Puedes crear los roles por defecto y añadirte a ti mismo como administrador.",
+    no_permission_to_view_users: "No tienes permisos para ver los usuarios",
+    no_permission_to_view_roles: "No tienes permisos para ver los roles",
+    no_permission_description: "Contacta a un administrador si necesitas acceso a esta sección.",
     save_before_changing_schema: "Debes guardar el documento antes de cambiar el esquema",
     edit_schema_for_this_form: "Editar esquema para este formulario",
     no_permissions_to_edit_collection: "No tienes permisos para editar esta colección",

package/src/locales/fr.ts

@@ -44,6 +44,7 @@ export const fr: RebaseTranslations = {
     all_entries_loaded: "Toutes les {{count}} entrées chargées",
     create_your_first_entry: "Créez votre première entrée",
     no_results_filter_sort: "Aucun résultat avec le filtre/tri appliqué",
+    no_results_search: "Aucun résultat trouvé pour \"{{search}}\"",
     add: "Ajouter",
     remove: "Supprimer",
     multiple_entities: "Entités multiples",
@@ -127,6 +128,9 @@ export const fr: RebaseTranslations = {
     delete_user_confirmation: "Êtes-vous sûr de vouloir supprimer cet utilisateur ?",
     create_your_users_and_roles: "Créez vos utilisateurs et rôles",
     no_users_or_roles_defined: "Vous n'avez défini aucun utilisateur ni rôle. Vous pouvez créer les rôles par défaut et ajouter l'utilisateur actuel en tant qu'administrateur.",
+    no_permission_to_view_users: "Vous n'avez pas la permission de voir les utilisateurs",
+    no_permission_to_view_roles: "Vous n'avez pas la permission de voir les rôles",
+    no_permission_description: "Contactez un administrateur si vous avez besoin d'accéder à cette section.",
     save_before_changing_schema: "Vous devez enregistrer le document avant de modifier le schéma",
     edit_schema_for_this_form: "Modifier le schéma de ce formulaire",
     no_permissions_to_edit_collection: "Vous n'avez pas l'autorisation de modifier cette collection",

package/src/locales/hi.ts

@@ -44,6 +44,7 @@ export const hi: RebaseTranslations = {
     all_entries_loaded: "सभी {{count}} प्रविष्टियाँ लोड हो गईं",
     create_your_first_entry: "अपनी पहली प्रविष्टि बनाएं",
     no_results_filter_sort: "लागू किए गए फ़िल्टर/सॉर्ट के साथ कोई परिणाम नहीं",
+    no_results_search: "\"{{search}}\" के लिए कोई परिणाम नहीं मिला",
     add: "जोड़ें",
     remove: "हटाएं",
     multiple_entities: "एकाधिक इकाइयां",
@@ -127,6 +128,9 @@ export const hi: RebaseTranslations = {
     delete_user_confirmation: "क्या आप वाकई इस उपयोगकर्ता को हटाना चाहते हैं?",
     create_your_users_and_roles: "अपने उपयोगकर्ता और भूमिकाएँ बनाएँ",
     no_users_or_roles_defined: "आपके पास कोई उपयोगकर्ता या भूमिका परिभाषित नहीं है। आप डिफ़ॉल्ट भूमिकाएँ बना सकते हैं और वर्तमान उपयोगकर्ता को एडमिन के रूप में जोड़ सकते हैं।",
+    no_permission_to_view_users: "आपको उपयोगकर्ताओं को देखने की अनुमति नहीं है",
+    no_permission_to_view_roles: "आपको भूमिकाओं को देखने की अनुमति नहीं है",
+    no_permission_description: "यदि आपको इस अनुभाग तक पहुँच की आवश्यकता है तो किसी व्यवस्थापक से संपर्क करें।",
     save_before_changing_schema: "स्कीमा बदलने से पहले आपको दस्तावेज़ सहेजना होगा",
     edit_schema_for_this_form: "इस फॉर्म के लिए स्कीमा संपादित करें",
     no_permissions_to_edit_collection: "आपके पास इस संग्रह को संपादित करने की अनुमति नहीं है",

package/src/locales/it.ts

@@ -44,6 +44,7 @@ export const it: RebaseTranslations = {
     all_entries_loaded: "Tutte le {{count}} voci caricate",
     create_your_first_entry: "Crea la tua prima voce",
     no_results_filter_sort: "Nessun risultato con il filtro/ordinamento applicato",
+    no_results_search: "Nessun risultato trovato per \"{{search}}\"",
     add: "Aggiungi",
     remove: "Rimuovi",
     multiple_entities: "Entità multiple",
@@ -127,6 +128,9 @@ export const it: RebaseTranslations = {
     delete_user_confirmation: "Sei sicuro di voler eliminare questo utente?",
     create_your_users_and_roles: "Crea i tuoi utenti e ruoli",
     no_users_or_roles_defined: "Non hai definito né utenti né ruoli. Puoi creare ruoli predefiniti e aggiungere l'utente corrente come amministratore.",
+    no_permission_to_view_users: "Non hai i permessi per visualizzare gli utenti",
+    no_permission_to_view_roles: "Non hai i permessi per visualizzare i ruoli",
+    no_permission_description: "Contatta un amministratore se hai bisogno di accedere a questa sezione.",
     save_before_changing_schema: "Devi salvare il documento prima di modificare lo schema",
     edit_schema_for_this_form: "Modifica lo schema per questo modulo",
     no_permissions_to_edit_collection: "Non hai i permessi per modificare questa collezione",

package/src/locales/pt.ts

@@ -49,6 +49,7 @@ export const pt: RebaseTranslations = {
     all_entries_loaded: "Todos os {{count}} registos carregados",
     create_your_first_entry: "Crie o seu primeiro registo",
     no_results_filter_sort: "Sem resultados com o filtro/ordenação aplicado",
+    no_results_search: "Nenhum resultado encontrado para \"{{search}}\"",
     add: "Adicionar",
     remove: "Remover",
     multiple_entities: "Múltiplas entidades",
@@ -132,6 +133,9 @@ export const pt: RebaseTranslations = {
     delete_user_confirmation: "Tem a certeza de que quer eliminar este utilizador?",
     create_your_users_and_roles: "Crie os seus utilizadores e funções",
     no_users_or_roles_defined: "Não tem utilizadores ou funções definidas. Pode criar funções predefinidas e adicionar o utilizador atual como administrador.",
+    no_permission_to_view_users: "Não tem permissão para ver os utilizadores",
+    no_permission_to_view_roles: "Não tem permissão para ver as funções",
+    no_permission_description: "Contacte um administrador se precisar de acesso a esta secção.",
     save_before_changing_schema: "Precisa de guardar o documento antes de alterar o esquema",
     edit_schema_for_this_form: "Editar esquema para este formulário",
     no_permissions_to_edit_collection: "Não tem permissões para editar esta coleção",

package/src/util/previews.ts

@@ -36,7 +36,7 @@ export function getEntityPreviewKeys(
     if (listProperties && listProperties.length > 0) {
         return listProperties;
     } else {
-        listProperties = allProperties;
+        listProperties = (targetCollection.propertiesOrder as string[]) || allProperties;
         return listProperties
             .filter(key => {
                 const prop = targetCollection.properties[key];
@@ -54,16 +54,25 @@ export function getEntityTitlePropertyKey<M extends Record<string, any>>(collect
     if (collection.titleProperty) {
         return collection.titleProperty as string;
     }
-    // find first text field property
-    for (const key in collection.properties) {
+    
+    const orderToSearch = (collection.propertiesOrder as string[]) || Object.keys(collection.properties);
+    let firstStringCandidate: string | undefined;
+
+    for (const key of orderToSearch) {
         const property = collection.properties[key];
-        if (!isPropertyBuilder(property)) {
+        if (property && !isPropertyBuilder(property)) {
             const prop = property as Property;
-            if (prop.type === "string" && !prop.multiline && !prop.markdown && !prop.storage && !prop.isId) {
-                return key;
+            if (prop.type === "string" && !prop.ui?.multiline && !prop.ui?.markdown && !prop.storage && !prop.isId) {
+                if (!firstStringCandidate) {
+                    firstStringCandidate = key;
+                }
+                const lowerKey = key.toLowerCase();
+                if (["name", "title", "label", "displayname", "username"].includes(lowerKey)) {
+                    return key; // Immediate return if it's a strong title candidate
+                }
             }
         }
     }
-    return undefined;
+    return firstStringCandidate;
 }