json-rest-api 1.0.23 → 1.0.25

package/plugins/core/lib/querying/knex-relationship-includes.js

@@ -75,9 +75,12 @@
  */
 
 import { applyFieldSelectionToQuery, buildFieldSelection } from '../querying-writing/knex-field-helpers.js'
-import { getForeignKeyFields } from '../querying-writing/field-utils.js'
 import { toJsonApiRecord } from './knex-json-api-transformers-querying.js'
-import { buildWindowedIncludeQuery, applyStandardIncludeConfig, buildOrderByClause } from './knex-window-queries.js'
+import {
+  buildWindowedIncludeSubquery,
+  applyStandardIncludeConfig,
+  buildOrderByClause
+} from './knex-window-queries.js'
 import { unwrapQueryBuilderState } from './query-builder-utils.js'
 import { RELATIONSHIPS_KEY, RELATIONSHIP_METADATA_KEY, ROW_NUMBER_KEY, COMPUTED_DEPENDENCIES_KEY, DEFAULT_QUERY_LIMIT } from '../querying-writing/knex-constants.js'
 import { RestApiResourceError } from '../../../../lib/rest-api-errors.js'
@@ -150,7 +153,8 @@ const applyScopeFiltersToIncludeQuery = async ({
   scopeName,
   requestContext,
   db,
-  tableName
+  tableName,
+  queryPurpose = 'include'
 }) => {
   const scopeObject = scopes[scopeName]
   if (!scopeObject?.applyQueryFilters) {
@@ -166,6 +170,7 @@ const applyScopeFiltersToIncludeQuery = async ({
     tableName: tableName || scopeObject.vars.schemaInfo.tableName,
     db,
     schemaInfo: scopeObject.vars.schemaInfo,
+    queryPurpose,
     storageAdapter
   }, buildScopedIncludeContext({
     requestContext,
@@ -491,8 +496,6 @@ export const loadBelongsTo = async (scope, deps) => {
     // Get target table info
     const targetTableName = scopes[targetScope].vars.schemaInfo.tableName
     const targetIdColumn = getIdColumnForScope(scopes, targetScope)
-    const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
-
     // Build field selection for sparse fieldsets
     const targetScopeObject = scopes[targetScope]
     const storageAdapter = targetScopeObject.vars.storageAdapter
@@ -548,9 +551,9 @@ export const loadBelongsTo = async (scope, deps) => {
 
     // Create lookup map
     const targetById = {}
-      targetRecords.forEach(record => {
-        targetById[getFieldValueForScope(scopes, targetScope, record, 'id')] = record
-      })
+    targetRecords.forEach(record => {
+      targetById[getFieldValueForScope(scopes, targetScope, record, 'id')] = record
+    })
 
     // Set relationships on original records
     const targetRecordsToProcess = []
@@ -695,7 +698,7 @@ export const loadHasMany = async (scope, deps) => {
       const otherKey = relDef.otherKey
 
       if (!foreignKey || !otherKey) {
-        throw new Error(`Missing foreignKey or otherKey in many-to-many relationship '${relName}' for scope '${scopeName}'`)
+        throw new Error(`Missing foreignKey or otherKey in many-to-many relationship '${includeName}' for scope '${scopeName}'`)
       }
 
       // For manyToMany, the target scope is the relationship name itself
@@ -737,12 +740,11 @@ export const loadHasMany = async (scope, deps) => {
       })
 
       // Step 3: Build field selection for sparse fieldsets
-      const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
       const targetScopeObject = scopes[targetScope]
       const storageAdapter = targetScopeObject.vars.storageAdapter
       const targetIdColumn = getIdColumnForScope(scopes, targetScope)
-    const fieldSelectionInfo = fields?.[targetScope]
-      ? await buildFieldSelection(targetScopeObject, {
+      const fieldSelectionInfo = fields?.[targetScope]
+        ? await buildFieldSelection(targetScopeObject, {
           context: {
             ...(requestContext || {}),
             scopeName: targetScope,
@@ -958,7 +960,7 @@ export const loadHasMany = async (scope, deps) => {
       const foreignKey = relDef.foreignKey
 
       if (!foreignKey) {
-        throw new Error(`Missing foreignKey in hasMany relationship '${relName}' for scope '${scopeName}'`)
+        throw new Error(`Missing foreignKey in hasMany relationship '${includeName}' for scope '${scopeName}'`)
       }
 
       log.debug(`[INCLUDE] Loading ${targetScope} records with foreign key ${foreignKey}:`, {
@@ -967,7 +969,6 @@ export const loadHasMany = async (scope, deps) => {
       })
 
       // Build field selection for sparse fieldsets
-      const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
       const targetScopeObject = scopes[targetScope]
       const storageAdapter = targetScopeObject.vars.storageAdapter
       const fieldSelectionInfo = fields?.[targetScope]
@@ -986,46 +987,38 @@ export const loadHasMany = async (scope, deps) => {
 
       // Check if we should use window functions
       if (relDef.include?.strategy === 'window') {
-        try {
-        // Try to build window function query
-          if (fieldSelectionInfo?.queryFieldsToSelect?.length) {
-            throw new Error('Query projection fields require the standard include query path.')
-          }
+        let windowedQuery
 
-          const selectFields = fieldSelectionInfo?.fieldsToSelect || null
-
-          query = buildWindowedIncludeQuery(
+        if (fieldSelectionInfo?.queryFieldsToSelect?.length) {
+          log.debug('[INCLUDE] Query projection fields require the standard include query path')
+        } else {
+          windowedQuery = buildWindowedIncludeSubquery(
             knex,
             targetTable,
             foreignKey,
             mainIds,
-            selectFields,
+            fieldSelectionInfo?.fieldsToSelect || null,
             relDef.include || {},
             capabilities,
-            targetScopeObject.vars  // Pass target scope vars
+            targetScopeObject.vars
           )
+        }
+
+        if (windowedQuery) {
           const scopedQueryState = await applyScopeFiltersToIncludeQuery({
-            query,
+            query: windowedQuery.subquery,
             scopes,
             scopeName: targetScope,
             requestContext,
             db: knex,
             tableName: targetTable
           })
-          query = scopedQueryState.query
+          query = knex
+            .select('*')
+            .from(scopedQueryState.query.as('_windowed'))
+            .where(ROW_NUMBER_KEY, '<=', windowedQuery.effectiveLimit)
           usingWindowFunction = true
           log.debug('[INCLUDE] Using window function strategy with limits')
-        } catch (error) {
-        // If window functions not supported, this will throw a clear error
-          if (error.details?.requiredFeature === 'window_functions') {
-            throw error // Re-throw the descriptive error
-          }
-          // For other errors, fall back to standard query
-          log.warn('[INCLUDE] Window function query failed, falling back to standard query:', {
-            error: error.message,
-            stack: error.stack
-          })
-          usingWindowFunction = false
         }
       }
 
@@ -1199,10 +1192,10 @@ export const loadHasOne = async (scope, deps) => {
   const { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields } = scope
   const { context: { scopes, log, knex, capabilities, requestContext } } = deps
 
-  log = log?.child ? log.child({ method: 'loadHasOne' }) : console
+  const childLog = log?.child ? log.child({ method: 'loadHasOne' }) : console
 
   if (!records || records.length === 0) {
-    log.trace('[INCLUDE] No records to load hasOne for')
+    childLog.trace('[INCLUDE] No records to load hasOne for')
     return
   }
 
@@ -1210,7 +1203,7 @@ export const loadHasOne = async (scope, deps) => {
   const mainIds = [...new Set(records.map(record => getFieldValueForScope(scopes, scopeName, record, 'id')).filter(Boolean))]
 
   if (mainIds.length === 0) {
-    log.trace('[INCLUDE] No parent IDs found, skipping hasOne load')
+    childLog.trace('[INCLUDE] No parent IDs found, skipping hasOne load')
     return
   }
 
@@ -1222,12 +1215,11 @@ export const loadHasOne = async (scope, deps) => {
     throw new Error(`Missing foreignKey in hasOne relationship '${includeName}' for scope '${scopeName}'`)
   }
 
-  log.debug(`[INCLUDE] Loading ${targetScope} records with foreign key ${foreignKey}:`, {
+  childLog.debug(`[INCLUDE] Loading ${targetScope} records with foreign key ${foreignKey}:`, {
     whereIn: mainIds
   })
 
   // Build query for hasOne - expects single result per parent
-  const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
   const targetScopeObject = scopes[targetScope]
   const storageAdapter = targetScopeObject.vars.storageAdapter
 
@@ -1629,7 +1621,6 @@ export const loadReversePolymorphic = async (scope, deps) => {
     })
 
     // Build field selection for sparse fieldsets
-    const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
     const targetScopeObject = scopes[targetScope]
     const storageAdapter = targetScopeObject.vars.storageAdapter
     const targetIdColumn = getIdColumnForScope(scopes, targetScope)
@@ -2121,7 +2112,8 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
         scopeName: relDef.target,
         requestContext,
         db: knex,
-        tableName: targetTable
+        tableName: targetTable,
+        queryPurpose: 'relationship-identifiers'
       })
       query = scopedQueryState.query
 
@@ -2166,7 +2158,8 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
         scopeName: targetScopeName,
         requestContext,
         db: knex,
-        tableName: targetTable
+        tableName: targetTable,
+        queryPurpose: 'relationship-identifiers'
       })
       query = scopedQueryState.query
 
@@ -2205,7 +2198,8 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
           scopeName: targetScope,
           requestContext,
           db: knex,
-          tableName: targetTable
+          tableName: targetTable,
+          queryPurpose: 'relationship-identifiers'
         })
         query = scopedQueryState.query
 

package/plugins/core/lib/querying/knex-window-queries.js

@@ -2,82 +2,21 @@ import { RestApiResourceError } from '../../../../lib/rest-api-errors.js'
 import { ROW_NUMBER_KEY, DEFAULT_QUERY_LIMIT, DEFAULT_MAX_QUERY_LIMIT, DEFAULT_MAX_INCLUDE_LIMIT } from '../querying-writing/knex-constants.js'
 
 /**
- * Builds a window function query for limited includes per parent record
+ * Builds the inner window-function query used to limit included children per
+ * parent. Mandatory target filters must be applied to this inner query before
+ * the caller wraps it and filters by ROW_NUMBER.
  *
  * @param {Object} knex - Knex instance
  * @param {string} tableName - Target table name
  * @param {string} foreignKey - Foreign key field
  * @param {Array} parentIds - Parent record IDs
- * @param {Array} fieldsToSelect - Fields to select
- * @param {Object} includeConfig - Include configuration (limit, orderBy)
+ * @param {Array|string} fieldsToSelect - Fields to select, or '*'
+ * @param {Object} includeConfig - Include limit and ordering
  * @param {Object} capabilities - Database capabilities
- * @param {Object} scopeVars - Scope variables for defaults and limits
- * @returns {Object} Knex query
- *
- * @example
- * // Input: Load max 3 comments per article, ordered by newest first
- * const query = buildWindowedIncludeQuery(
- *   knex,
- *   'comments',
- *   'article_id',
- *   [1, 2, 3],  // Article IDs
- *   ['id', 'text', 'created_at'],
- *   { limit: 3, orderBy: ['-created_at'] },
- *   { windowFunctions: true },
- *   { queryDefaultLimit: 10 }
- * );
- *
- * // Generated SQL:
- * // WITH _windowed AS (
- * //   SELECT id, text, created_at, article_id,
- * //          ROW_NUMBER() OVER (
- * //            PARTITION BY article_id
- * //            ORDER BY created_at DESC
- * //          ) as __$jsonrestapi_rn$__
- * //   FROM comments
- * //   WHERE article_id IN (1, 2, 3)
- * // )
- * // SELECT * FROM _windowed
- * // WHERE __$jsonrestapi_rn$__ <= 3
- *
- * // Result: Each article gets max 3 comments, not 3 total
- *
- * @example
- * // Input: Database doesn't support window functions
- * const query = buildWindowedIncludeQuery(
- *   knex,
- *   'comments',
- *   'article_id',
- *   [1, 2, 3],
- *   '*',
- *   { limit: 5 },
- *   { windowFunctions: false, dbInfo: { client: 'mysql', version: '5.7' } }
- * );
- *
- * // Throws RestApiResourceError:
- * // "Include limits require window function support. Your database (mysql 5.7)
- * //  does not support this feature. Window functions are supported in:
- * //  PostgreSQL 8.4+, MySQL 8.0+, MariaDB 10.2+, SQLite 3.25+, SQL Server 2005+"
- *
- * @description
- * Used by:
- * - loadHasMany when strategy: 'window' and database supports window functions
- * - Enables per-parent limits for one-to-many relationships
- *
- * Purpose:
- * - Solves the "N+1 limit" problem where you want X records per parent
- * - Without window functions, LIMIT 10 gives 10 total across all parents
- * - With window functions, each parent gets up to 10 related records
- * - Critical for consistent API responses with includes
- *
- * Data flow:
- * 1. Creates subquery with ROW_NUMBER() partitioned by foreign key
- * 2. Numbers rows within each partition based on orderBy
- * 3. Outer query filters to keep only rows within limit
- * 4. Returns query ready for execution
- * 5. Caller removes the ROW_NUMBER column from results
+ * @param {Object} scopeVars - Resource query limits
+ * @returns {{ subquery: Object, effectiveLimit: number }} Inner query and validated limit
  */
-export const buildWindowedIncludeQuery = (
+export const buildWindowedIncludeSubquery = (
   knex,
   tableName,
   foreignKey,
@@ -137,13 +76,7 @@ export const buildWindowedIncludeQuery = (
     subquery.select(fieldsWithFK)
   }
 
-  // Wrap in outer query to filter by row number
-  const query = knex
-    .select('*')
-    .from(subquery.as('_windowed'))
-    .where(ROW_NUMBER_KEY, '<=', effectiveLimit)
-
-  return query
+  return { subquery, effectiveLimit }
 }
 
 /**
@@ -175,7 +108,7 @@ export const buildWindowedIncludeQuery = (
  *
  * @description
  * Used by:
- * - buildWindowedIncludeQuery for PARTITION BY ordering
+ * - buildWindowedIncludeSubquery for PARTITION BY ordering
  * - applyStandardIncludeConfig for regular ORDER BY
  * - Query builders that need consistent sort syntax
  *

package/plugins/core/lib/querying/url-helpers.js

@@ -11,13 +11,12 @@
  * Priority order:
  * 1. context.urlPrefixOverride - Explicit override (from hooks or middleware)
  * 2. context.urlPrefix - Pre-calculated URL prefix
- * 3. Calculate from request if provided
- * 4. scope.vars.transport?.mountPath - Fallback to mount path
+ * 3. scope.vars.transport?.publicBaseUrl - Explicit public URL prefix
+ * 4. scope.vars.transport?.mountPath - Fallback to relative mount path
  * 5. '' - Empty string as final fallback
  *
  * @param {Object} context - Request context (may have urlPrefixOverride or urlPrefix)
  * @param {Object} scope - Scope/resource object with transport vars
- * @param {Object} req - Optional Express request object for auto-calculation
  * @returns {string} The final URL prefix to use
  *
  * @example
@@ -25,10 +24,10 @@
  * const urlPrefix = getUrlPrefix(context, scope);
  *
  * @example
- * // With request object for auto-calculation
- * const urlPrefix = getUrlPrefix({}, api, req);
+ * // With explicit public base URL
+ * const urlPrefix = getUrlPrefix({}, { vars: { transport: { publicBaseUrl: 'https://api.example.com/api' } } });
  */
-export function getUrlPrefix (context, scope, req = null) {
+export function getUrlPrefix (context, scope) {
   // Priority 1: Explicit override
   if (context?.urlPrefixOverride) {
     return context.urlPrefixOverride
@@ -39,21 +38,10 @@ export function getUrlPrefix (context, scope, req = null) {
     return context.urlPrefix
   }
 
-  // Priority 3: Calculate from request if provided
-  if (req) {
-    const protocol = req.get?.('x-forwarded-proto') ||
-      req.headers?.['x-forwarded-proto'] ||
-      req.protocol ||
-      'http'
-    const host = req.get?.('x-forwarded-host') ||
-      req.headers?.['x-forwarded-host'] ||
-      req.get?.('host') ||
-      req.headers?.host
-    const mountPath = scope?.vars?.transport?.mountPath || ''
-
-    if (host) {
-      return `${protocol}://${host}${mountPath}`
-    }
+  // Priority 3: Explicit public URL prefix configured by the transport
+  const publicBaseUrl = scope?.vars?.transport?.publicBaseUrl
+  if (publicBaseUrl) {
+    return String(publicBaseUrl).replace(/\/+$/, '')
   }
 
   // Priority 4: Fallback to mount path

package/plugins/core/lib/querying-writing/compile-schemas.js

@@ -1,6 +1,6 @@
 import { createSchema } from 'json-rest-schema'
 import { ensureSearchFieldsAreIndexed, generateSearchSchemaFromSchema, sortFieldsByDependencies } from './schema-helpers.js'
-import { buildStorageInfo } from '../storage/storage-mapping.js'
+import { buildStorageInfo, normalizeStorageConfig } from '../storage/storage-mapping.js'
 
 /**
  * Compiles and enriches schemas for a resource scope
@@ -155,7 +155,7 @@ export async function compileSchemas (scope, deps) {
   }
 
   // Default enrichment: Add type to belongsTo fields
-  for (const [fieldName, fieldDef] of Object.entries(enrichedFields)) {
+  for (const [, fieldDef] of Object.entries(enrichedFields)) {
     if (fieldDef.belongsTo && !fieldDef.type) {
       fieldDef.type = 'id'
     }
@@ -174,7 +174,7 @@ export async function compileSchemas (scope, deps) {
 
   if (isProbablyPivot) {
     // Make all belongsTo fields searchable for pivot operations
-    for (const [fieldName, fieldDef] of belongsToFields) {
+    for (const [, fieldDef] of belongsToFields) {
       if (!fieldDef.search) {
         fieldDef.search = true
       }
@@ -206,6 +206,7 @@ export async function compileSchemas (scope, deps) {
     scope.scopeOptions.searchSchema
   )
 
+  let searchSchemaObject
   if (rawSearchFields) {
     // Mark all search fields as indexed for database optimization.
     // This ensures that any field used for filtering will have a database index created,
@@ -224,9 +225,9 @@ export async function compileSchemas (scope, deps) {
     await runHooks('searchSchema:enrich', searchSchemaContext)
 
     // Create searchSchema object
-    var searchSchemaObject = createSchema(rawSearchFields)
+    searchSchemaObject = createSchema(rawSearchFields)
   } else {
-    var searchSchemaObject = createSchema({})
+    searchSchemaObject = createSchema({})
   }
 
   // Build schemaRelationships including polymorphic fields from schema
@@ -317,9 +318,11 @@ export async function compileSchemas (scope, deps) {
   }
 
   const idProperty = scope.scopeOptions.idProperty || scope.vars.idProperty || 'id'
+  const storage = normalizeStorageConfig(scope.scopeOptions.storage)
   const storageInfo = buildStorageInfo({
     schemaStructure: schemaObject.structure,
-    idProperty
+    idProperty,
+    storage
   })
 
   // Cache everything
@@ -335,6 +338,7 @@ export async function compileSchemas (scope, deps) {
     schemaRelationships,
     tableName: scope.scopeOptions.tableName || scopeName,
     idProperty,
+    storage,
     storageInfo,
     indexes: Array.isArray(scope.scopeOptions.indexes) ? [...scope.scopeOptions.indexes] : [],
     foreignKeys: Array.isArray(scope.scopeOptions.foreignKeys) ? [...scope.scopeOptions.foreignKeys] : [],

package/plugins/core/lib/querying-writing/connectors-query-parser.js

@@ -163,3 +163,54 @@ export function parseJsonApiQuery (queryString) {
 
   return result
 }
+
+const hasSerializableValue = (value) => (
+  value !== undefined &&
+  value !== null &&
+  !(Array.isArray(value) && value.length === 0)
+)
+
+const stringifyQueryValue = (value) => {
+  if (value instanceof Date) return value.toISOString()
+  if (Array.isArray(value)) return value.map(stringifyQueryValue).join(',')
+  return String(value)
+}
+
+const appendCommaList = (params, key, value) => {
+  if (!hasSerializableValue(value)) return
+  const serialized = Array.isArray(value)
+    ? value.map(stringifyQueryValue).filter((entry) => entry.length > 0).join(',')
+    : stringifyQueryValue(value)
+
+  if (serialized) {
+    params.set(key, serialized)
+  }
+}
+
+const appendScopedParams = (params, publicName, values) => {
+  if (!values || typeof values !== 'object' || Array.isArray(values)) return
+
+  for (const [key, value] of Object.entries(values)) {
+    if (!key || !hasSerializableValue(value)) continue
+    params.set(`${publicName}[${key}]`, stringifyQueryValue(value))
+  }
+}
+
+/**
+ * Serializes internal REST API query parameters to public JSON:API query string form.
+ *
+ * This is intentionally the inverse of parseJsonApiQuery for the supported transport
+ * contract: include, sort, filter[...], fields[...], and page[...].
+ */
+export function serializeJsonApiQuery (queryParams = {}, { page } = {}) {
+  const params = new URLSearchParams()
+  const effectivePage = page === undefined ? queryParams.page : page
+
+  appendCommaList(params, 'include', queryParams.include)
+  appendCommaList(params, 'sort', queryParams.sort)
+  appendScopedParams(params, 'filter', queryParams.filters || queryParams.filter)
+  appendScopedParams(params, 'fields', queryParams.fields)
+  appendScopedParams(params, 'page', effectivePage)
+
+  return params.toString()
+}

package/plugins/core/lib/querying-writing/database-capabilities.js

@@ -63,7 +63,7 @@ const parseVersion = (versionString) => {
  *
  * @description
  * Used by:
- * - buildWindowedIncludeQuery to validate before using window functions
+ * - buildWindowedIncludeSubquery to validate before using window functions
  * - rest-api-knex-plugin to determine query strategies
  *
  * Purpose:

package/plugins/core/lib/querying-writing/database-value-normalizers.js

@@ -48,7 +48,7 @@
  * 4. Handles MySQL datetime format (no T separator)
  * 5. Forces UTC interpretation to prevent timezone issues
  */
-function normalizeDateValue (value, type) {
+export function normalizeDateValue (value, type) {
   // Handle null/undefined
   if (value === null || value === undefined) {
     return null
@@ -81,25 +81,34 @@ function normalizeDateValue (value, type) {
 
   // Handle string values
   if (typeof value === 'string') {
+    const trimmed = value.trim()
+
+    if (/^-?\d+$/.test(trimmed)) {
+      const numericDate = new Date(Number(trimmed))
+      if (!isNaN(numericDate.getTime())) {
+        return numericDate
+      }
+    }
+
     // Detect MySQL datetime format: 'YYYY-MM-DD HH:MM:SS'
     // These have no T separator and no timezone indicator
     const isMySQLDateTime = type === 'dateTime' &&
-                           /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/.test(value) &&
-                           !value.includes('T') &&
-                           !value.includes('Z') &&
-                           !value.includes('+') &&
-                           !value.includes('-', 10) // Don't match date separators
+                           /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/.test(trimmed) &&
+                           !trimmed.includes('T') &&
+                           !trimmed.includes('Z') &&
+                           !trimmed.includes('+') &&
+                           !trimmed.includes('-', 10) // Don't match date separators
 
     if (isMySQLDateTime) {
       // Convert to ISO format and force UTC interpretation
       // '2024-01-15 10:30:00' becomes '2024-01-15T10:30:00Z'
-      return new Date(value.replace(' ', 'T') + 'Z')
+      return new Date(trimmed.replace(' ', 'T') + 'Z')
     }
 
     // For date-only fields, ensure parsing at UTC midnight
     // This prevents timezone shifts when parsing dates
-    if (type === 'date' && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
-      return new Date(value + 'T00:00:00Z')
+    if (type === 'date' && /^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+      return new Date(trimmed + 'T00:00:00Z')
     }
   }
 

package/plugins/core/lib/querying-writing/knex-field-helpers.js

@@ -150,7 +150,8 @@ export const buildFieldSelection = async (scope, deps) => {
   const scopeSchemaInfo = scope?.vars?.schemaInfo || {}
   const {
     schemaInstance,
-    computed: computedFields = {}
+    computed: computedFields = {},
+    idProperty = 'id'
   } = scopeSchemaInfo
   let schemaStructure = scopeSchemaInfo.schemaStructure
   const queryFields = scope?.vars?.queryFields || {}
@@ -196,6 +197,8 @@ export const buildFieldSelection = async (scope, deps) => {
     // Sparse fieldsets requested - only select specified fields
     // Example: ?fields[products]=name,price,profit_margin
     requested.forEach(field => {
+      if (field === 'id' || field === idProperty) return
+
       if (queryFieldNames.has(field)) {
         if (queryFields[field]?.hidden === true) return
         queryFieldsToSelect.add(field)
@@ -257,11 +260,12 @@ export const buildFieldSelection = async (scope, deps) => {
         }
       })
     }
-
   } else {
     // No sparse fieldsets - return all visible fields
     // This is the default behavior when no ?fields parameter is provided
     Object.entries(schemaStructure).forEach(([field, fieldDef]) => {
+      if (field === 'id' || field === idProperty) return
+
       // Skip virtual fields - they don't exist in database
       if (fieldDef.virtual === true) return
 
@@ -283,7 +287,7 @@ export const buildFieldSelection = async (scope, deps) => {
     // So we need to include their dependencies even if normallyHidden
     // Example: profit_margin depends on 'cost' which is normallyHidden
     // We fetch 'cost' for calculation but don't return it in response
-    for (const [fieldName, fieldDef] of Object.entries(computedFields)) {
+    for (const [, fieldDef] of Object.entries(computedFields)) {
       if (fieldDef.dependencies) {
         for (const dep of fieldDef.dependencies) {
           const depFieldDef = schemaStructure[dep]