@stoker-platform/web-app 0.5.225 → 0.5.227

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @stoker-platform/web-app
 
+## 0.5.227
+
+### Patch Changes
+
+- feat: use equality filter for one-to relation filters
+
+## 0.5.226
+
+### Patch Changes
+
+- feat: apply search to list metrics
+
 ## 0.5.225
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stoker-platform/web-app",
-    "version": "0.5.225",
+    "version": "0.5.227",
     "type": "module",
     "license": "SEE LICENSE IN LICENSE.md",
     "scripts": {

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/List.tsx

@@ -1345,9 +1345,9 @@ export function List({
             if (permissions?.Role && (!metric.roles || metric.roles.includes(permissions?.Role))) {
                 if (metric.type === "custom" && metric.formula) {
                     // eslint-disable-next-line security/detect-object-injection
-                    values[index] = metric.formula(list).toString() || ""
+                    values[index] = metric.formula(searchList).toString() || ""
                 } else if (metric.type === "count") {
-                    let value = (list?.length || 0).toString()
+                    let value = (searchList.length || 0).toString()
                     if (metric.prefix) {
                         value = `${metric.prefix}${value}`
                     }
@@ -1361,7 +1361,7 @@ export function List({
                     let value: string
                     const field = getField(fields, metric.field)
                     const fieldCustomization = getFieldCustomization(field, customization)
-                    list?.forEach((record: StokerRecord) => {
+                    searchList.forEach((record: StokerRecord) => {
                         if (!metric.field) return
                         const value = record[metric.field]
                         if (field.type === "Number" && typeof value === "number") {
@@ -1395,7 +1395,7 @@ export function List({
                     let value: string
                     const field = getField(fields, metric.field)
                     const fieldCustomization = getFieldCustomization(field, customization)
-                    list?.forEach((record: StokerRecord) => {
+                    searchList.forEach((record: StokerRecord) => {
                         if (!metric.field) return
                         const value = record[metric.field]
                         if (field.type === "Number" && typeof value === "number") {
@@ -1406,7 +1406,7 @@ export function List({
                             total = newTotal
                         }
                     })
-                    const average = total / list?.length || 0
+                    const average = total / searchList.length || 0
                     const currency = tryFunction(fieldCustomization?.admin?.currency)
                     if (currency) {
                         value = `${currency}${average.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
@@ -1424,7 +1424,7 @@ export function List({
                 } else if (metric.type === "area") {
                     if (metric.metricField1) {
                         const chartData: MetricValue = []
-                        list?.forEach((record: StokerRecord) => {
+                        searchList.forEach((record: StokerRecord) => {
                             if (!record[metric.dateField] || !metric.metricField1) return
                             const date = DateTime.fromJSDate((record[metric.dateField] as Timestamp).toDate(), {
                                 zone: timezone,
@@ -1460,7 +1460,7 @@ export function List({
                         const chartData: MetricValue = []
                         const dateMap = new Map<string, number>()
 
-                        list?.forEach((record: StokerRecord) => {
+                        searchList.forEach((record: StokerRecord) => {
                             if (!record[metric.dateField]) return
                             const date = DateTime.fromJSDate((record[metric.dateField] as Timestamp).toDate(), {
                                 zone: timezone,
@@ -1489,7 +1489,7 @@ export function List({
             }
         })
         return values
-    }, [list])
+    }, [list, searchList])
 
     const [timeRange, setTimeRange] = useState<Record<string, string>>({})
 

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) {