json-rest-api 1.0.22 → 1.0.24

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

@@ -74,33 +74,108 @@
  * 6. Return array of unique included resources
  */
 
-import { buildFieldSelection } from '../querying-writing/knex-field-helpers.js'
-import { getForeignKeyFields } from '../querying-writing/field-utils.js'
+import { applyFieldSelectionToQuery, buildFieldSelection } from '../querying-writing/knex-field-helpers.js'
 import { toJsonApiRecord } from './knex-json-api-transformers-querying.js'
 import { buildWindowedIncludeQuery, 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'
+import {
+  getFieldValue as getStorageFieldValue,
+  getIdColumn as getStorageIdColumn,
+  getStorageColumn as getMappedStorageColumn,
+} from '../storage/storage-mapping.js'
+
+const getScopeStorageAdapter = (scopes, scopeName) => scopes[scopeName]?.vars?.storageAdapter || null
+
+const getIdColumnForScope = (scopes, scopeName) => {
+  const adapter = getScopeStorageAdapter(scopes, scopeName)
+  if (adapter?.getIdColumn) {
+    return adapter.getIdColumn()
+  }
 
-const translateSelectFieldsForAdapter = (fields, adapter) => {
-  if (!adapter || !fields) return fields
+  return getStorageIdColumn(scopes[scopeName]?.vars?.schemaInfo || {})
+}
 
-  const translateField = (field) => {
-    if (typeof field !== 'string') return field
+const getFieldValueForScope = (scopes, scopeName, record, fieldName) => {
+  const adapter = getScopeStorageAdapter(scopes, scopeName)
+  if (adapter?.getFieldValue) {
+    return adapter.getFieldValue(record, fieldName)
+  }
 
-    if (field === '*') return '*'
+  return getStorageFieldValue(record, scopes[scopeName]?.vars?.schemaInfo || {}, fieldName)
+}
 
-    const aliasMatch = field.match(/\s+as\s+/i)
-    if (aliasMatch) {
-      const [source, alias] = field.split(/\s+as\s+/i)
-      const translatedSource = adapter.translateColumn(source.trim()) || source.trim()
-      return `${translatedSource} as ${alias.trim()}`
-    }
+const translateColumnForScope = (scopes, scopeName, fieldName) => {
+  const adapter = getScopeStorageAdapter(scopes, scopeName)
+  if (adapter?.translateColumn) {
+    return adapter.translateColumn(fieldName)
+  }
+
+  return getMappedStorageColumn(scopes[scopeName]?.vars?.schemaInfo || {}, fieldName)
+}
+
+const buildRelationshipLinks = (scopes, scopeName, record, relationshipName) => {
+  const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
+  const recordId = getFieldValueForScope(scopes, scopeName, record, 'id')
+
+  return {
+    self: `${urlPrefix}/${scopeName}/${recordId}/relationships/${relationshipName}`,
+    related: `${urlPrefix}/${scopeName}/${recordId}/${relationshipName}`
+  }
+}
 
-    const translated = adapter.translateColumn(field)
-    return translated || field
+const buildScopedIncludeContext = ({ requestContext, scopeName, scopeObject, storageAdapter }) => {
+  const queryParams = requestContext?.queryParams
+    ? { ...requestContext.queryParams }
+    : {}
+
+  if ('filters' in queryParams) {
+    delete queryParams.filters
+  }
+
+  return {
+    ...(requestContext || {}),
+    scopeName,
+    schemaInfo: scopeObject.vars.schemaInfo,
+    storageAdapter,
+    queryParams
+  }
+}
+
+const applyScopeFiltersToIncludeQuery = async ({
+  query,
+  scopes,
+  scopeName,
+  requestContext,
+  db,
+  tableName
+}) => {
+  const scopeObject = scopes[scopeName]
+  if (!scopeObject?.applyQueryFilters) {
+    return { query }
   }
 
-  return fields.map(translateField)
+  const storageAdapter = scopeObject.vars.storageAdapter
+
+  const queryState = await scopeObject.applyQueryFilters({
+    query,
+    filters: undefined,
+    scopeName,
+    tableName: tableName || scopeObject.vars.schemaInfo.tableName,
+    db,
+    schemaInfo: scopeObject.vars.schemaInfo,
+    storageAdapter
+  }, buildScopedIncludeContext({
+    requestContext,
+    scopeName,
+    scopeObject,
+    storageAdapter
+  }))
+
+  return {
+    query: unwrapQueryBuilderState(queryState, query)
+  }
 }
 
 /**
@@ -162,12 +237,12 @@ const translateSelectFieldsForAdapter = (fields, adapter) => {
  * 3. Collects unique IDs for each type
  * 4. Returns map used for batch WHERE IN queries
  */
-export const groupByPolymorphicType = (records, typeField, idField) => {
+export const groupByPolymorphicType = (records, typeField, idField, getFieldValue = (record, fieldName) => record[fieldName]) => {
   const grouped = {}
 
   records.forEach(record => {
-    const type = record[typeField]
-    const id = record[idField]
+    const type = getFieldValue(record, typeField)
+    const id = getFieldValue(record, idField)
 
     // Skip if either type or id is missing
     if (!type || !id) return
@@ -295,7 +370,7 @@ const loadRelationshipMetadata = async (scopes, records, scopeName) => {
       // Process belongsTo relationships from schema
       for (const [fieldName, fieldDef] of Object.entries(schema)) {
         if (fieldDef.belongsTo && fieldDef.as) {
-          const foreignKeyValue = record[fieldName]
+          const foreignKeyValue = getFieldValueForScope(scopes, scopeName, record, fieldName)
           if (foreignKeyValue != null) {
             record[RELATIONSHIP_METADATA_KEY][fieldDef.as] = {
               data: {
@@ -320,8 +395,8 @@ const loadRelationshipMetadata = async (scopes, records, scopeName) => {
         } else if (relDef.belongsToPolymorphic) {
           // Process polymorphic relationships defined in relationships section
           const { typeField, idField } = relDef.belongsToPolymorphic
-          const type = record[typeField]
-          const id = record[idField]
+          const type = getFieldValueForScope(scopes, scopeName, record, typeField)
+          const id = getFieldValueForScope(scopes, scopeName, record, idField)
 
           if (type && id) {
             record[RELATIONSHIP_METADATA_KEY][relName] = {
@@ -361,7 +436,6 @@ const loadRelationshipMetadata = async (scopes, records, scopeName) => {
  *   - processedPaths: Set - Set of already processed paths
  *   - currentPath: string - Current include path for tracking
  *   - fields: Object - Sparse fieldsets configuration
- *   - idProperty: string - The ID property name
  * @param {Object} deps - Dependencies object containing:
  *   - context.scopes: Object - The hooked-api scopes object
  *   - context.log: Object - Logger instance
@@ -369,8 +443,8 @@ const loadRelationshipMetadata = async (scopes, records, scopeName) => {
  * @returns {Promise<void>}
  */
 export const loadBelongsTo = async (scope, deps) => {
-  const { records, scopeName, fieldName, fieldDef, includeName, subIncludes, included, processedPaths, currentPath, fields, idProperty } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { records, scopeName, fieldName, fieldDef, includeName, subIncludes, included, processedPaths, currentPath, fields } = scope
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Loading belongsTo:', {
       fieldName,
@@ -387,7 +461,7 @@ export const loadBelongsTo = async (scope, deps) => {
 
     // Collect all foreign key values
     const foreignKeyValues = records
-      .map(r => r[fieldName])
+      .map(record => getFieldValueForScope(scopes, scopeName, record, fieldName))
       .filter(val => val != null) // Filter out null/undefined
 
     const uniqueIds = [...new Set(foreignKeyValues)]
@@ -404,12 +478,8 @@ export const loadBelongsTo = async (scope, deps) => {
         const relationshipObject = { data: null }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record[idProperty]}/relationships/${includeName}`,
-            related: `${urlPrefix}/${scopeName}/${record[idProperty]}/${includeName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
         }
 
         record[RELATIONSHIPS_KEY][includeName] = relationshipObject
@@ -419,15 +489,14 @@ export const loadBelongsTo = async (scope, deps) => {
 
     // Get target table info
     const targetTableName = scopes[targetScope].vars.schemaInfo.tableName
-    const targetIdProperty = scopes[targetScope].vars.schemaInfo.idProperty
-    const targetSchema = scopes[targetScope].vars.schemaInfo.schemaInstance
-
+    const targetIdColumn = getIdColumnForScope(scopes, targetScope)
     // Build field selection for sparse fieldsets
     const targetScopeObject = scopes[targetScope]
     const storageAdapter = targetScopeObject.vars.storageAdapter
     const fieldSelectionInfo = fields?.[targetScope]
       ? await buildFieldSelection(targetScopeObject, {
         context: {
+          ...(requestContext || {}),
           scopeName: targetScope,
           queryParams: { fields: { [targetScope]: fields[targetScope] } },
           schemaInfo: targetScopeObject.vars.schemaInfo,
@@ -437,14 +506,38 @@ export const loadBelongsTo = async (scope, deps) => {
       : null
 
     // Load the target records
-    let query = knex(targetTableName).whereIn(targetIdProperty, uniqueIds)
+    let query = knex(targetTableName).whereIn(targetIdColumn, uniqueIds)
     if (fieldSelectionInfo) {
-      const selectFields = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-      query = query.select(selectFields)
-    } else if (targetIdProperty !== 'id') {
-      // If no field selection but custom idProperty, we need to alias it
-      query = query.select('*', `${targetIdProperty} as id`)
+      const selectionState = await applyFieldSelectionToQuery({
+        query,
+        scope: targetScopeObject,
+        fieldSelectionInfo,
+        tableName: targetTableName,
+        useTablePrefix: false,
+        storageAdapter,
+        db: knex,
+        context: {
+          ...(requestContext || {}),
+          scopeName: targetScope,
+          schemaInfo: targetScopeObject.vars.schemaInfo,
+          storageAdapter,
+        },
+        scopeName: targetScope
+      })
+      query = selectionState.query
+    } else if (targetIdColumn !== 'id') {
+      // If no field selection but the storage ID column is not `id`, alias it for response shaping.
+      query = query.select('*', `${targetIdColumn} as id`)
     }
+    const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+      query,
+      scopes,
+      scopeName: targetScope,
+      requestContext,
+      db: knex,
+      tableName: targetTableName
+    })
+    query = scopedQueryState.query
     const targetRecords = await query
 
     // Load relationship metadata for all target records
@@ -453,7 +546,7 @@ export const loadBelongsTo = async (scope, deps) => {
     // Create lookup map
     const targetById = {}
     targetRecords.forEach(record => {
-      targetById[record.id || record[targetIdProperty]] = record
+      targetById[getFieldValueForScope(scopes, targetScope, record, 'id')] = record
     })
 
     // Set relationships on original records
@@ -462,7 +555,7 @@ export const loadBelongsTo = async (scope, deps) => {
     records.forEach(record => {
       if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
 
-      const targetId = record[fieldName]
+      const targetId = getFieldValueForScope(scopes, scopeName, record, fieldName)
       const targetRecord = targetById[targetId]
 
       if (targetRecord) {
@@ -488,12 +581,8 @@ export const loadBelongsTo = async (scope, deps) => {
         const relationshipObject = { data: { type: targetScope, id: String(targetId) } }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record[idProperty]}/relationships/${includeName}`,
-            related: `${urlPrefix}/${scopeName}/${record[idProperty]}/${includeName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
         }
 
         record[RELATIONSHIPS_KEY][includeName] = relationshipObject
@@ -512,12 +601,8 @@ export const loadBelongsTo = async (scope, deps) => {
         const relationshipObject = { data: null }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record[idProperty]}/relationships/${includeName}`,
-            related: `${urlPrefix}/${scopeName}/${record[idProperty]}/${includeName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
         }
 
         record[RELATIONSHIPS_KEY][includeName] = relationshipObject
@@ -529,8 +614,8 @@ export const loadBelongsTo = async (scope, deps) => {
       const nextPath = `${currentPath}.${includeName}`
       if (!processedPaths.has(nextPath)) {
         await processIncludes(
-          { records: targetRecordsToProcess, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields, idProperty: targetIdProperty },
-          { context: { scopes, log, knex, capabilities } }
+          { records: targetRecordsToProcess, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields },
+          { context: { scopes, log, knex, capabilities, requestContext } }
         )
       }
     }
@@ -580,7 +665,7 @@ export const loadBelongsTo = async (scope, deps) => {
  */
 export const loadHasMany = async (scope, deps) => {
   const { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Loading hasMany/manyToMany relationship:', {
       scopeName,
@@ -592,7 +677,7 @@ export const loadHasMany = async (scope, deps) => {
     })
 
     // Collect all parent IDs
-    const mainIds = records.map(r => r.id).filter(Boolean)
+    const mainIds = records.map(record => getFieldValueForScope(scopes, scopeName, record, 'id')).filter(Boolean)
 
     if (mainIds.length === 0) {
       log.trace('[INCLUDE] No parent IDs found, skipping hasMany load')
@@ -607,7 +692,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
@@ -631,12 +716,8 @@ export const loadHasMany = async (scope, deps) => {
           const relationshipObject = { data: [] }
 
           // Add links if urlPrefix is configured
-          const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
           if (scopeName) {
-            relationshipObject.links = {
-              self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${includeName}`,
-              related: `${urlPrefix}/${scopeName}/${record.id}/${includeName}`
-            }
+            relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
           }
 
           record[RELATIONSHIPS_KEY][includeName] = relationshipObject
@@ -653,13 +734,13 @@ 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 targetIdProperty = targetScopeObject.vars.schemaInfo.idProperty
+      const targetIdColumn = getIdColumnForScope(scopes, targetScope)
       const fieldSelectionInfo = fields?.[targetScope]
         ? await buildFieldSelection(targetScopeObject, {
           context: {
+            ...(requestContext || {}),
             scopeName: targetScope,
             queryParams: { fields: { [targetScope]: fields[targetScope] } },
             schemaInfo: targetScopeObject.vars.schemaInfo,
@@ -671,7 +752,7 @@ export const loadHasMany = async (scope, deps) => {
       // Step 4: For many-to-many with limits, we need a different approach
       let targetRecords
 
-      if (relDef.include?.strategy === 'window') {
+      if (relDef.include?.strategy === 'window' && !fieldSelectionInfo?.queryFieldsToSelect?.length) {
       // For many-to-many with window functions, we need to limit per parent
       // This requires joining back through the pivot table
 
@@ -690,27 +771,36 @@ export const loadHasMany = async (scope, deps) => {
           })
         }
 
-        const targetIdProperty = scopes[targetScope]?.vars?.schemaInfo?.idProperty || 'id'
-        const windowQuery = knex
+        let windowQuery = knex
           .select(`${targetTable}.*`)
 
         // Add id alias if needed
-        if (targetIdProperty !== 'id') {
-          windowQuery.select(`${targetTable}.${targetIdProperty} as id`)
+        if (targetIdColumn !== 'id') {
+          windowQuery.select(`${targetTable}.${targetIdColumn} as id`)
         }
 
         windowQuery.select(
           knex.raw(
             'ROW_NUMBER() OVER (PARTITION BY pivot.?? ORDER BY ' +
-            buildOrderByClause(relDef.include?.orderBy || [targetIdProperty], targetTable) +
+            buildOrderByClause(relDef.include?.orderBy || [targetIdColumn], targetTable) +
             ') as ' + ROW_NUMBER_KEY,
             [foreignKey]
           )
         )
           .from(targetTable)
-          .join(`${pivotTable} as pivot`, `${targetTable}.${targetIdProperty}`, 'pivot.' + otherKey)
+          .join(`${pivotTable} as pivot`, `${targetTable}.${targetIdColumn}`, 'pivot.' + otherKey)
           .whereIn(`pivot.${foreignKey}`, mainIds)
 
+        const scopedWindowQueryState = await applyScopeFiltersToIncludeQuery({
+          query: windowQuery,
+          scopes,
+          scopeName: targetScope,
+          requestContext,
+          db: knex,
+          tableName: targetTable
+        })
+        windowQuery = scopedWindowQueryState.query
+
         // Wrap to filter by row number
         const limitedQuery = knex
           .select('*')
@@ -723,17 +813,41 @@ export const loadHasMany = async (scope, deps) => {
         targetRecords.forEach(record => delete record[ROW_NUMBER_KEY])
       } else {
       // Standard query without per-parent limits
-        const targetIdProperty = scopes[targetScope]?.vars?.schemaInfo?.idProperty || 'id'
-        let query = knex(targetTable).whereIn(targetIdProperty, targetIds)
+        let query = knex(targetTable).whereIn(targetIdColumn, targetIds)
 
         if (fieldSelectionInfo) {
-          const selectFields = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-          query = query.select(selectFields)
-        } else if (targetIdProperty !== 'id') {
-        // If no field selection but custom idProperty, we need to alias it
-          query = query.select('*', `${targetIdProperty} as id`)
+          const selectionState = await applyFieldSelectionToQuery({
+            query,
+            scope: targetScopeObject,
+            fieldSelectionInfo,
+            tableName: targetTable,
+            useTablePrefix: false,
+            storageAdapter,
+            db: knex,
+            context: {
+              ...(requestContext || {}),
+              scopeName: targetScope,
+              schemaInfo: targetScopeObject.vars.schemaInfo,
+              storageAdapter,
+            },
+            scopeName: targetScope
+          })
+          query = selectionState.query
+        } else if (targetIdColumn !== 'id') {
+        // If no field selection but the storage ID column is not `id`, alias it for response shaping.
+          query = query.select('*', `${targetIdColumn} as id`)
         }
 
+        const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+          query,
+          scopes,
+          scopeName: targetScope,
+          requestContext,
+          db: knex,
+          tableName: targetTable
+        })
+        query = scopedQueryState.query
+
         // Apply standard include config (global limits)
         if (relDef.include) {
           const targetVars = scopes[targetScope].vars
@@ -751,7 +865,7 @@ export const loadHasMany = async (scope, deps) => {
       // Step 6: Create lookup map for target records
       const targetById = {}
       targetRecords.forEach(record => {
-        targetById[record.id] = record
+        targetById[getFieldValueForScope(scopes, targetScope, record, 'id')] = record
       })
 
       // Step 7: Group pivot records by parent ID
@@ -769,14 +883,16 @@ export const loadHasMany = async (scope, deps) => {
       records.forEach(record => {
         if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
 
-        const childIds = pivotsByParent[record.id] || []
+        const recordId = getFieldValueForScope(scopes, scopeName, record, 'id')
+        const childIds = pivotsByParent[recordId] || []
 
         const relData = childIds
           .map(childId => targetById[childId])
           .filter(Boolean)
           .map(childRecord => {
           // Add to included
-            const resourceKey = `${targetScope}:${childRecord.id}`
+            const childRecordId = getFieldValueForScope(scopes, targetScope, childRecord, 'id')
+            const resourceKey = `${targetScope}:${childRecordId}`
             if (!included.has(resourceKey)) {
               const jsonApiRecord = toJsonApiRecord(
                 scopes[targetScope],
@@ -798,24 +914,20 @@ export const loadHasMany = async (scope, deps) => {
 
               included.set(resourceKey, jsonApiRecord)
             }
-            return { type: targetScope, id: String(childRecord.id) }
+            return { type: targetScope, id: String(childRecordId) }
           })
 
         const relationshipObject = { data: relData }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${includeName}`,
-            related: `${urlPrefix}/${scopeName}/${record.id}/${includeName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
         }
 
         record[RELATIONSHIPS_KEY][includeName] = relationshipObject
 
         // Update the record in the included Map if it exists
-        const recordKey = `${scopeName}:${record.id}`
+        const recordKey = `${scopeName}:${recordId}`
         if (included.has(recordKey)) {
           const existingRecord = included.get(recordKey)
           if (!existingRecord.relationships) {
@@ -830,8 +942,8 @@ export const loadHasMany = async (scope, deps) => {
         const nextPath = `${currentPath}.${includeName}`
         if (!processedPaths.has(nextPath)) {
           await processIncludes(
-            { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields, idProperty: targetIdProperty },
-            { context: { scopes, log, knex, capabilities } }
+            { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields },
+            { context: { scopes, log, knex, capabilities, requestContext } }
           )
         }
       }
@@ -842,7 +954,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}:`, {
@@ -851,10 +963,8 @@ 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 targetIdProperty = targetScopeObject.vars.schemaInfo.idProperty
       const fieldSelectionInfo = fields?.[targetScope]
         ? await buildFieldSelection(targetScopeObject, {
           context: {
@@ -873,9 +983,11 @@ export const loadHasMany = async (scope, deps) => {
       if (relDef.include?.strategy === 'window') {
         try {
         // Try to build window function query
-          const selectFields = fieldSelectionInfo
-            ? translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-            : null
+          if (fieldSelectionInfo?.queryFieldsToSelect?.length) {
+            throw new Error('Query projection fields require the standard include query path.')
+          }
+
+          const selectFields = fieldSelectionInfo?.fieldsToSelect || null
 
           query = buildWindowedIncludeQuery(
             knex,
@@ -887,6 +999,15 @@ export const loadHasMany = async (scope, deps) => {
             capabilities,
             targetScopeObject.vars  // Pass target scope vars
           )
+          const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+            query,
+            scopes,
+            scopeName: targetScope,
+            requestContext,
+            db: knex,
+            tableName: targetTable
+          })
+          query = scopedQueryState.query
           usingWindowFunction = true
           log.debug('[INCLUDE] Using window function strategy with limits')
         } catch (error) {
@@ -905,13 +1026,39 @@ export const loadHasMany = async (scope, deps) => {
 
       // Build standard query if not using window functions
       if (!usingWindowFunction) {
-        query = knex(targetTable).whereIn(foreignKey, mainIds)
+        const foreignKeyColumn = translateColumnForScope(scopes, targetScope, foreignKey)
+        query = knex(targetTable).whereIn(foreignKeyColumn, mainIds)
 
         if (fieldSelectionInfo) {
-          const selectFieldsStd = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-          query = query.select(selectFieldsStd)
+          const selectionState = await applyFieldSelectionToQuery({
+            query,
+            scope: targetScopeObject,
+            fieldSelectionInfo,
+            tableName: targetTable,
+            useTablePrefix: false,
+            storageAdapter,
+            db: knex,
+            context: {
+              ...(requestContext || {}),
+              scopeName: targetScope,
+              schemaInfo: targetScopeObject.vars.schemaInfo,
+              storageAdapter,
+            },
+            scopeName: targetScope
+          })
+          query = selectionState.query
         }
 
+        const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+          query,
+          scopes,
+          scopeName: targetScope,
+          requestContext,
+          db: knex,
+          tableName: targetTable
+        })
+        query = scopedQueryState.query
+
         // Apply standard config with defaults
         const targetVars = scopes[targetScope].vars
         query = applyStandardIncludeConfig(
@@ -941,7 +1088,7 @@ export const loadHasMany = async (scope, deps) => {
       // Group by parent ID
       const childrenByParent = {}
       targetRecords.forEach(record => {
-        const parentId = record[foreignKey]
+        const parentId = getFieldValueForScope(scopes, targetScope, record, foreignKey)
         if (!childrenByParent[parentId]) {
           childrenByParent[parentId] = []
         }
@@ -952,10 +1099,12 @@ export const loadHasMany = async (scope, deps) => {
       records.forEach(record => {
         if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
 
-        const children = childrenByParent[record.id] || []
+        const recordId = getFieldValueForScope(scopes, scopeName, record, 'id')
+        const children = childrenByParent[recordId] || []
         const relData = children.map(childRecord => {
         // Add to included
-          const resourceKey = `${targetScope}:${childRecord.id}`
+          const childRecordId = getFieldValueForScope(scopes, targetScope, childRecord, 'id')
+          const resourceKey = `${targetScope}:${childRecordId}`
           if (!included.has(resourceKey)) {
             const jsonApiRecord = toJsonApiRecord(
               scopes[targetScope],
@@ -977,24 +1126,20 @@ export const loadHasMany = async (scope, deps) => {
 
             included.set(resourceKey, jsonApiRecord)
           }
-          return { type: targetScope, id: String(childRecord.id) }
+          return { type: targetScope, id: String(childRecordId) }
         })
 
         const relationshipObject = { data: relData }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${includeName}`,
-            related: `${urlPrefix}/${scopeName}/${record.id}/${includeName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
         }
 
         record[RELATIONSHIPS_KEY][includeName] = relationshipObject
 
         // Update the record in the included Map if it exists
-        const recordKey = `${scopeName}:${record.id}`
+        const recordKey = `${scopeName}:${recordId}`
         if (included.has(recordKey)) {
           const existingRecord = included.get(recordKey)
           if (!existingRecord.relationships) {
@@ -1009,8 +1154,8 @@ export const loadHasMany = async (scope, deps) => {
         const nextPath = `${currentPath}.${includeName}`
         if (!processedPaths.has(nextPath)) {
           await processIncludes(
-            { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields, idProperty: targetIdProperty },
-            { context: { scopes, log, knex, capabilities } }
+            { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields },
+            { context: { scopes, log, knex, capabilities, requestContext } }
           )
         }
       }
@@ -1047,21 +1192,20 @@ export const loadHasMany = async (scope, deps) => {
  */
 export const loadHasOne = async (scope, deps) => {
   const { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields } = scope
-  const { context: { scopes, log, knex, capabilities } } = deps
+  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
   }
 
   // Get parent IDs
-  const idProperty = scopes[scopeName]?.vars?.schemaInfo?.idProperty || 'id'
-  const mainIds = [...new Set(records.map(r => r[idProperty]).filter(Boolean))]
+  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
   }
 
@@ -1073,20 +1217,19 @@ 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
-  const targetIdProperty = targetScopeObject.vars.schemaInfo.idProperty
 
   // Build field selection for sparse fieldsets
   const fieldSelectionInfo = fields?.[targetScope]
     ? await buildFieldSelection(targetScopeObject, {
       context: {
+        ...(requestContext || {}),
         scopeName: targetScope,
         queryParams: { fields: { [targetScope]: fields[targetScope] } },
         schemaInfo: targetScopeObject.vars.schemaInfo,
@@ -1096,19 +1239,45 @@ export const loadHasOne = async (scope, deps) => {
     : null
 
   // Query related records
-  let query = knex(targetTable).whereIn(foreignKey, mainIds)
+  const foreignKeyColumn = translateColumnForScope(scopes, targetScope, foreignKey)
+  let query = knex(targetTable).whereIn(foreignKeyColumn, mainIds)
 
-  if (fieldSelectionInfo?.fieldsToSelect) {
-    const selectFields = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-    query = query.select(selectFields)
+  if (fieldSelectionInfo) {
+    const selectionState = await applyFieldSelectionToQuery({
+      query,
+      scope: targetScopeObject,
+      fieldSelectionInfo,
+      tableName: targetTable,
+      useTablePrefix: false,
+      storageAdapter,
+      db: knex,
+      context: {
+        ...(requestContext || {}),
+        scopeName: targetScope,
+        schemaInfo: targetScopeObject.vars.schemaInfo,
+        storageAdapter,
+      },
+      scopeName: targetScope
+    })
+    query = selectionState.query
   }
 
+  const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+    query,
+    scopes,
+    scopeName: targetScope,
+    requestContext,
+    db: knex,
+    tableName: targetTable
+  })
+  query = scopedQueryState.query
+
   const relatedRecords = await query
 
   // Create a map of parent ID to related record (should be one-to-one)
   const relatedByParentId = {}
   for (const related of relatedRecords) {
-    const parentId = related[foreignKey]
+    const parentId = getFieldValueForScope(scopes, targetScope, related, foreignKey)
     if (relatedByParentId[parentId]) {
       log.warn(`[INCLUDE] Multiple records found for hasOne relationship '${includeName}' with ${foreignKey}=${parentId}`)
     }
@@ -1117,7 +1286,7 @@ export const loadHasOne = async (scope, deps) => {
 
   // Process each parent record
   for (const record of records) {
-    const recordId = record[idProperty]
+    const recordId = getFieldValueForScope(scopes, scopeName, record, 'id')
     const relatedRecord = relatedByParentId[recordId]
 
     if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
@@ -1136,12 +1305,13 @@ export const loadHasOne = async (scope, deps) => {
       )
 
       // Set single object (not array) for hasOne
+      const relatedRecordId = getFieldValueForScope(scopes, targetScope, relatedRecord, 'id')
       record[RELATIONSHIPS_KEY][includeName] = {
-        data: { type: targetScope, id: String(relatedRecord[targetIdProperty]) }
+        data: { type: targetScope, id: String(relatedRecordId) }
       }
 
       // Add to included if not already there
-      const key = `${targetScope}:${relatedRecord[targetIdProperty]}`
+      const key = `${targetScope}:${relatedRecordId}`
       if (!included.has(key)) {
         included.set(key, transformed)
       }
@@ -1153,7 +1323,7 @@ export const loadHasOne = async (scope, deps) => {
           processedPaths.add(newPath)
           await processIncludes(
             { records: [relatedRecord], scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: newPath, fields },
-            { context: { scopes, log, knex, capabilities } }
+            { context: { scopes, log, knex, capabilities, requestContext } }
           )
         }
       }
@@ -1187,7 +1357,7 @@ export const loadHasOne = async (scope, deps) => {
  */
 export const loadPolymorphicBelongsTo = async (scope, deps) => {
   const { records, scopeName, relName, relDef, subIncludes, included, processedPaths, currentPath, fields } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Loading polymorphic belongsTo:', {
       relName,
@@ -1200,7 +1370,8 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
     const grouped = groupByPolymorphicType(
       records,
       typeField,
-      idField
+      idField,
+      (record, fieldName) => getFieldValueForScope(scopes, scopeName, record, fieldName)
     )
 
     log.trace('[INCLUDE] Grouped by type:', {
@@ -1224,11 +1395,11 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
 
       // Build field selection for sparse fieldsets
       const targetScopeObject = scopes[targetType]
-      // const targetIdProperty = targetScopeObject.vars.schemaInfo.idProperty;
       const storageAdapter = targetScopeObject.vars.storageAdapter
       const fieldSelectionInfo = fields?.[targetType]
         ? await buildFieldSelection(targetScopeObject, {
           context: {
+            ...(requestContext || {}),
             scopeName: targetType,
             queryParams: { fields: { [targetType]: fields[targetType] } },
             schemaInfo: targetScopeObject.vars.schemaInfo,
@@ -1243,15 +1414,39 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
       })
 
       // Query for this type
-      const targetIdProperty = scopes[targetType]?.vars?.schemaInfo?.idProperty || 'id'
-      let query = knex(targetTable).whereIn(targetIdProperty, targetIds)
+      const targetIdColumn = getIdColumnForScope(scopes, targetType)
+      let query = knex(targetTable).whereIn(targetIdColumn, targetIds)
       if (fieldSelectionInfo) {
-        const selectFields = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-        query = query.select(selectFields)
-      } else if (targetIdProperty !== 'id') {
-      // If no field selection but custom idProperty, we need to alias it
-        query = query.select('*', `${targetIdProperty} as id`)
+        const selectionState = await applyFieldSelectionToQuery({
+          query,
+          scope: targetScopeObject,
+          fieldSelectionInfo,
+          tableName: targetTable,
+          useTablePrefix: false,
+          storageAdapter,
+          db: knex,
+          context: {
+            ...(requestContext || {}),
+            scopeName: targetType,
+            schemaInfo: targetScopeObject.vars.schemaInfo,
+            storageAdapter,
+          },
+          scopeName: targetType
+        })
+        query = selectionState.query
+      } else if (targetIdColumn !== 'id') {
+      // If no field selection but the storage ID column is not `id`, alias it for response shaping.
+        query = query.select('*', `${targetIdColumn} as id`)
       }
+      const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+        query,
+        scopes,
+        scopeName: targetType,
+        requestContext,
+        db: knex,
+        tableName: targetTable
+      })
+      query = scopedQueryState.query
       const targetRecords = await query
 
       // Load relationship metadata for all target records
@@ -1260,13 +1455,13 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
       // Create lookup map
       const targetById = {}
       targetRecords.forEach(record => {
-        targetById[record.id] = record
+        targetById[getFieldValueForScope(scopes, targetType, record, 'id')] = record
       })
 
       // Add to included and set relationships
       records.forEach(record => {
-        if (record[typeField] === targetType) {
-          const targetId = record[idField]
+        if (getFieldValueForScope(scopes, scopeName, record, typeField) === targetType) {
+          const targetId = getFieldValueForScope(scopes, scopeName, record, idField)
           const targetRecord = targetById[targetId]
 
           if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
@@ -1301,12 +1496,8 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
             }
 
             // Add links if urlPrefix is configured
-            const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
             if (scopeName) {
-              relationshipObject.links = {
-                self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${relName}`,
-                related: `${urlPrefix}/${scopeName}/${record.id}/${relName}`
-              }
+              relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, relName)
             }
 
             record[RELATIONSHIPS_KEY][relName] = relationshipObject
@@ -1314,12 +1505,8 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
             const relationshipObject = { data: null }
 
             // Add links if urlPrefix is configured
-            const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
             if (scopeName) {
-              relationshipObject.links = {
-                self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${relName}`,
-                related: `${urlPrefix}/${scopeName}/${record.id}/${relName}`
-              }
+              relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, relName)
             }
 
             record[RELATIONSHIPS_KEY][relName] = relationshipObject
@@ -1332,8 +1519,8 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
         const nextPath = `${currentPath}.${relName}`
         if (!processedPaths.has(nextPath)) {
           await processIncludes(
-            { records: targetRecords, scopeName: targetType, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields, idProperty: targetIdProperty },
-            { context: { scopes, log, knex, capabilities } }
+            { records: targetRecords, scopeName: targetType, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields },
+            { context: { scopes, log, knex, capabilities, requestContext } }
           )
         }
       }
@@ -1346,12 +1533,8 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
         const relationshipObject = { data: null }
 
         // Add links if urlPrefix is configured
-        const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
         if (scopeName) {
-          relationshipObject.links = {
-            self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${relName}`,
-            related: `${urlPrefix}/${scopeName}/${record.id}/${relName}`
-          }
+          relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, relName)
         }
 
         record[RELATIONSHIPS_KEY][relName] = relationshipObject
@@ -1401,7 +1584,7 @@ export const loadPolymorphicBelongsTo = async (scope, deps) => {
  */
 export const loadReversePolymorphic = async (scope, deps) => {
   const { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Loading reverse polymorphic (via):', {
       scopeName,
@@ -1429,7 +1612,7 @@ export const loadReversePolymorphic = async (scope, deps) => {
     const targetTable = scopes[targetScope].vars.schemaInfo.tableName
 
     // Collect parent IDs
-    const parentIds = records.map(r => r.id).filter(Boolean)
+    const parentIds = records.map(record => getFieldValueForScope(scopes, scopeName, record, 'id')).filter(Boolean)
     if (parentIds.length === 0) return
 
     log.debug(`[INCLUDE] Loading ${targetScope} records via ${viaRelName}:`, {
@@ -1440,13 +1623,13 @@ 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 targetIdProperty = targetScopeObject.vars.schemaInfo.idProperty
+    const targetIdColumn = getIdColumnForScope(scopes, targetScope)
     const fieldSelectionInfo = fields?.[targetScope]
       ? await buildFieldSelection(targetScopeObject, {
         context: {
+          ...(requestContext || {}),
           scopeName: targetScope,
           queryParams: { fields: { [targetScope]: fields[targetScope] } },
           schemaInfo: targetScopeObject.vars.schemaInfo,
@@ -1456,18 +1639,45 @@ export const loadReversePolymorphic = async (scope, deps) => {
       : null
 
     // Query for records pointing back to our scope
+    const typeColumn = translateColumnForScope(scopes, targetScope, typeField)
+    const idColumn = translateColumnForScope(scopes, targetScope, idField)
     let query = knex(targetTable)
-      .where(typeField, scopeName)
-      .whereIn(idField, parentIds)
+      .where(typeColumn, scopeName)
+      .whereIn(idColumn, parentIds)
 
     if (fieldSelectionInfo) {
-      const selectFields = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, storageAdapter)
-      query = query.select(selectFields)
-    } else if (targetIdProperty !== 'id') {
-    // If no field selection but custom idProperty, we need to alias it
-      query = query.select('*', `${targetIdProperty} as id`)
+      const selectionState = await applyFieldSelectionToQuery({
+        query,
+        scope: targetScopeObject,
+        fieldSelectionInfo,
+        tableName: targetTable,
+        useTablePrefix: false,
+        storageAdapter,
+        db: knex,
+        context: {
+          ...(requestContext || {}),
+          scopeName: targetScope,
+          schemaInfo: targetScopeObject.vars.schemaInfo,
+          storageAdapter,
+        },
+        scopeName: targetScope
+      })
+      query = selectionState.query
+    } else if (targetIdColumn !== 'id') {
+    // If no field selection but the storage ID column is not `id`, alias it for response shaping.
+      query = query.select('*', `${targetIdColumn} as id`)
     }
 
+    const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+      query,
+      scopes,
+      scopeName: targetScope,
+      requestContext,
+      db: knex,
+      tableName: targetTable
+    })
+    query = scopedQueryState.query
+
     // Apply include configuration (limits, ordering, etc.)
     const targetVars = scopes[targetScope].vars
     query = applyStandardIncludeConfig(
@@ -1489,7 +1699,7 @@ export const loadReversePolymorphic = async (scope, deps) => {
     // Group by parent ID
     const childrenByParent = {}
     targetRecords.forEach(record => {
-      const parentId = record[idField]
+      const parentId = getFieldValueForScope(scopes, targetScope, record, idField)
       if (!childrenByParent[parentId]) {
         childrenByParent[parentId] = []
       }
@@ -1500,10 +1710,12 @@ export const loadReversePolymorphic = async (scope, deps) => {
     records.forEach(record => {
       if (!record[RELATIONSHIPS_KEY]) record[RELATIONSHIPS_KEY] = {}
 
-      const children = childrenByParent[record.id] || []
+      const recordId = getFieldValueForScope(scopes, scopeName, record, 'id')
+      const children = childrenByParent[recordId] || []
       const relData = children.map(childRecord => {
       // Add to included
-        const resourceKey = `${targetScope}:${childRecord.id}`
+        const childRecordId = getFieldValueForScope(scopes, targetScope, childRecord, 'id')
+        const resourceKey = `${targetScope}:${childRecordId}`
         if (!included.has(resourceKey)) {
           const jsonApiRecord = toJsonApiRecord(
             scopes[targetScope],
@@ -1525,18 +1737,14 @@ export const loadReversePolymorphic = async (scope, deps) => {
 
           included.set(resourceKey, jsonApiRecord)
         }
-        return { type: targetScope, id: String(childRecord.id) }
+        return { type: targetScope, id: String(childRecordId) }
       })
 
       const relationshipObject = { data: relData }
 
       // Add links if urlPrefix is configured
-      const urlPrefix = scopes[scopeName]?.vars?.returnBasePath || scopes[scopeName]?.vars?.mountPath || ''
       if (scopeName) {
-        relationshipObject.links = {
-          self: `${urlPrefix}/${scopeName}/${record.id}/relationships/${includeName}`,
-          related: `${urlPrefix}/${scopeName}/${record.id}/${includeName}`
-        }
+        relationshipObject.links = buildRelationshipLinks(scopes, scopeName, record, includeName)
       }
 
       record[RELATIONSHIPS_KEY][includeName] = relationshipObject
@@ -1547,8 +1755,8 @@ export const loadReversePolymorphic = async (scope, deps) => {
       const nextPath = `${currentPath}.${includeName}`
       if (!processedPaths.has(nextPath)) {
         await processIncludes(
-          { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields, idProperty: targetIdProperty },
-          { context: { scopes, log, knex } }
+          { records: targetRecords, scopeName: targetScope, includeTree: subIncludes, included, processedPaths, currentPath: nextPath, fields },
+          { context: { scopes, log, knex, capabilities, requestContext } }
         )
       }
     }
@@ -1588,7 +1796,6 @@ export const loadReversePolymorphic = async (scope, deps) => {
  *   - processedPaths: Set - Set tracking processed paths to prevent cycles
  *   - currentPath: string - Current path in the include tree (default '')
  *   - fields: Object - Sparse fieldsets configuration (default {})
- *   - idProperty: string - The ID property name
  * @param {Object} deps - Dependencies object containing:
  *   - context.scopes: Object - The hooked-api scopes object
  *   - context.log: Object - Logger instance
@@ -1596,8 +1803,8 @@ export const loadReversePolymorphic = async (scope, deps) => {
  * @returns {Promise<void>}
  */
 export const processIncludes = async (scope, deps) => {
-  const { records, scopeName, includeTree, included, processedPaths, currentPath = '', fields = {}, idProperty } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { records, scopeName, includeTree, included, processedPaths, currentPath = '', fields = {} } = scope
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Processing includes:', {
       scopeName,
@@ -1636,8 +1843,8 @@ export const processIncludes = async (scope, deps) => {
         for (const [fieldName, fieldDef] of Object.entries(schemaInstance.structure || {})) {
           if (fieldDef.as === includeName && fieldDef.belongsTo) {
             await loadBelongsTo(
-              { records, scopeName, fieldName, fieldDef, includeName, subIncludes, included, processedPaths, currentPath, fields, idProperty },
-              { context: { scopes, log, knex, capabilities } }
+              { records, scopeName, fieldName, fieldDef, includeName, subIncludes, included, processedPaths, currentPath, fields },
+              { context: { scopes, log, knex, capabilities, requestContext } }
             )
             handled = true
             break
@@ -1658,7 +1865,7 @@ export const processIncludes = async (scope, deps) => {
               })
               await loadHasOne(
                 { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields },
-                { context: { scopes, log, knex, capabilities } }
+                { context: { scopes, log, knex, capabilities, requestContext } }
               )
               handled = true
             } else if (relDef.type === 'hasMany' || relDef.type === 'manyToMany') {
@@ -1666,7 +1873,7 @@ export const processIncludes = async (scope, deps) => {
               if (relDef.via) {
                 await loadReversePolymorphic(
                   { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields },
-                  { context: { scopes, log, knex, capabilities } }
+                  { context: { scopes, log, knex, capabilities, requestContext } }
                 )
               } else {
                 log.debug('[INCLUDE] About to call loadHasMany:', {
@@ -1678,14 +1885,14 @@ export const processIncludes = async (scope, deps) => {
                 })
                 await loadHasMany(
                   { records, scopeName, includeName, relDef, subIncludes, included, processedPaths, currentPath, fields },
-                  { context: { scopes, log, knex, capabilities } }
+                  { context: { scopes, log, knex, capabilities, requestContext } }
                 )
               }
               handled = true
             } else if (relDef.belongsToPolymorphic) {
               await loadPolymorphicBelongsTo(
                 { records, scopeName, relName: includeName, relDef, subIncludes, included, processedPaths, currentPath, fields },
-                { context: { scopes, log, knex, capabilities } }
+                { context: { scopes, log, knex, capabilities, requestContext } }
               )
               handled = true
             }
@@ -1737,7 +1944,6 @@ export const processIncludes = async (scope, deps) => {
  *   - scopeName: string - The scope name of the main resources
  *   - includeParam: string - The include parameter value (e.g., "author,comments.author")
  *   - fields: Object - Sparse fieldsets configuration
- *   - idProperty: string - The ID property name
  * @param {Object} deps - Dependencies object containing:
  *   - context.scopes: Object - The hooked-api scopes object
  *   - context.log: Object - Logger instance
@@ -1750,8 +1956,7 @@ export const processIncludes = async (scope, deps) => {
  *     records: articleRecords,
  *     scopeName: 'articles',
  *     includeParam: 'author,comments.author',
- *     fields: { articles: 'title,body', people: 'name' },
- *     idProperty: 'id'
+ *     fields: { articles: 'title,body', people: 'name' }
  *   },
  *   { context: { scopes, log, knex } }
  * );
@@ -1765,8 +1970,8 @@ export const processIncludes = async (scope, deps) => {
  * // result.recordsWithRelationships = original records with _relationships added
  */
 export const buildIncludedResources = async (scope, deps) => {
-  const { records, scopeName, includeParam, fields, idProperty } = scope
-  const { scopes, log, knex, capabilities } = deps.context
+  const { records, scopeName, includeParam, fields } = scope
+  const { scopes, log, knex, capabilities, requestContext } = deps.context
   try {
     log.trace('[INCLUDE] Building included resources:', { scopeName, includeParam, recordCount: records.length })
 
@@ -1799,8 +2004,8 @@ export const buildIncludedResources = async (scope, deps) => {
 
     // Process all includes
     await processIncludes(
-      { records, scopeName, includeTree, included, processedPaths, currentPath: '', fields, idProperty },
-      { context: { scopes, log, knex, capabilities } }
+      { records, scopeName, includeTree, included, processedPaths, currentPath: '', fields },
+      { context: { scopes, log, knex, capabilities, requestContext } }
     )
 
     // Convert Map to array for JSON:API format
@@ -1873,7 +2078,7 @@ export const buildIncludedResources = async (scope, deps) => {
  * @param {Object} knex - Knex instance for database queries
  * @returns {Promise<void>} Modifies records in place by adding relationship data
  */
-export const loadRelationshipIdentifiers = async (records, scopeName, scopes, knex) => {
+export const loadRelationshipIdentifiers = async (records, scopeName, scopes, knex, requestContext = null) => {
   if (!records.length) return
 
   const schemaInfo = scopes[scopeName]?.vars?.schemaInfo
@@ -1896,14 +2101,27 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
       }
       const targetScope = scopes[relDef.target]
       const targetTable = targetScope?.vars?.schemaInfo?.tableName || relDef.target
-      const targetIdProperty = targetScope?.vars?.schemaInfo?.idProperty || 'id'
+      const targetIdColumn = getIdColumnForScope(scopes, relDef.target)
+      const foreignKeyColumn = translateColumnForScope(scopes, relDef.target, foreignKey)
+
+      let query = knex(targetTable)
+        .whereIn(foreignKeyColumn, recordIds)
+        .select(targetIdColumn !== 'id' ? `${targetIdColumn} as id` : 'id', foreignKeyColumn)
+
+      const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+        query,
+        scopes,
+        scopeName: relDef.target,
+        requestContext,
+        db: knex,
+        tableName: targetTable
+      })
+      query = scopedQueryState.query
 
-      const results = await knex(targetTable)
-        .whereIn(foreignKey, recordIds)
-        .select(targetIdProperty !== 'id' ? `${targetIdProperty} as id` : 'id', foreignKey)
+      const results = await query
 
       results.forEach(row => {
-        const parentId = String(row[foreignKey])
+        const parentId = String(row[foreignKeyColumn])
         if (!idsMap[parentId]) idsMap[parentId] = []
         idsMap[parentId].push(String(row.id))
       })
@@ -1922,13 +2140,34 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
       const pivotScope = scopes[through]
       const pivotTable = pivotScope?.vars?.schemaInfo?.tableName || through
 
-      const results = await knex(pivotTable)
-        .whereIn(fk, recordIds)
-        .select(fk, ok)
+      const targetScopeName = relDef.target || relName
+      const targetTable = scopes[targetScopeName]?.vars?.schemaInfo?.tableName || targetScopeName
+      const targetIdColumn = getIdColumnForScope(scopes, targetScopeName)
+      let query = knex(targetTable)
+        .join(`${pivotTable} as pivot`, `${targetTable}.${targetIdColumn}`, `pivot.${ok}`)
+        .whereIn(`pivot.${fk}`, recordIds)
+        .select(
+          `pivot.${fk} as __parent_id`,
+          targetIdColumn !== 'id'
+            ? `${targetTable}.${targetIdColumn} as id`
+            : `${targetTable}.id as id`
+        )
+
+      const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+        query,
+        scopes,
+        scopeName: targetScopeName,
+        requestContext,
+        db: knex,
+        tableName: targetTable
+      })
+      query = scopedQueryState.query
+
+      const results = await query
 
       results.forEach(row => {
-        const parentId = String(row[fk])
-        const childId = String(row[ok])
+        const parentId = String(row.__parent_id)
+        const childId = String(row.id)
         if (!idsMap[parentId]) idsMap[parentId] = []
         idsMap[parentId].push(childId)
       })
@@ -1944,15 +2183,29 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
 
         // Get the actual table name
         const targetTable = scopes[targetScope]?.vars?.schemaInfo?.tableName || targetScope
-        const targetIdProperty = scopes[targetScope]?.vars?.schemaInfo?.idProperty || 'id'
+        const targetIdColumn = getIdColumnForScope(scopes, targetScope)
+        const typeColumn = translateColumnForScope(scopes, targetScope, typeField)
+        const idColumn = translateColumnForScope(scopes, targetScope, idField)
+
+        let query = knex(targetTable)
+          .where(typeColumn, scopeName)
+          .whereIn(idColumn, recordIds)
+          .select(targetIdColumn !== 'id' ? `${targetIdColumn} as id` : 'id', idColumn)
+
+        const scopedQueryState = await applyScopeFiltersToIncludeQuery({
+          query,
+          scopes,
+          scopeName: targetScope,
+          requestContext,
+          db: knex,
+          tableName: targetTable
+        })
+        query = scopedQueryState.query
 
-        const results = await knex(targetTable)
-          .where(typeField, scopeName)
-          .whereIn(idField, recordIds)
-          .select(targetIdProperty !== 'id' ? `${targetIdProperty} as id` : 'id', idField)
+        const results = await query
 
         results.forEach(row => {
-          const parentId = String(row[idField])
+          const parentId = String(row[idColumn])
           if (!idsMap[parentId]) idsMap[parentId] = []
           idsMap[parentId].push(String(row.id))
         })
@@ -1966,7 +2219,7 @@ export const loadRelationshipIdentifiers = async (records, scopeName, scopes, kn
           record[RELATIONSHIPS_KEY] = {}
         }
 
-        const ids = idsMap[String(record.id)] || []
+        const ids = idsMap[String(getFieldValueForScope(scopes, scopeName, record, 'id'))] || []
         // For manyToMany, the target type is the relationship name itself
         // For hasMany/hasOne, the target type is specified in the target property
         const targetType = (relDef.type === 'manyToMany') ? relName : relDef.target