rimecms 0.23.26 → 0.23.27

package/dist/adapter-sqlite/where.js

@@ -100,6 +100,13 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
             // 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
         }
+        // Unsupported operator for multi-valued relations
+        const supportedRelationManyOperators = ['equals', 'not_equals', 'in_array', 'not_in_array'];
+        if (fieldConfig.many && !supportedRelationManyOperators.includes(operator)) {
+            logger.warn(`the operator "${operator}" is not supported for multi-valued relation field "${column}" in ${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
+        }
         // Only compare with the relation ID for now
         // @TODO handle relation props ex: author.email
         const [to, localized] = [fieldConfig.relationTo, fieldConfig.localized];
@@ -109,31 +116,114 @@ export const buildWhereParam = ({ query, slug, db, locale, tables, configCtx })
         // 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 = Array.isArray(rawValue)
-                ? rawValue
-                : typeof rawValue === 'string' && rawValue.includes(',')
-                    ? rawValue.split(',')
-                    : [value];
+            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));
             // Owners with total relation count equal to values.length
             const ownersWithTotalCount = db
                 .select({ id: relationTable.ownerId })
                 .from(relationTable)
-                .where(and(...(localized ? [eq(relationTable.locale, locale)] : [])))
+                .where(and(eq(relationTable.path, column), ...(localized ? [eq(relationTable.locale, locale)] : [])))
                 .groupBy(relationTable.ownerId)
                 .having(drizzleORM.eq(drizzleORM.count(relationTable.id), 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), ...(localized ? [eq(relationTable.locale, locale)] : [])))
+                .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));
             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));
+            // 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));
+            // 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));
+            // 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));
+            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));
+            return or(drizzleORM.notInArray(table.id, ownersWithTotalCount), drizzleORM.notInArray(table.id, ownersWithMatchingCount));
+        }
         // Default behavior (membership checks with in_array etc.)
-        const conditions = [fn(relationTable[`${to}Id`], value)];
+        const conditions = [eq(relationTable.path, column), fn(relationTable[`${to}Id`], value)];
         if (localized) {
             conditions.push(eq(relationTable.locale, locale));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rimecms",
-	"version": "0.23.26",
+	"version": "0.23.27",
 	"homepage": "https://github.com/bienbiendev/rime",
 	"scripts": {
 		"dev": "vite dev",