rimecms 0.23.27 → 0.24.1

package/README.md

@@ -31,6 +31,7 @@ Headless CMS powered by SvelteKit.
 ### Content Management
 
 Fields types:
+
 - Blocks
 - Tree (nested array)
 - Tabs
@@ -52,6 +53,7 @@ Fields types:
 npx sv create my-app
 cd my-app
 ```
+
 > [!NOTE]
 > Select TypeScript when prompted
 
@@ -83,7 +85,7 @@ import { sveltekit } from '@sveltejs/kit/vite';
 import { rime } from 'rimecms/vite';
 
 export default defineConfig({
-  plugins: [rime(), sveltekit()]
+	plugins: [rime(), sveltekit()]
 });
 ```
 
@@ -198,29 +200,37 @@ export default rime({
 
 ```ts
 export const load = async (event: LayoutServerLoadEvent) => {
-  const { rime } = event.locals;
-  // Get an Area document
-  const menu = await rime.area('menu').find();
-  // Get all pages documents
-  const pages = await rime.collection('pages').findAll({ locale: 'en' });
-  // Get a page byId
-  const home = await rime.collection('pages').findById({ locale: 'en', id: 'some-id' });
-  // Get a user with a query
-  const [user] = await rime.collection('users').find({
-    query: `where[email][equals]=some@email.com` // qs query or ParsedQsQuery
-  });
-  // Get some config values
-  const languages = rime.config.getLocalesCodes();
-  const collections = rime.config.collections;
-  //...
+	const { rime } = event.locals;
+	// Get an Area document
+	const menu = await rime.area('menu').find();
+	// Get all pages documents
+	const pages = await rime.collection('pages').findAll({ locale: 'en' });
+	// Get a page byId
+	const home = await rime.collection('pages').findById({ locale: 'en', id: 'some-id' });
+	// Get a user with a query
+	const [user] = await rime.collection('users').find({
+		query: `where[email][equals]=some@email.com` // qs query or ParsedQsQuery
+	});
+	// Get some config values
+	const languages = rime.config.getLocalesCodes();
+	const collections = rime.config.collections;
+	//...
 };
 ```
 
 ### From the API :
+
 ```ts
-const { docs } = await fetch('http://localhost:5173/api/pages').then(r => r.json())
-const { docs } = await fetch('http://localhost:5173/api/pages?sort=title&limit=1').then(r => r.json())
-const { docs } = await fetch('http://localhost:5173/api/pages?where[author][like]=some-id&locale=en`;').then(r => r.json())
+const { docs } = await fetch('http://localhost:5173/api/pages').then((r) => r.json());
+const { docs } = await fetch('http://localhost:5173/api/pages?sort=title&limit=1').then((r) =>
+	r.json()
+);
+const { docs } = await fetch(
+	'http://localhost:5173/api/pages?where[author][equals]=some-id&locale=en`;'
+).then((r) => r.json());
+const { docs } = await fetch(
+	'http://localhost:5173/api/pages?where[author.email][equals]=some@email.com&locale=en`;'
+).then((r) => r.json());
 ```
 
 ## DEPLOYING
@@ -228,10 +238,12 @@ const { docs } = await fetch('http://localhost:5173/api/pages?where[author][like
 For now I am using it with @svelte/adapter-node, other adapter not tested and probably not working.
 
 With the node adapter :
+
 ```sh
 npx rime build
 npx rime build -d # to copy the database directory
 ```
+
 It's doing bascically `vite build` under the hood and create the polka server file inside an app directory, plus giving some info on how to run it.
 
 ## ROADMAP
@@ -246,6 +258,7 @@ It's doing bascically `vite build` under the hood and create the polka server fi
 - [x] Document version
 - [x] collection nested
 - [x] more better-auth integration
+- [x] Handle relation poperties in queries
 - [~] Documentation
 - [ ] Live Edit system in practice
 - [ ] auto-saved draft

package/dist/adapter-sqlite/where.js

@@ -7,61 +7,40 @@ import {} from '../index.js';
 import * as drizzleORM from 'drizzle-orm';
 import { and, eq, getTableColumns, inArray, or } from 'drizzle-orm';
 export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx }) => {
+    // Helper to get table by key with correct typing
     function getTable(key) {
         return tables[key];
     }
-    const table = getTable(slug);
-    const tableNameLocales = withLocalesSuffix(slug);
-    const tableLocales = getTable(tableNameLocales);
-    const localizedColumns = locale && tableNameLocales in tables ? Object.keys(getTableColumns(tableLocales)) : [];
-    const unlocalizedColumns = Object.keys(getTableColumns(table));
+    function getTablesAndColumns(slug) {
+        // Get main table and localized table if applicable
+        const table = getTable(slug);
+        const tableNameLocales = withLocalesSuffix(slug);
+        const tableLocales = getTable(tableNameLocales);
+        // Get localized and unlocalized columns
+        const localizedColumns = locale && tableNameLocales in tables ? Object.keys(getTableColumns(tableLocales)) : [];
+        const unlocalizedColumns = Object.keys(getTableColumns(table));
+        return { table, tableLocales, localizedColumns, unlocalizedColumns };
+    }
+    const { 
+    // Get main table and localized table if applicable
+    table, tableLocales, localizedColumns, unlocalizedColumns } = getTablesAndColumns(slug);
     const buildCondition = (conditionObject) => {
         // Handle nested AND conditions
         if ('and' in conditionObject && Array.isArray(conditionObject.and)) {
-            const subConditions = conditionObject.and
-                .map((condition) => buildCondition(condition))
-                .filter(Boolean);
+            const subConditions = conditionObject.and.map((condition) => buildCondition(condition)).filter(Boolean);
             return subConditions.length ? and(...subConditions) : false;
         }
         // Handle nested OR conditions
         if ('or' in conditionObject && Array.isArray(conditionObject.or)) {
-            const subConditions = conditionObject.or
-                .map((condition) => buildCondition(condition))
-                .filter(Boolean);
+            const subConditions = conditionObject.or.map((condition) => buildCondition(condition)).filter(Boolean);
             return subConditions.length ? or(...subConditions) : false;
         }
-        // Handle id field for versioned collections
-        // if "id" inside the query it should refer to the root table
-        if (hasVersionsSuffix(slug) && 'id' in conditionObject) {
-            // Replace id with ownerId and keep the same operator and value
-            const idOperator = conditionObject.id;
-            delete conditionObject.id;
-            conditionObject.ownerId = idOperator;
-        }
-        // Handle versionId field for versioned collections
-        // if "versionId" inside the query it should refer to the id of the version table (current)
-        if (hasVersionsSuffix(slug) && 'versionId' in conditionObject) {
-            // Replace id with ownerId and keep the same operator and value
-            const idOperator = conditionObject.versionId;
-            delete conditionObject.versionId;
-            conditionObject.id = idOperator;
-        }
-        // Handle regular field conditions
-        const [column, operatorObj] = Object.entries(conditionObject)[0];
-        const [operator, rawValue] = Object.entries(operatorObj)[0];
-        if (!isOperator(operator)) {
-            throw new RimeError(RimeError.INVALID_DATA, operator + 'is not supported');
-        }
-        // get the correct Drizzle operator
-        const fn = operators[operator];
-        // Format compared value to support Date, Arrays,...
-        const value = formatValue({ operator, value: rawValue });
-        // Convert dot notation to double underscore
-        // for fields included in groups or tabs
-        const sqlColumn = column.replace(/\./g, '__');
+        conditionObject = normalizedForVersion(conditionObject, slug);
+        const { 
+        // Get condition members
+        column, sqlColumn, fn, operator, rawValue, value } = getConditionMembers(conditionObject);
         // Handle hierarchy fields (_parent, _position) in versioned collections
-        if (hasVersionsSuffix(slug) &&
-            (sqlColumn === '_parent' || sqlColumn === '_position' || sqlColumn === '_path')) {
+        if (shouldHandleVersionedHierarchyFields(slug, sqlColumn)) {
             // Get the root table name by removing the '_versions' suffix
             const rootSlug = slug.replace('_versions', '');
             const rootTable = getTable(rootSlug);
@@ -82,154 +61,182 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         // Look for a relation field
         // Get document config
         const documentConfig = configCtx.getBySlug(slug);
-        if (!documentConfig) {
-            throw new Error(`${slug} not found (should never happen)`);
-        }
-        // Get the field config
-        const fieldConfig = getFieldConfigByPath(column, documentConfig.fields.map((f) => f.compile()));
+        // Get the compiled fields for lookups
+        const compiledFields = documentConfig.fields.map((f) => f.compile());
+        let fieldConfig = getFieldConfigByPath(column, compiledFields);
+        // Track relation-property detection (e.g. attributes.author.name)
+        let matchedPrefix = column;
+        let relationPropertyPath = null;
+        let isRelationProperty = false;
+        // If the exact path isn't found, try progressively shorter prefixes to support
+        // relation property queries like `attributes.author.name` -> `attributes.author`
         if (!fieldConfig) {
-            // @TODO handle relation props ex: author.email
-            logger.warn(`the query contains the field "${column}", not found for ${documentConfig.slug} document`);
+            const parts = column.split('.');
+            for (let i = parts.length - 1; i > 0; i--) {
+                const prefix = parts.slice(0, i).join('.');
+                const candidate = getFieldConfigByPath(prefix, compiledFields);
+                if (candidate) {
+                    fieldConfig = candidate;
+                    // If prefix shorter than original column, record the property suffix
+                    if (i < parts.length) {
+                        matchedPrefix = prefix;
+                        relationPropertyPath = parts.slice(i).join('.');
+                        isRelationProperty = true;
+                    }
+                    break;
+                }
+            }
+        }
+        // If still not found or not a relation field, log warning and return false condition
+        if (!fieldConfig || !isRelationField(fieldConfig)) {
+            const message = `the query contains the field "${column}", not found for ${documentConfig.slug} document`;
+            logger.warn(message);
             // Return a condition that will always be false instead of returning false
             // This ensures no documents match when a non-existent field is queried
-            return eq(table.id, '-1'); // No document will have ID = -1, so this will always be false
+            return eq(table.id, '-1');
         }
-        // Not a relation
-        if (!isRelationField(fieldConfig)) {
-            logger.warn(`the query contains the field "${column}", not found for ${documentConfig.slug} document`);
-            // Return a condition that will always be false
-            return eq(table.id, '-1'); // No document will have ID = -1, so this will always be false
+        // Helper: normalize various input forms (rawValue, CSV string, or formatted array)
+        // into a unique array of values used for multi-valued relation comparisons.
+        const normalizeValues = (raw, formatted) => {
+            let out;
+            if (Array.isArray(raw))
+                out = raw;
+            else if (typeof raw === 'string' && raw.includes(','))
+                out = raw.split(',');
+            else if (Array.isArray(formatted))
+                out = formatted;
+            else
+                out = [formatted];
+            return Array.from(new Set(out));
+        };
+        // Handle relation property queries (e.g., attributes.author.name)
+        // by building a subquery on the related collection
+        const buildRelationPropertyCondition = () => {
+            const relatedSlug = fieldConfig.relationTo;
+            const relatedTable = getTable(relatedSlug);
+            // Build a where clause for the related collection using the same operator/value
+            const relatedWhere = { [relationPropertyPath]: { [operator]: rawValue } };
+            // Recursive call to buildWhereParam for the related collection
+            const relatedCondition = buildWhereParam({
+                query: { where: relatedWhere },
+                slug: relatedSlug,
+                db,
+                locale,
+                tables,
+                configCtx
+            });
+            if (!relatedCondition) {
+                // No documents in related collection match => no parent documents match
+                return eq(table.id, '-1');
+            }
+            // Subquery of related document ids that match the property condition
+            const matchingRelatedIds = db.select({ id: relatedTable.id }).from(relatedTable).where(relatedCondition);
+            const relsTable = getTable(`${slug}Rels`);
+            // Join relation rows to documents by matching the related id and the relation path
+            const ownersWithMatching = db
+                .select({ id: relsTable.ownerId })
+                .from(relsTable)
+                .where(and(inArray(relsTable[`${relatedSlug}Id`], matchingRelatedIds), eq(relsTable.path, matchedPrefix), ...(fieldConfig.localized ? [eq(relsTable.locale, locale)] : [])));
+            return inArray(table.id, ownersWithMatching);
+        };
+        // If this is a relation property query, delegate to the relation property handler
+        if (isRelationProperty && relationPropertyPath) {
+            return buildRelationPropertyCondition();
         }
-        // Unsupported operator for multi-valued relations
+        // Handle direct relation field queries (e.g., attributes.author)
+        // only support a subset of operators for multi-valued relations
+        // Unsupported operator for multi-valued relations :
         const supportedRelationManyOperators = ['equals', 'not_equals', 'in_array', 'not_in_array'];
+        // Only enforce the restriction for direct relation field queries.
+        // If this is a relation property query (e.g. attributes.author.name) we allow
+        // any operator because those will be applied to the related collection.
         if (fieldConfig.many && !supportedRelationManyOperators.includes(operator)) {
-            logger.warn(`the operator "${operator}" is not supported for multi-valued relation field "${column}" in ${documentConfig.slug} document`);
+            const unsupportedMessage = `the operator "${operator}" is not supported for multi-valued relation field "${column}" in ${documentConfig.slug} document`;
+            logger.warn(unsupportedMessage);
             // Return a condition that will always be false
-            return eq(table.id, '-1'); // No document will have ID = -1, so this will always be false
+            return eq(table.id, '-1');
         }
-        // Only compare with the relation ID for now
-        // @TODO handle relation props ex: author.email
+        // Build relation condition
         const [to, localized] = [fieldConfig.relationTo, fieldConfig.localized];
-        const relationTableName = `${slug}Rels`;
-        const relationTable = getTable(relationTableName);
+        const relsTableName = `${slug}Rels`;
+        const relsTable = getTable(relsTableName);
+        // Helpers for building common relation-owner subqueries (operate on the relations table)
+        const buildOwnersWithTotalCount = (count) => db
+            .select({ id: relsTable.ownerId })
+            .from(relsTable)
+            .where(and(eq(relsTable.path, column), ...(localized ? [eq(relsTable.locale, locale)] : [])))
+            .groupBy(relsTable.ownerId)
+            .having(drizzleORM.eq(drizzleORM.count(relsTable.id), count));
+        // Owners that have total relation count equal to the number of provided values
+        const buildOwnersWithMatchingCount = (values) => db
+            .select({ id: relsTable.ownerId })
+            .from(relsTable)
+            .where(and(drizzleORM.inArray(relsTable[`${to}Id`], values), eq(relsTable.path, column), ...(localized ? [eq(relsTable.locale, locale)] : [])))
+            .groupBy(relsTable.ownerId)
+            .having(drizzleORM.eq(drizzleORM.count(relsTable.id), values.length));
+        // Owners that have at least one relation row NOT in the provided values
+        const buildOwnersWithNonMatching = (values) => db
+            .select({ id: relsTable.ownerId })
+            .from(relsTable)
+            .where(and(drizzleORM.notInArray(relsTable[`${to}Id`], values), eq(relsTable.path, column), ...(localized ? [eq(relsTable.locale, locale)] : [])))
+            .groupBy(relsTable.ownerId)
+            .having(drizzleORM.gt(drizzleORM.count(relsTable.id), 0));
+        // Owners that have any relation rows (to exclude docs with no relations)
+        const buildOwnersWithRelations = () => db
+            .select({ id: relsTable.ownerId })
+            .from(relsTable)
+            .where(and(eq(relsTable.path, column), ...(localized ? [eq(relsTable.locale, locale)] : [])))
+            .groupBy(relsTable.ownerId)
+            .having(drizzleORM.gt(drizzleORM.count(relsTable.id), 0));
         // Handle multi-valued relations specially when operator is `equals` to provide
         // strict equality semantics (the relation set must equal the provided value(s)).
         if (fieldConfig.many && operator === 'equals') {
-            // Accept array inputs, repeated params, or CSV values for equality checks
-            let values = (() => {
-                if (Array.isArray(rawValue))
-                    return rawValue;
-                if (typeof rawValue === 'string' && rawValue.includes(','))
-                    return rawValue.split(',');
-                if (Array.isArray(value))
-                    return value;
-                return [value];
-            })();
-            // Ensure values are unique
-            values = Array.from(new Set(values));
+            // Accept various input forms and normalize to a unique array
+            const values = normalizeValues(rawValue, value);
             // Owners with total relation count equal to values.length
-            const ownersWithTotalCount = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.eq(drizzleORM.count(relationTable.id), values.length));
+            const ownersWithTotalCount = buildOwnersWithTotalCount(values.length);
             // Owners with matching relations count equal to values.length
-            const ownersWithMatchingCount = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(drizzleORM.inArray(relationTable[`${to}Id`], values), eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.eq(drizzleORM.count(relationTable.id), values.length));
+            const ownersWithMatchingCount = buildOwnersWithMatchingCount(values);
             return and(inArray(table.id, ownersWithTotalCount), inArray(table.id, ownersWithMatchingCount));
         }
         // For multi-valued relations, allow `in_array` to act as a subset check:
         // The provided values must contain ALL relation values of the document.
         if (fieldConfig.many && operator === 'in_array') {
-            // Accept array inputs, repeated params, or CSV values for in_array checks
-            let values = (() => {
-                if (Array.isArray(rawValue))
-                    return rawValue;
-                if (typeof rawValue === 'string' && rawValue.includes(','))
-                    return rawValue.split(',');
-                if (Array.isArray(value))
-                    return value;
-                return [value];
-            })();
-            // Ensure values are unique
-            values = Array.from(new Set(values));
+            // Accept various input forms and normalize to a unique array
+            const values = normalizeValues(rawValue, value);
             // Owners that have at least one relation row not included in the provided set
-            const ownersWithNonMatching = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(drizzleORM.notInArray(relationTable[`${to}Id`], values), eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.gt(drizzleORM.count(relationTable.id), 0));
+            const ownersWithNonMatching = buildOwnersWithNonMatching(values);
             // Owners that have any relation rows (to exclude docs with no relations)
-            const ownersWithRelations = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.gt(drizzleORM.count(relationTable.id), 0));
+            const ownersWithRelations = buildOwnersWithRelations();
             // Match documents that have relations and do NOT have any non-matching relation rows
             return and(drizzleORM.notInArray(table.id, ownersWithNonMatching), inArray(table.id, ownersWithRelations));
         }
         // For multi-valued relations, `not_in_array` should match documents where the provided
         // set does NOT contain all of the document's relation values (inverse of `in_array`).
         if (fieldConfig.many && operator === 'not_in_array') {
-            let values = (() => {
-                if (Array.isArray(rawValue))
-                    return rawValue;
-                if (typeof rawValue === 'string' && rawValue.includes(','))
-                    return rawValue.split(',');
-                if (Array.isArray(value))
-                    return value;
-                return [value];
-            })();
-            values = Array.from(new Set(values));
-            const ownersWithNonMatching = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(drizzleORM.notInArray(relationTable[`${to}Id`], values), eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.gt(drizzleORM.count(relationTable.id), 0));
+            // Accept various input forms and normalize to a unique array
+            const values = normalizeValues(rawValue, value);
+            const ownersWithNonMatching = buildOwnersWithNonMatching(values);
             return inArray(table.id, ownersWithNonMatching);
         }
         // For multi-valued relations, `not_equals` is the inverse of `equals` (exact-set inequality)
         if (fieldConfig.many && operator === 'not_equals') {
-            let values = (() => {
-                if (Array.isArray(rawValue))
-                    return rawValue;
-                if (typeof rawValue === 'string' && rawValue.includes(','))
-                    return rawValue.split(',');
-                if (Array.isArray(value))
-                    return value;
-                return [value];
-            })();
-            values = Array.from(new Set(values));
-            const ownersWithTotalCount = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.eq(drizzleORM.count(relationTable.id), values.length));
-            const ownersWithMatchingCount = db
-                .select({ id: relationTable.ownerId })
-                .from(relationTable)
-                .where(and(inArray(relationTable[`${to}Id`], values), eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
-                .groupBy(relationTable.ownerId)
-                .having(drizzleORM.eq(drizzleORM.count(relationTable.id), values.length));
+            // Accept various input forms and normalize to a unique array
+            const values = normalizeValues(rawValue, value);
+            const ownersWithTotalCount = buildOwnersWithTotalCount(values.length);
+            const ownersWithMatchingCount = buildOwnersWithMatchingCount(values);
             return or(drizzleORM.notInArray(table.id, ownersWithTotalCount), drizzleORM.notInArray(table.id, ownersWithMatchingCount));
         }
+        // Handle single-valued relations and other operators
         // Default behavior (membership checks with in_array etc.)
-        const conditions = [eq(relationTable.path, column), fn(relationTable[`${to}Id`], value)];
-        if (localized) {
-            conditions.push(eq(relationTable.locale, locale));
-        }
+        const conditions = [
+            eq(relsTable.path, column),
+            fn(relsTable[`${to}Id`], value),
+            ...(localized ? [eq(relsTable.locale, locale)] : [])
+        ];
         return inArray(table.id, db
-            .select({ id: relationTable.ownerId })
-            .from(relationTable)
+            .select({ id: relsTable.ownerId })
+            .from(relsTable)
             .where(and(...conditions)));
     };
     return buildCondition(query.where);
@@ -252,6 +259,7 @@ const operators = {
     greater_than: drizzleORM.gt
 };
 const isOperator = (str) => Object.keys(operators).includes(str);
+// Format value based on operator and type
 const formatValue = ({ operator, value }) => {
     switch (true) {
         case typeof value === 'string' &&
@@ -269,3 +277,43 @@ const formatValue = ({ operator, value }) => {
             return value;
     }
 };
+// Extract column, operator, and raw value from condition object
+function getConditionMembers(obj) {
+    const [column, operatorObj] = Object.entries(obj)[0];
+    const [operator, rawValue] = Object.entries(operatorObj)[0];
+    if (!isOperator(operator)) {
+        throw new RimeError(RimeError.INVALID_DATA, operator + 'is not supported');
+    }
+    // get the correct Drizzle operator
+    const fn = operators[operator];
+    // Convert dot notation to double underscore
+    // for fields included in groups or tabs
+    const sqlColumn = column.replace(/\./g, '__');
+    // Format compared value to support Date, Arrays,...
+    const value = formatValue({ operator, value: rawValue });
+    return { column, sqlColumn, fn, operator, rawValue, value };
+}
+// Determine if we should handle versioned hierarchy fields
+function shouldHandleVersionedHierarchyFields(slug, sqlColumn) {
+    return hasVersionsSuffix(slug) && (sqlColumn === '_parent' || sqlColumn === '_position' || sqlColumn === '_path');
+}
+// Normalize condition object for versioned collections
+function normalizedForVersion(conditionObject, slug) {
+    // Handle id field for versioned collections
+    // if "id" inside the query it should refer to the root table
+    if (hasVersionsSuffix(slug) && 'id' in conditionObject) {
+        // Replace id with ownerId and keep the same operator and value
+        const idOperator = conditionObject.id;
+        delete conditionObject.id;
+        conditionObject.ownerId = idOperator;
+    }
+    // Handle versionId field for versioned collections
+    // if "versionId" inside the query it should refer to the id of the version table (current)
+    if (hasVersionsSuffix(slug) && 'versionId' in conditionObject) {
+        // Replace id with ownerId and keep the same operator and value
+        const idOperator = conditionObject.versionId;
+        delete conditionObject.versionId;
+        conditionObject.id = idOperator;
+    }
+    return conditionObject;
+}

package/dist/core/config/shared/find-title.d.ts

@@ -4,8 +4,8 @@ import type { DateField } from '../../../fields/date/index.js';
 import type { EmailField } from '../../../fields/email/index.js';
 import type { SlugField } from '../../../fields/slug/index.js';
 import type { TextField } from '../../../fields/text/index.js';
-import type { Field, FormField } from '../../../fields/types.js';
-export declare const hasMaybeTitle: (field: Field) => field is TextField | DateField | SlugField | EmailField;
+import type { Field, FormField, RichTextField } from '../../../fields/types.js';
+export declare const hasMaybeTitle: (field: Field) => field is TextField | DateField | SlugField | EmailField | RichTextField;
 interface TitleFieldResult {
     field: FormFieldBuilder<FormField>;
     path: string;

package/dist/core/config/shared/find-title.js

@@ -1,7 +1,7 @@
 import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
 import { isGroupField } from '../../../fields/group/index.js';
 import { TabsBuilder } from '../../../fields/tabs/index.js';
-export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email'].includes(field.type);
+export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
 export function findTitleField(fields = [], basePath = '') {
     for (const field of fields) {
         // Direct check for isTitle

package/dist/core/operations/hooks/before-read/set-document-title.server.js

@@ -1,4 +1,5 @@
-import { getValueAtPath } from '../../../../util/object.js';
+import { getValueAtPath, isObjectLiteral } from '../../../../util/object.js';
+import { richTextJSONToText } from '../../../../fields/rich-text/client.js';
 import { Hooks } from '../index.server.js';
 export const setDocumentTitle = Hooks.beforeRead(async (args) => {
     const config = args.config;
@@ -7,8 +8,20 @@ export const setDocumentTitle = Hooks.beforeRead(async (args) => {
     const hasSelect = Array.isArray(paramSelect) && paramSelect.length;
     const shouldSetTitle = !doc.title && (!hasSelect || (hasSelect && paramSelect.includes('title')));
     if (shouldSetTitle) {
+        function computeTitleFromValue(value) {
+            // Handle rich text value
+            if (isObjectLiteral(value) && 'content' in value) {
+                return richTextJSONToText(value);
+            }
+            if (typeof value === 'string') {
+                return value;
+            }
+            return doc.id;
+        }
+        const titleRaw = getValueAtPath(config.asTitle, doc);
+        const title = computeTitleFromValue(titleRaw);
         doc = {
-            title: getValueAtPath(config.asTitle, doc),
+            title,
             ...doc
         };
     }

package/dist/fields/relation/component/Cell.svelte

@@ -17,7 +17,7 @@
 	let { value }: Props = $props();
 	let displayCount = $derived(value && value.length > 1);
 
-	const APIProxy = getAPIProxyContext(API_PROXY.DOCUMENT);
+	const APIProxy = getAPIProxyContext(API_PROXY.ROOT);
 
 	let APIUrl = $derived.by(() => {
 		if (value && value.length && value[0].documentId) {
@@ -33,7 +33,7 @@
 	});
 </script>
 
-<span>
+<span class="rz-relation-cell">
 	{#if displayCount}
 		{value.length} items
 	{:else if ressource?.data?.doc}
@@ -44,15 +44,21 @@
 			/>
 			{ressource.data.doc.title}
 		{:else}
-			{ressource.data.doc.title}
+			<span class="rz-relation-cell__title">{ressource.data.doc.title}</span>
 		{/if}
 	{/if}
 </span>
 
 <style>
-	span {
+	.rz-relation-cell {
 		display: flex;
 		gap: var(--rz-size-2);
 		align-items: center;
 	}
+	.rz-relation-cell__title {
+		overflow: hidden;
+		display: -webkit-box;
+		-webkit-box-orient: vertical;
+		-webkit-line-clamp: 1;
+	}
 </style>

package/dist/fields/relation/component/default/Default.svelte

@@ -83,7 +83,7 @@
 		>
 			{#each selectedItems as item (item.documentId)}
 				<Tag onRemove={() => removeValue(item.documentId)} {readOnly}>
-					{item.label}
+					<a href={item.editUrl}>{item.label}</a>
 				</Tag>
 			{/each}
 

package/dist/fields/rich-text/index.d.ts

@@ -9,6 +9,7 @@ export declare class RichTextFieldBuilder extends FormFieldBuilder<RichTextField
     get cell(): import("svelte").Component<{
         value: string;
     }, {}, "">;
+    isTitle(): this;
     /**
      * Sets a custom TipTap editor configuration for the rich text field.
      *
@@ -44,6 +45,7 @@ type RichTextContent = {
 };
 export type RichTextField = FormField & {
     type: 'richText';
+    isTitle?: true;
     features?: Array<RichTextFeature>;
     defaultValue?: RichTextContent | DefaultValueFn<RichTextContent>;
 };