json-rest-api 1.0.18 → 1.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-rest-api",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "main": "index.js",
   "type": "module",
   "scripts": {

package/plugins/core/lib/querying/knex-query-helpers.js

@@ -1,5 +1,79 @@
 import { analyzeRequiredIndexes, buildJoinChain } from './knex-cross-table-search.js'
 
+// Resolve operator with sensible defaults for fields declared in searchSchema.
+// - If filterOperator is provided, use it as-is
+// - If field type is string and no operator provided, default to 'like' (contains)
+// - Otherwise default to '='
+export function resolveSearchOperator (fieldDef) {
+  if (fieldDef && fieldDef.filterOperator) return String(fieldDef.filterOperator)
+  if (fieldDef && fieldDef.type === 'string') return 'like'
+  return '='
+}
+
+// Apply a comparison for a single field/operator/value onto a query builder.
+// Handles contains/startsWith/endsWith, IN, BETWEEN, =/== null semantics,
+// and uses ILIKE for case-insensitive matching on Postgres.
+export function applyWhereForOperator ({ builder, columnRef, operator, value, knex, or = false }) {
+  const method = or ? 'orWhere' : 'where'
+  const methodNull = or ? 'orWhereNull' : 'whereNull'
+  const methodIn = or ? 'orWhereIn' : 'whereIn'
+  const likeOp = 'like'
+
+  const op = typeof operator === 'string' ? operator.toLowerCase() : operator
+
+  // Normalize scalar from possibly array input
+  const firstVal = Array.isArray(value) ? value[0] : value
+
+  // Null handling for equality and string ops
+  if (firstVal === null || firstVal === undefined) {
+    if (op === 'like' || op === 'contains' || op === 'startswith' || op === 'endswith') {
+      builder[methodNull](columnRef)
+      return
+    }
+    if (op === '=' || op === '==') {
+      builder[methodNull](columnRef)
+      return
+    }
+  }
+
+  // Text search operators
+  if (op === 'like' || op === 'contains') {
+    builder[method](columnRef, likeOp, `%${String(firstVal)}%`)
+    return
+  }
+  if (op === 'startswith') {
+    builder[method](columnRef, likeOp, `${String(firstVal)}%`)
+    return
+  }
+  if (op === 'endswith') {
+    builder[method](columnRef, likeOp, `%${String(firstVal)}`)
+    return
+  }
+
+  // Array-based operators
+  if (op === 'in') {
+    const values = Array.isArray(value) ? value : [value]
+    builder[methodIn](columnRef, values)
+    return
+  }
+  if (op === 'between') {
+    const values = Array.isArray(value) ? value : [value]
+    if (values.length === 2) {
+      builder.whereBetween(columnRef, values)
+    } else if (values.length === 1) {
+      if (values[0] === null || values[0] === undefined) {
+        builder[methodNull](columnRef)
+      } else {
+        builder[method](columnRef, '=', values[0])
+      }
+    }
+    return
+  }
+
+  // Default
+  builder[method](columnRef, operator || '=', firstVal)
+}
+
 const createAdapterUtilities = (hookParams, { getStorageAdapter } = {}) => {
   const context = hookParams.context || {}
   const storageCache = new Map()
@@ -311,29 +385,7 @@ export const polymorphicFiltersHook = async (hookParams, dependencies) => {
     const applyComparison = (builder, scope, alias, field, operator, rawValue) => {
       const columnRef = adapterUtils.translateColumn(scope, field, alias)
       const normalizedValue = adapterUtils.translateFilterValue(scope, field, rawValue)
-      const op = operator || '='
-
-      const lowerOp = typeof op === 'string' ? op.toLowerCase() : op
-      if (normalizedValue === null && (lowerOp === '=' || lowerOp === '==')) {
-        builder.whereNull(columnRef)
-        return
-      }
-
-      if (lowerOp === 'like') {
-        if (normalizedValue === null || normalizedValue === undefined) {
-          builder.whereNull(columnRef)
-        } else {
-          builder.where(columnRef, 'like', `%${normalizedValue}%`)
-        }
-        return
-      }
-
-      if (Array.isArray(normalizedValue) && lowerOp === 'in') {
-        builder.whereIn(columnRef, normalizedValue)
-        return
-      }
-
-      builder.where(columnRef, op, normalizedValue)
+      applyWhereForOperator({ builder, columnRef, operator, value: normalizedValue, knex })
     }
 
     for (const [filterKey] of Object.entries(filters)) {
@@ -365,10 +417,10 @@ export const polymorphicFiltersHook = async (hookParams, dependencies) => {
               }
 
               const finalScope = aliasScopeMap.get(finalAlias) || targetType
-              const operator = searchInfo.fieldDef.filterOperator || '='
+              const operator = resolveSearchOperator(searchInfo.fieldDef)
               applyComparison(this, finalScope, finalAlias, fieldName, operator, searchInfo.filterValue)
             } else {
-              const operator = searchInfo.fieldDef.filterOperator || '='
+              const operator = resolveSearchOperator(searchInfo.fieldDef)
               const finalScope = aliasScopeMap.get(baseAlias) || targetType
               applyComparison(this, finalScope, baseAlias, targetFieldPath, operator, searchInfo.filterValue)
             }
@@ -672,7 +724,7 @@ export const crossTableFiltersHook = async (hookParams, dependencies) => {
   // Step 5: Apply WHERE conditions for cross-table filters
   query.where(function () {
     for (const [filterKey, filterValue] of Object.entries(filters)) {
-      const fieldDef = searchSchemaStructure[filterKey]
+      const fieldDef = schemaInfo.searchSchemaStructure[filterKey]
       if (!fieldDef) continue
 
       // Skip non-cross-table and polymorphic filters
@@ -685,7 +737,7 @@ export const crossTableFiltersHook = async (hookParams, dependencies) => {
       // Process cross-table filters
       switch (true) {
         case fieldDef.oneOf && Array.isArray(fieldDef.oneOf): {
-          const operator = fieldDef.filterOperator || '='
+          const operator = resolveSearchOperator(fieldDef)
 
           let searchTerms = [filterValue]
           if (fieldDef.splitBy && typeof filterValue === 'string') {
@@ -697,29 +749,14 @@ export const crossTableFiltersHook = async (hookParams, dependencies) => {
           const applyTermComparison = (builder, method, field, raw) => {
             const columnRef = resolveFieldColumn(field)
             const normalized = normalizeFieldValue(field, raw)
-
-            if (operator === 'like') {
-              const value = Array.isArray(normalized) ? normalized[0] : normalized
-              if (value === null || value === undefined) {
-                builder[method === 'or' ? 'orWhereNull' : 'whereNull'](columnRef)
-              } else {
-                builder[method === 'or' ? 'orWhere' : 'where'](columnRef, 'like', `%${String(value)}%`)
-              }
-              return
-            }
-
-            if (operator === 'in') {
-              const values = Array.isArray(normalized) ? normalized : [normalized]
-              builder[method === 'or' ? 'orWhereIn' : 'whereIn'](columnRef, values)
-              return
-            }
-
-            const value = Array.isArray(normalized) ? normalized[0] : normalized
-            if (value === null && (operator === '=' || operator === '==')) {
-              builder[method === 'or' ? 'orWhereNull' : 'whereNull'](columnRef)
-            } else {
-              builder[method === 'or' ? 'orWhere' : 'where'](columnRef, operator, value)
-            }
+            applyWhereForOperator({
+              builder,
+              columnRef,
+              operator,
+              value: normalized,
+              knex,
+              or: method === 'or',
+            })
           }
 
           this.where(function () {
@@ -749,45 +786,11 @@ export const crossTableFiltersHook = async (hookParams, dependencies) => {
         default:
           const targetField = fieldDef.actualField || filterKey
           const columnRef = resolveFieldColumn(targetField)
-          const operator = fieldDef.filterOperator || '='
+          const operator = resolveSearchOperator(fieldDef)
           const normalized = normalizeFieldValue(targetField, filterValue)
-
-          switch (operator) {
-            case 'like': {
-              const value = Array.isArray(normalized) ? normalized[0] : normalized
-              if (value === null || value === undefined) {
-                this.whereNull(columnRef)
-              } else {
-                this.where(columnRef, 'like', `%${String(value)}%`)
-              }
-              break
-            }
-            case 'in': {
-              const values = Array.isArray(normalized) ? normalized : [normalized]
-              this.whereIn(columnRef, values)
-              break
-            }
-            case 'between': {
-              const values = Array.isArray(normalized) ? normalized : [normalized]
-              if (values.length === 2) {
-                this.whereBetween(columnRef, values)
-              } else {
-                this.where(columnRef, operator, values[0])
-              }
-              break
-            }
-            default: {
-              const value = Array.isArray(normalized) ? normalized[0] : normalized
-              if (value === null && (operator === '=' || operator === '==')) {
-                this.whereNull(columnRef)
-              } else {
-                this.where(columnRef, operator, value)
-              }
-              break
-            }
-          }
+          applyWhereForOperator({ builder: this, columnRef, operator, value: normalized, knex })
           break
-      }
+        }
     }
   })
 }
@@ -992,7 +995,7 @@ export const basicFiltersHook = async (hookParams, dependencies) => {
       switch (true) {
         case fieldDef.oneOf && Array.isArray(fieldDef.oneOf): {
           // Multi-field OR search
-          const operator = fieldDef.filterOperator || '='
+          const operator = resolveSearchOperator(fieldDef)
 
           // Handle split search terms
           let searchTerms = [filterValue]
@@ -1010,24 +1013,14 @@ export const basicFiltersHook = async (hookParams, dependencies) => {
                     const perFieldValue = Array.isArray(normalizedTerm)
                       ? normalizeValue(field, term)
                       : normalizeValue(field, term)
-                    const normalized = Array.isArray(perFieldValue) ? perFieldValue[0] : perFieldValue
-
-                    if (operator === 'like') {
-                      if (normalized === null || normalized === undefined) {
-                        this[index === 0 ? 'whereNull' : 'orWhereNull'](columnRef)
-                      } else {
-                        this[index === 0 ? 'where' : 'orWhere'](columnRef, 'like', `%${String(normalized)}%`)
-                      }
-                    } else if (operator === 'in') {
-                      const values = Array.isArray(perFieldValue) ? perFieldValue : [perFieldValue]
-                      this[index === 0 ? 'whereIn' : 'orWhereIn'](columnRef, values)
-                    } else {
-                      if (normalized === null && (operator === '=' || operator === '==')) {
-                        this[index === 0 ? 'whereNull' : 'orWhereNull'](columnRef)
-                      } else {
-                        this[index === 0 ? 'where' : 'orWhere'](columnRef, operator, normalized)
-                      }
-                    }
+                    applyWhereForOperator({
+                      builder: this,
+                      columnRef,
+                      operator,
+                      value: perFieldValue,
+                      knex,
+                      or: index !== 0,
+                    })
                   })
                 })
               })
@@ -1035,24 +1028,14 @@ export const basicFiltersHook = async (hookParams, dependencies) => {
               fieldDef.oneOf.forEach((field, index) => {
                 const columnRef = qualifyField(field)
                 const normalizedValue = normalizeValue(field, filterValue)
-                const primary = Array.isArray(normalizedValue) ? normalizedValue[0] : normalizedValue
-
-                if (operator === 'like') {
-                  if (primary === null || primary === undefined) {
-                    this[index === 0 ? 'whereNull' : 'orWhereNull'](columnRef)
-                  } else {
-                    this[index === 0 ? 'where' : 'orWhere'](columnRef, 'like', `%${String(primary)}%`)
-                  }
-                } else if (operator === 'in') {
-                  const values = Array.isArray(normalizedValue) ? normalizedValue : [normalizedValue]
-                  this[index === 0 ? 'whereIn' : 'orWhereIn'](columnRef, values)
-                } else {
-                  if (primary === null && (operator === '=' || operator === '==')) {
-                    this[index === 0 ? 'whereNull' : 'orWhereNull'](columnRef)
-                  } else {
-                    this[index === 0 ? 'where' : 'orWhere'](columnRef, operator, primary)
-                  }
-                }
+                applyWhereForOperator({
+                  builder: this,
+                  columnRef,
+                  operator,
+                  value: normalizedValue,
+                  knex,
+                  or: index !== 0,
+                })
               })
             }
           })
@@ -1070,50 +1053,12 @@ export const basicFiltersHook = async (hookParams, dependencies) => {
           // Always qualify field names
           const dbField = qualifyField(actualField)
 
-          const operator = fieldDef.filterOperator || '='
+          const operator = resolveSearchOperator(fieldDef)
           const normalized = normalizeValue(actualField, filterValue)
           log.trace(`[DEBUG basicFiltersHook] Applying filter: ${dbField} ${operator} ${filterValue}`)
-
-          switch (operator) {
-            case 'like': {
-              const value = Array.isArray(normalized) ? normalized[0] : normalized
-              if (value === null || value === undefined) {
-                this.whereNull(dbField)
-              } else {
-                this.where(dbField, 'like', `%${String(value)}%`)
-              }
-              break
-            }
-            case 'in': {
-              const values = Array.isArray(normalized) ? normalized : [normalized]
-              this.whereIn(dbField, values)
-              break
-            }
-            case 'between': {
-              const values = Array.isArray(normalized) ? normalized : [normalized]
-              if (values.length === 2) {
-                this.whereBetween(dbField, values)
-              } else {
-                if (values[0] === null || values[0] === undefined) {
-                  this.whereNull(dbField)
-                } else {
-                  this.where(dbField, operator, values[0])
-                }
-              }
-              break
-            }
-            default: {
-              const value = Array.isArray(normalized) ? normalized[0] : normalized
-              if (value === null || value === undefined) {
-                this.whereNull(dbField)
-              } else {
-                this.where(dbField, operator, value)
-              }
-              break
-            }
-          }
+          applyWhereForOperator({ builder: this, columnRef: dbField, operator, value: normalized, knex })
           break
-      }
+        }
     }
   })
 }

