@stoker-platform/web-app 0.5.226 → 0.5.228

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @stoker-platform/web-app
 
+## 0.5.228
+
+### Patch Changes
+
+- Updated dependencies
+    - @stoker-platform/node-client@0.5.89
+
+## 0.5.227
+
+### Patch Changes
+
+- feat: use equality filter for one-to relation filters
+
 ## 0.5.226
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stoker-platform/web-app",
-    "version": "0.5.226",
+    "version": "0.5.228",
     "type": "module",
     "license": "SEE LICENSE IN LICENSE.md",
     "scripts": {
@@ -51,7 +51,7 @@
         "@radix-ui/react-tooltip": "^1.2.8",
         "@react-google-maps/api": "^2.20.8",
         "@sentry/react": "^10.56.0",
-        "@stoker-platform/node-client": "0.5.88",
+        "@stoker-platform/node-client": "0.5.89",
         "@stoker-platform/utils": "0.5.79",
         "@stoker-platform/web-client": "0.5.94",
         "@tanstack/react-table": "^8.21.3",

package/src/Collection.tsx

@@ -1541,9 +1541,14 @@ function Collection({
             }
         }
         if (relationList) {
+            const relationListField = getField(fields, relationList.field)
+            const relationListUsesArrayContains = ["ManyToOne", "ManyToMany"].includes(relationListField.type)
             filters.forEach((filter) => {
                 if (filter.type === "relation") {
-                    if (!isPreloadCacheEnabled || filter.field === relationList.field) {
+                    if (
+                        filter.field === relationList.field ||
+                        (!isPreloadCacheEnabled && relationListUsesArrayContains)
+                    ) {
                         excluded.push(filter.field)
                     }
                 }
@@ -1553,7 +1558,7 @@ function Collection({
             }
         }
         return excluded
-    }, [isPreloadCacheEnabled, cardsConfig, statusField, tab, filters])
+    }, [isPreloadCacheEnabled, cardsConfig, statusField, tab, filters, relationList, fields])
 
     const filtersActive = useMemo(() => {
         return (

package/src/Filters.tsx

@@ -103,9 +103,12 @@ export function Filters({
 
     const preventChange = isRouteLoadingImmediate.has(location.pathname)
 
-    const isArrayOrRelationFilter = useCallback(
+    const isArrayContainsFilter = useCallback(
         (filter: Filter): filter is SelectFilter | RelationFilter => {
-            if (filter.type === "relation") return true
+            if (filter.type === "relation") {
+                const fieldSchema = getField(fields, filter.field)
+                return ["ManyToOne", "ManyToMany"].includes(fieldSchema.type)
+            }
             if (filter.type === "select") {
                 const fieldSchema = getField(fields, filter.field)
                 return fieldSchema.type === "Array"
@@ -116,11 +119,13 @@ export function Filters({
     )
 
     const isIncludeAssignedActive = useCallback(() => {
-        if (!isAssigning || !assignable?.includeAssignedInFilters?.length) return false
+        if (!isAssigning || !assignable?.includeAssignedInFilters?.length || !relationList) return false
+        const relationField = getField(fields, relationList.field)
+        if (["OneToOne", "OneToMany"].includes(relationField.type)) return false
         return assignable.includeAssignedInFilters.some((field) =>
             filters.some((filter) => filter.type === "select" && filter.field === field && filter.value),
         )
-    }, [isAssigning, assignable, filters])
+    }, [isAssigning, assignable, filters, relationList, fields])
 
     const isMobile = useIsMobile()
     const someFilterOpen = Object.values(open).some(Boolean)
@@ -213,14 +218,14 @@ export function Filters({
             }
         }
 
-        const arrayOrRelationFilter = filters.find(
-            (filter): filter is SelectFilter | RelationFilter => !!filter.value && isArrayOrRelationFilter(filter),
+        const arrayContainsFilter = filters.find(
+            (filter): filter is SelectFilter | RelationFilter => !!filter.value && isArrayContainsFilter(filter),
         )
-        if (arrayOrRelationFilter) {
-            arrayOrRelationField = arrayOrRelationFilter.field
+        if (arrayContainsFilter) {
+            arrayOrRelationField = arrayContainsFilter.field
         }
         setArrayContainsFilterSet(arrayOrRelationField)
-    }, [filters, isAssigning, assignable, isPreloadCacheEnabled, isIncludeAssignedActive, isArrayOrRelationFilter])
+    }, [filters, isAssigning, assignable, isPreloadCacheEnabled, isIncludeAssignedActive, isArrayContainsFilter])
 
     const handleChange = useCallback(
         (filter: Filter, value: string, type: CollectionField["type"]) => {
@@ -454,19 +459,36 @@ export function Filters({
         (filter: Filter) => {
             if (filter.type === "range" || filter.type === "status") return false
             const fieldSchema = getField(fields, filter.field)
+            const relationField = relationList ? getField(fields, relationList.field) : undefined
+            const includeAssignedUsesArrayContains =
+                isAssigning &&
+                !!assignable?.includeAssignedInFilters?.includes(filter.field) &&
+                !!relationField &&
+                ["ManyToOne", "ManyToMany"].includes(relationField.type)
             return !!(
                 (!isPreloadCacheEnabled &&
                     arrayContainsFilterSet &&
                     arrayContainsFilterSet !== filter.field &&
-                    (filter.type === "relation" ||
+                    ((filter.type === "relation" && ["ManyToOne", "ManyToMany"].includes(fieldSchema.type)) ||
                         fieldSchema.type === "Array" ||
-                        (isAssigning && assignable?.includeAssignedInFilters?.includes(filter.field)))) ||
+                        includeAssignedUsesArrayContains)) ||
                 (isRelationField(fieldSchema) &&
                     connectionStatus === "offline" &&
                     !preloadCacheEnabled(schema.collections[fieldSchema.collection]))
             )
         },
-        [isPreloadCacheEnabled, arrayContainsFilterSet, isRouteLoading, location.pathname, fields],
+        [
+            isPreloadCacheEnabled,
+            arrayContainsFilterSet,
+            isRouteLoading,
+            location.pathname,
+            fields,
+            relationList,
+            isAssigning,
+            assignable,
+            connectionStatus,
+            schema,
+        ],
     )
 
     return (

package/src/providers/FiltersProvider.tsx

@@ -152,11 +152,17 @@ export const FiltersProvider: React.FC<FiltersProviderProps> = ({
                             if (includeValueInFilters) {
                                 filterValues.push(includeValueInFilters.includeValue as string | number)
                             }
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                            const relationField = getField(fields, relationList!.field)
+                            const assignedConstraint = ["OneToOne", "OneToMany"].includes(relationField.type)
+                                ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                  where(`${relationList!.field}_Single.id`, "==", relationParent!.id)
+                                : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                                  where(`${relationList!.field}_Array`, "array-contains", relationParent!.id)
                             constraints.push(
                                 or(
                                     where(filter.field, "in", filterValues),
-                                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                                    where(`${relationList!.field}_Array`, "array-contains", relationParent!.id),
+                                    assignedConstraint,
                                 ) as unknown as QueryConstraint,
                             )
                         } else if (isAssigning && includeValueInFilters) {
@@ -169,7 +175,11 @@ export const FiltersProvider: React.FC<FiltersProviderProps> = ({
                     }
                     if (filter.type === "relation") {
                         const field = getField(fields, filter.field)
-                        constraints.push(where(`${field.name}_Array`, "array-contains", filter.value))
+                        if (["OneToOne", "OneToMany"].includes(field.type)) {
+                            constraints.push(where(`${field.name}_Single.id`, "==", filter.value))
+                        } else {
+                            constraints.push(where(`${field.name}_Array`, "array-contains", filter.value))
+                        }
                     }
                 })
                 if (!isPreloadCacheEnabled) {
@@ -240,7 +250,11 @@ export const FiltersProvider: React.FC<FiltersProviderProps> = ({
                     }
                     if (filter.type === "relation") {
                         const field = getField(fields, filter.field)
-                        constraints.push([`${field.name}_Array`, "array-contains", filter.value])
+                        if (["OneToOne", "OneToMany"].includes(field.type)) {
+                            constraints.push([`${field.name}_Single.id`, "==", filter.value])
+                        } else {
+                            constraints.push([`${field.name}_Array`, "array-contains", filter.value])
+                        }
                     }
                 })
                 if (!isPreloadCacheEnabled) {