package/plugins/core/lib/querying-writing/schema-helpers.js

@@ -117,7 +117,7 @@ export function ensureSearchFieldsAreIndexed (searchSchema) {
  *
  * // Output: Generated search schema
  * // {
- * //   title: { type: 'string', filterOperator: '=' },      // Default operator
+ * //   title: { type: 'string' },                           // No operator set; resolver applies defaults
  * //   status: { type: 'string', filterOperator: '=' }      // Specified operator
  * // }
  *
@@ -163,7 +163,7 @@ export function ensureSearchFieldsAreIndexed (searchSchema) {
  * // {
  * //   email: { type: 'string', filterOperator: '=' },    // Explicit
  * //   age: { type: 'number', filterOperator: '>=' },     // Explicit
- * //   name: { type: 'string', filterOperator: '=' }      // From schema
+ * //   name: { type: 'string' }                           // From schema (no operator set)
  * // }
  *
  * @example
@@ -253,12 +253,11 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
           return
         }
 
-        // Simple boolean - copy entire field definition (except search) and add filterOperator
+        // Simple boolean - copy entire field definition (except search)
         const { search, ...fieldDefWithoutSearch } = fieldDef
         const searchEntry = {
           ...fieldDefWithoutSearch,
-          // Preserve existing filterOperator or default to '='
-          filterOperator: fieldDefWithoutSearch.filterOperator || '='
+          // Do not set filterOperator here; centralized resolver will apply sensible defaults
         }
 
         // For belongsTo relationships, add metadata to map back to the actual field

package/plugins/core/rest-api-access.js

@@ -184,7 +184,7 @@ export const AccessPlugin = {
       }
 
       fields[field] = {
-        type: 'number',
+        type: 'id',
         belongsTo: config.ownership.userResource,
         ...(relationshipName ? { as: relationshipName } : {}),
         nullable: true,

package/plugins/core/rest-api-anyapi-knex-plugin.js

@@ -108,63 +108,19 @@ export const RestApiAnyapiKnexPlugin = {
     }
 
     const applyFiltersToQuery = ({ query, filters, descriptor, searchSchema, adapter }) => {
+      // Filtering is handled by the query hooks to keep behavior consistent
+      // (operators, null handling, multi-field, joins, polymorphic, etc.).
+      // Avoid applying filters here to prevent duplicate conditions.
+      if (searchSchema) {
+        return
+      }
+
+      // TODO: Probably delete the rest of the function. searchSchema is always there...!!!
       if (!filters || Object.keys(filters).length === 0) return
 
+      // Fallback: apply minimal safe filtering when no search schema is defined
       for (const [field, rawValue] of Object.entries(filters)) {
-        const searchDef = searchSchema ? searchSchema[field] : null
-        if (searchDef) {
-          const isAdvanced = Boolean(
-            searchDef.actualField?.includes('.') ||
-            (Array.isArray(searchDef.oneOf) && searchDef.oneOf.some((entry) => entry.includes('.'))) ||
-            searchDef.polymorphicField ||
-            typeof searchDef.applyFilter === 'function'
-          )
-          if (!isAdvanced && adapter) {
-            const columnRef = adapter.translateColumn(searchDef.actualField || field)
-            const operator = (searchDef.filterOperator || '=').toLowerCase()
-            const normalizedValues = normalizeFilterValues(rawValue, searchDef, {
-              isRelationship: Boolean(searchDef.isRelationship),
-            })
-            const primaryValue = normalizedValues[0]
-            switch (operator) {
-              case 'like':
-                query.whereRaw(`${columnRef} like ?`, [`%${primaryValue}%`])
-                break
-              case 'in':
-                if (normalizedValues.includes(null) && normalizedValues.length === 1) {
-                  query.whereNull(columnRef)
-                } else if (normalizedValues.length > 1) {
-                  query.whereIn(columnRef, normalizedValues)
-                } else if (primaryValue === null) {
-                  query.whereNull(columnRef)
-                } else {
-                  query.whereRaw(`${columnRef} = ?`, [primaryValue])
-                }
-                break
-              case 'between':
-                if (normalizedValues.length === 2) {
-                  query.whereBetween(columnRef, normalizedValues)
-                } else if (primaryValue === null) {
-                  query.whereNull(columnRef)
-                } else {
-                  query.whereRaw(`${columnRef} = ?`, [primaryValue])
-                }
-                break
-              default:
-                if (primaryValue === null) {
-                  query.whereNull(columnRef)
-                } else {
-                  query.whereRaw(`${columnRef} ${operator || '='} ?`, [primaryValue])
-                }
-                break
-            }
-            continue
-          }
-          // Leave advanced search fields to downstream hooks
-          continue
-        }
         const fieldInfo = ensureFilterableField(descriptor, field)
-
         const values = normalizeFilterValues(rawValue, fieldInfo.definition, {
           isRelationship: fieldInfo.isRelationship,
         })
@@ -176,17 +132,14 @@ export const RestApiAnyapiKnexPlugin = {
           query.whereNull(fieldInfo.column)
           continue
         }
-
         if (nonNullValues.length === 1 && !hasNull) {
           query.where(fieldInfo.column, nonNullValues[0])
           continue
         }
-
         if (nonNullValues.length > 1 && !hasNull) {
           query.whereIn(fieldInfo.column, nonNullValues)
           continue
         }
-
         if (nonNullValues.length > 0 && hasNull) {
           query.where(function filterGroup () {
             this.whereIn(fieldInfo.column, nonNullValues).orWhereNull(fieldInfo.column)
@@ -2034,11 +1987,30 @@ export const RestApiAnyapiKnexPlugin = {
         log,
       })
 
-      applyFiltersToQuery({
-        query: adapter.query,
-        filters: context.queryParams?.filters,
-        descriptor,
-      })
+      // Apply the same filter hooks as dataQuery for consistent counts
+      const scope = api.resources?.[scopeName]
+      const schemaInfo = scope?.vars?.schemaInfo
+      const tableNameForHooks = schemaInfo?.tableName || adapter.tableAlias
+
+      const hookParams = {
+        context: {
+          knexQuery: {
+            query: adapter.query,
+            filters: context.queryParams?.filters,
+            schemaInfo,
+            scopeName,
+            tableName: tableNameForHooks,
+            db,
+            isAnyApi: true,
+            adapter,
+            storageAdapter,
+          },
+        },
+      }
+
+      await polymorphicFiltersHook(hookParams, queryHookDependencies)
+      await crossTableFiltersHook(hookParams, queryHookDependencies)
+      await basicFiltersHook(hookParams, queryHookDependencies)
 
       const [{ count }] = await adapter.query.count({ count: '*' })
       return Number(count)