json-rest-api 1.0.22 → 1.0.24

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

@@ -5,6 +5,7 @@ import { createSchema } from 'json-rest-schema'
 import {
   DEFAULT_QUERY_LIMIT,
   DEFAULT_MAX_QUERY_LIMIT,
+  COMPUTED_DEPENDENCIES_KEY,
 } from './lib/querying-writing/knex-constants.js'
 import {
   calculatePaginationMeta,
@@ -13,7 +14,7 @@ import {
   buildCursorMeta,
   parseCursor,
 } from './lib/querying/knex-pagination-helpers.js'
-import { getUrlPrefix, buildResourceUrl } from './lib/querying/url-helpers.js'
+import { getUrlPrefix, buildResourceUrl, buildRelationshipUrl } from './lib/querying/url-helpers.js'
 import {
   normalizeId,
   resolveFieldInfo,
@@ -29,13 +30,30 @@ import {
   ensureSearchFieldsAreIndexed,
   generateSearchSchemaFromSchema,
 } from './lib/querying-writing/schema-helpers.js'
-import { buildFieldSelection } from './lib/querying-writing/knex-field-helpers.js'
+import { applyFieldSelectionToQuery, buildFieldSelection } from './lib/querying-writing/knex-field-helpers.js'
 import {
   polymorphicFiltersHook,
   crossTableFiltersHook,
   basicFiltersHook,
+  resolveSearchOperator,
+  applyWhereForOperator,
 } from './lib/querying/knex-query-helpers.js'
-import { createStorageAdapter } from './lib/storage/storage-adapter.js'
+import {
+  createStorageAdapter,
+} from './lib/storage/storage-adapter.js'
+import {
+  translateCanonicalAttributesForStorage,
+  getCanonicalResourceId,
+  getCanonicalResourceIdColumn,
+  translateCanonicalRecordFromStorage,
+} from './lib/storage/canonical-storage-mapping.js'
+import {
+  buildCursorPredicateChains,
+  applyQueryFieldOrder,
+  buildEffectiveSortList,
+  parseSortEntry
+} from './lib/querying/query-field-sort-helpers.js'
+import { unwrapQueryBuilderState } from './lib/querying/query-builder-utils.js'
 
 const DEFAULT_TENANT = 'default'
 const LINKS_TABLE = 'any_links'
@@ -107,76 +125,138 @@ export const RestApiAnyapiKnexPlugin = {
       return descriptor
     }
 
-    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) {
+    const decorateResourceLinks = ({ resource, scope, scopeName, context }) => {
+      if (!resource || !scope || !scopeName || !context) return
+
+      resource.links = resource.links || {}
+      resource.links.self = buildResourceUrl(context, scope, scopeName, resource.id)
+
+      if (!resource.relationships || typeof resource.relationships !== 'object') {
         return
       }
 
-      // TODO: Probably delete the rest of the function. searchSchema is always there...!!!
+      for (const [relationshipName, relationshipObject] of Object.entries(resource.relationships)) {
+        if (!relationshipObject || typeof relationshipObject !== 'object') {
+          continue
+        }
+
+        relationshipObject.links = {
+          self: buildRelationshipUrl(context, scope, scopeName, resource.id, relationshipName, true),
+          related: buildRelationshipUrl(context, scope, scopeName, resource.id, relationshipName, false),
+        }
+      }
+    }
+
+    const getAllowedQueryFieldNames = (scopeName) => (
+      Object.keys(api.resources?.[scopeName]?.vars?.queryFields || {})
+    )
+
+    const getLogicalResourceIdColumn = (descriptor) => getCanonicalResourceIdColumn(descriptor)
+
+    const getLogicalResourceId = (row, descriptor) => getCanonicalResourceId(row, descriptor)
+
+    const applyFiltersToQuery = ({ query, filters, descriptor, searchSchema, adapter }) => {
       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 fieldInfo = ensureFilterableField(descriptor, field)
+      const normalizeValue = (field, value) => {
+        if (!adapter?.translateFilterValue) {
+          return value
+        }
+        if (Array.isArray(value)) {
+          return value.map((entry) => adapter.translateFilterValue(field, entry))
+        }
+        return adapter.translateFilterValue(field, value)
+      }
+
+      for (const [filterKey, rawValue] of Object.entries(filters)) {
+        const fieldDef = searchSchema?.[filterKey]
+
+        if (fieldDef?.polymorphicField) {
+          continue
+        }
+
+        if (fieldDef?.actualField?.includes('.')) {
+          continue
+        }
+
+        if (fieldDef?.oneOf?.some((field) => field.includes('.'))) {
+          continue
+        }
+
+        if (fieldDef?.oneOf && Array.isArray(fieldDef.oneOf)) {
+          continue
+        }
+
+        if (fieldDef?.applyFilter && typeof fieldDef.applyFilter === 'function') {
+          continue
+        }
+
+        const actualField = fieldDef?.actualField || filterKey
+        const fieldInfo = ensureFilterableField(descriptor, filterKey)
+        const columnRef = adapter ? adapter.translateColumn(actualField) : fieldInfo.column
+        const operator = resolveSearchOperator(fieldDef || fieldInfo.definition)
         const values = normalizeFilterValues(rawValue, fieldInfo.definition, {
           isRelationship: fieldInfo.isRelationship,
         })
-
-        const nonNullValues = values.filter((value) => value !== null)
-        const hasNull = values.length !== nonNullValues.length
+        const normalizedValues = values.map((value) => normalizeValue(actualField, value))
+        const nonNullValues = normalizedValues.filter((value) => value !== null)
+        const hasNull = normalizedValues.length !== nonNullValues.length
 
         if (nonNullValues.length === 0 && hasNull) {
-          query.whereNull(fieldInfo.column)
+          query.whereNull(columnRef)
           continue
         }
         if (nonNullValues.length === 1 && !hasNull) {
-          query.where(fieldInfo.column, nonNullValues[0])
+          applyWhereForOperator({
+            builder: query,
+            columnRef,
+            operator,
+            value: nonNullValues[0],
+            knex,
+          })
           continue
         }
         if (nonNullValues.length > 1 && !hasNull) {
-          query.whereIn(fieldInfo.column, nonNullValues)
+          query.whereIn(columnRef, nonNullValues)
           continue
         }
         if (nonNullValues.length > 0 && hasNull) {
-          query.where(function filterGroup () {
-            this.whereIn(fieldInfo.column, nonNullValues).orWhereNull(fieldInfo.column)
+          query.where(function anyApiNullFilterGroup () {
+            this.whereIn(columnRef, nonNullValues).orWhereNull(columnRef)
           })
         }
       }
     }
 
-    const applySortingToQuery = ({ query, sort, descriptor, scope }) => {
-      let sortList = Array.isArray(sort) ? sort : (sort ? [sort] : [])
-
-      if (sortList.length === 0 && scope?.vars?.defaultSort) {
-        const defaultSort = scope.vars.defaultSort
-        if (Array.isArray(defaultSort)) {
-          sortList = defaultSort
-        } else if (typeof defaultSort === 'string') {
-          sortList = [defaultSort]
-        } else if (defaultSort && typeof defaultSort === 'object') {
-          const field = defaultSort.field || defaultSort.column || 'id'
-          const direction = (defaultSort.direction || '').toLowerCase() === 'desc' ? '-' : ''
-          sortList = [`${direction}${field}`]
-        }
-      }
-
-      const effectiveSort = sortList.length > 0 ? sortList : ['id']
+    const applySortingToQuery = ({ query, sort, descriptor, scope, queryFieldRuntimeByField = new Map() }) => {
+      const effectiveSort = buildEffectiveSortList(sort, {
+        defaultSort: scope?.vars?.defaultSort,
+        idField: 'id'
+      })
       const descriptors = []
 
       for (const entry of effectiveSort) {
-        const desc = typeof entry === 'string' && entry.startsWith('-')
-        const field = typeof entry === 'string' ? (desc ? entry.slice(1) : entry) : entry
+        const { field, direction, sqlDirection } = parseSortEntry(entry)
+        const queryFieldRuntime = queryFieldRuntimeByField.get(field)
+        if (queryFieldRuntime) {
+          applyQueryFieldOrder(query, queryFieldRuntime, sqlDirection)
+          descriptors.push({
+            field,
+            direction,
+            definition: queryFieldRuntime.definition,
+            isRelationship: false,
+            queryFieldRuntime,
+          })
+          continue
+        }
+
         const fieldInfo = resolveFieldInfo(descriptor, field)
         if (!fieldInfo?.column) continue
-        query.orderBy(fieldInfo.column, desc ? 'desc' : 'asc')
+        query.orderBy(fieldInfo.column, direction)
         descriptors.push({
           field,
           column: fieldInfo.column,
-          direction: desc ? 'desc' : 'asc',
+          direction,
           definition: fieldInfo.definition || null,
           isRelationship: fieldInfo.isRelationship || false,
         })
@@ -282,64 +362,37 @@ export const RestApiAnyapiKnexPlugin = {
         return typed
       }
 
-      const buildCursorPredicate = (cursorValues, operatorSelector) => {
-        if (!descriptors || descriptors.length === 0) {
-          return
-        }
-
-        if (descriptors.length === 1) {
-          const descriptor = descriptors[0]
-          const value = cursorValues[descriptor.field]
-          if (value === undefined) return
-          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
-          const operator = operatorSelector(descriptor.direction)
-          if (adapter) {
-            query.whereRaw(`${columnRef} ${operator} ?`, [value])
-          } else {
-            query.where(columnRef, operator, value)
-          }
-          return
-        }
-
-        const translatedConditions = []
-
-        descriptors.forEach((descriptor, index) => {
-          const value = cursorValues[descriptor.field]
-          if (value === undefined) return
-
-          const chain = []
-          for (let i = 0; i < index; i += 1) {
-            const prev = descriptors[i]
-            const prevValue = cursorValues[prev.field]
-            if (prevValue === undefined) return
-            const prevColumn = adapter ? adapter.translateColumn(prev.column) : prev.column
-            chain.push({ column: prevColumn, operator: '=', value: prevValue })
-          }
-
-          const operator = operatorSelector(descriptor.direction)
-          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
-          chain.push({ column: columnRef, operator, value })
-          translatedConditions.push(chain)
-        })
+      const applyRawCursorPredicate = (cursorValues, operatorSelector) => {
+        const predicateChains = buildCursorPredicateChains(
+          descriptors,
+          cursorValues,
+          operatorSelector,
+          { onMissingValue: () => {} }
+        )
 
-        if (translatedConditions.length === 0) {
+        if (predicateChains.length === 0) {
           return
         }
 
         const predicateParts = []
         const predicateBindings = []
-        translatedConditions.forEach((chain) => {
-          const chainParts = chain.map(({ column, operator, value }) => {
+
+        predicateChains.forEach((chain) => {
+          const chainParts = chain.map(({ descriptor, operator, value }) => {
+            if (descriptor.queryFieldRuntime) {
+              predicateBindings.push(...(descriptor.queryFieldRuntime.bindings || []), value)
+              return `(${descriptor.queryFieldRuntime.sql}) ${operator} ?`
+            }
+
+            const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
             predicateBindings.push(value)
-            return `${column} ${operator} ?`
+            return `${columnRef} ${operator} ?`
           })
+
           predicateParts.push(`(${chainParts.join(' AND ')})`)
         })
 
-        if (predicateParts.length > 0) {
-          const combined = predicateParts.join(' OR ')
-          query.whereRaw(`(${combined})`, predicateBindings)
-        }
+        query.whereRaw(`(${predicateParts.join(' OR ')})`, predicateBindings)
       }
 
       const ensurePageSize = () => {
@@ -378,11 +431,11 @@ export const RestApiAnyapiKnexPlugin = {
         if (pageParams.after) {
           const cursorMap = parseCursorOrThrow(pageParams.after, 'after')
           const cursorValues = coerceCursorValues(cursorMap)
-          buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '<' : '>'))
+          applyRawCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '<' : '>'))
         } else if (pageParams.before) {
           const cursorMap = parseCursorOrThrow(pageParams.before, 'before')
           const cursorValues = coerceCursorValues(cursorMap)
-          buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '>' : '<'))
+          applyRawCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '>' : '<'))
         }
 
         return {
@@ -900,12 +953,13 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
 
       const row = await context.db(canonical.tableName)
         .select('id')
         .where(canonical.tenantColumn, descriptor.tenant)
         .where(canonical.resourceColumn, descriptor.resource)
-        .where('id', id)
+        .where(logicalIdColumn, id)
         .first()
 
       return !!row
@@ -918,8 +972,17 @@ export const RestApiAnyapiKnexPlugin = {
       }
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
+      const explicitId = context.inputRecord?.data?.id
       const attributes = context.inputRecord?.data?.attributes || {}
-      const row = translateAttributesForStorage(attributes, descriptor)
+      const row = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(attributes)
+        : translateCanonicalAttributesForStorage(attributes, descriptor)
+
+      if (explicitId !== undefined && explicitId !== null) {
+        row[logicalIdColumn] = explicitId
+      }
+
       row[canonical.tenantColumn] = descriptor.tenant
       row[canonical.resourceColumn] = descriptor.resource
 
@@ -928,10 +991,25 @@ export const RestApiAnyapiKnexPlugin = {
         .returning('id')
 
       const inserted = Array.isArray(result) ? result[0] : result
-      if (inserted && typeof inserted === 'object' && 'id' in inserted) {
-        return inserted.id
+      const insertedRowId = inserted && typeof inserted === 'object' && 'id' in inserted
+        ? inserted.id
+        : inserted
+
+      if (explicitId !== undefined && explicitId !== null) {
+        return explicitId
+      }
+
+      if (insertedRowId === undefined || insertedRowId === null) {
+        return insertedRowId
       }
-      return inserted
+
+      const generatedLogicalId = String(insertedRowId)
+
+      await context.db(canonical.tableName)
+        .where({ id: insertedRowId })
+        .update({ [logicalIdColumn]: generatedLogicalId })
+
+      return generatedLogicalId
     }
 
     helpers.dataPut = async ({ scopeName, context }) => {
@@ -942,8 +1020,11 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
       const attributes = context.inputRecord?.data?.attributes || {}
-      const row = translateAttributesForStorage(attributes, descriptor)
+      const row = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(attributes)
+        : translateCanonicalAttributesForStorage(attributes, descriptor)
 
       row[canonical.resourceColumn] = descriptor.resource
       row[canonical.tenantColumn] = descriptor.tenant
@@ -957,7 +1038,7 @@ export const RestApiAnyapiKnexPlugin = {
       }
 
       const result = await context.db(canonical.tableName)
-        .where('id', id)
+        .where(logicalIdColumn, id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
         .update(updateRow)
@@ -973,8 +1054,11 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
       const attributes = context.inputRecord?.data?.attributes || {}
-      const row = translateAttributesForStorage(attributes, descriptor)
+      const row = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(attributes)
+        : translateCanonicalAttributesForStorage(attributes, descriptor)
 
       const updateRow = Object.fromEntries(
         Object.entries(row).filter(([, value]) => value !== undefined)
@@ -985,7 +1069,7 @@ export const RestApiAnyapiKnexPlugin = {
       }
 
       const result = await context.db(canonical.tableName)
-        .where('id', id)
+        .where(logicalIdColumn, id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
         .update(updateRow)
@@ -1001,9 +1085,10 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
 
       const result = await context.db(canonical.tableName)
-        .where('id', id)
+        .where(logicalIdColumn, id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
         .delete()
@@ -1011,7 +1096,7 @@ export const RestApiAnyapiKnexPlugin = {
       return result
     }
 
-    helpers.dataGetMinimal = async ({ scopeName, context }) => {
+    helpers.dataGetMinimal = async ({ scopeName, context, runHooks, applyQueryFilters }) => {
       const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
         context.storageAdapter = storageAdapter
@@ -1019,26 +1104,64 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
       const scope = api.resources?.[scopeName]
 
-      const row = await context.db(canonical.tableName)
-        .where('id', id)
+      let query = context.db(canonical.tableName)
+        .where(logicalIdColumn, id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .first()
+
+      if (typeof applyQueryFilters === 'function') {
+        const scopedQueryState = await applyQueryFilters({
+          query,
+          filters: context.queryParams?.filters,
+          tableName: canonical.tableName,
+          db: context.db,
+          scopeName,
+          storageAdapter,
+          isAnyApi: true
+        })
+        query = unwrapQueryBuilderState(scopedQueryState, query)
+      } else if (runHooks) {
+        context.knexQuery = {
+          query,
+          filters: context.queryParams?.filters,
+          schemaInfo: context.schemaInfo,
+          scopeName,
+          tableName: canonical.tableName,
+          db: context.db,
+          isAnyApi: true,
+          adapter: storageAdapter,
+          storageAdapter,
+        }
+
+        await applyBuiltInAnyApiQueryFilters(context)
+
+        await runHooks('knexQueryFiltering')
+
+        if (context.knexQuery) {
+          delete context.knexQuery
+        }
+      }
+
+      const row = await query.first()
 
       if (!row) return null
-      const translated = translateRecordFromStorage(row, descriptor)
+      const translated = translateCanonicalRecordFromStorage(
+        row,
+        descriptor,
+        { allowedExtraFields: getAllowedQueryFieldNames(scopeName) }
+      )
+      const resourceId = getLogicalResourceId(row, descriptor)
       const minimal = {
         type: descriptor.resource,
-        id: String(row.id),
+        id: resourceId,
         attributes: translated.attributes,
         relationships: translated.relationships,
       }
       if (scope) {
-        minimal.links = {
-          self: buildResourceUrl(context, scope, scopeName, minimal.id),
-        }
+        decorateResourceLinks({ resource: minimal, scope, scopeName, context })
       }
       return minimal
     }
@@ -1069,17 +1192,107 @@ export const RestApiAnyapiKnexPlugin = {
       return tree
     }
 
+    const applyIncludeFieldSelection = async ({ query, resourceName, tableName, context }) => {
+      const targetScope = api.resources?.[resourceName]
+      if (!targetScope) {
+        return { query, fieldSelectionInfo: null }
+      }
+
+      const storageAdapter = getScopeStorageAdapter(resourceName)
+      const fieldSelectionInfo = await buildFieldSelection(targetScope, {
+        context: {
+          ...context,
+          scopeName: resourceName,
+          schemaInfo: targetScope.vars.schemaInfo,
+          storageAdapter,
+        }
+      })
+
+      const selectionState = await applyFieldSelectionToQuery({
+        query,
+        scope: targetScope,
+        fieldSelectionInfo,
+        tableName,
+        useTablePrefix: false,
+        storageAdapter,
+        db: context.db || context.transaction || api.knex.instance,
+        context,
+        scopeName: resourceName
+      })
+
+      return {
+        query: selectionState.query,
+        fieldSelectionInfo
+      }
+    }
+
+    const applyTargetScopeFilters = async ({ query, resourceName, tableName, context, filters }) => {
+      const targetScope = api.resources?.[resourceName]
+      if (!targetScope?.applyQueryFilters) {
+        return { query }
+      }
+
+      const storageAdapter = getScopeStorageAdapter(resourceName)
+      const queryState = await targetScope.applyQueryFilters({
+        query,
+        filters,
+        schemaInfo: targetScope.vars?.schemaInfo,
+        scopeName: resourceName,
+        tableName,
+        db: context.db || context.transaction || api.knex.instance,
+        isAnyApi: true,
+        storageAdapter
+      }, {
+        ...context,
+        scopeName: resourceName,
+        schemaInfo: targetScope.vars?.schemaInfo,
+        storageAdapter
+      })
+
+      return {
+        query: unwrapQueryBuilderState(queryState, query)
+      }
+    }
+
+    const buildIncludedResource = ({ row, descriptor, context, fieldSelectionInfo = null }) => {
+      const translated = translateCanonicalRecordFromStorage(
+        row,
+        descriptor,
+        { allowedExtraFields: getAllowedQueryFieldNames(descriptor.resource) }
+      )
+      const resourceId = getLogicalResourceId(row, descriptor)
+      const includeResource = {
+        type: descriptor.resource,
+        id: resourceId,
+        attributes: translated.attributes,
+      }
+
+      if (translated.relationships && Object.keys(translated.relationships).length > 0) {
+        includeResource.relationships = translated.relationships
+      }
+
+      if (fieldSelectionInfo?.computedDependencies?.length) {
+        includeResource[COMPUTED_DEPENDENCIES_KEY] = fieldSelectionInfo.computedDependencies
+      }
+
+      const targetScope = api.resources?.[descriptor.resource]
+      if (targetScope) {
+        decorateResourceLinks({
+          resource: includeResource,
+          scope: targetScope,
+          scopeName: descriptor.resource,
+          context,
+        })
+      }
+
+      return includeResource
+    }
+
     const collectIncludes = async ({ descriptor, resources, includeTree, context, includes, seen }) => {
       const entries = Object.entries(includeTree || {})
       if (entries.length === 0 || !resources || resources.length === 0) return
 
       const db = context.db || context.transaction || api.knex.instance
-      const addSelfLink = (resource, resourceType) => {
-        const targetScope = api.resources?.[resourceType]
-        if (!targetScope) return
-        resource.links = resource.links || {}
-        resource.links.self = buildResourceUrl(context, targetScope, resourceType, resource.id)
-      }
 
       for (const [relName, childTree] of entries) {
         const childKeys = Object.keys(childTree || {})
@@ -1095,26 +1308,31 @@ export const RestApiAnyapiKnexPlugin = {
           const targetDescriptor = await registry.getDescriptor(tenantId, belongsToInfo.target)
           if (!targetDescriptor) continue
 
-          const rows = await db(targetDescriptor.canonical.tableName)
+          let query = db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-            .whereIn('id', ids)
+            .whereIn(getLogicalResourceIdColumn(targetDescriptor), ids)
+          const selectionState = await applyIncludeFieldSelection({
+            query,
+            resourceName: targetDescriptor.resource,
+            tableName: targetDescriptor.canonical.tableName,
+            context
+          })
+          query = selectionState.query
+          const rows = await query
 
           const newResources = []
           for (const row of rows) {
-            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            const includeId = getLogicalResourceId(row, targetDescriptor)
+            const includeKey = `${targetDescriptor.resource}:${includeId}`
             if (seen.has(includeKey)) continue
             seen.add(includeKey)
-            const translated = translateRecordFromStorage(row, targetDescriptor)
-            const includeResource = {
-              type: targetDescriptor.resource,
-              id: String(row.id),
-              attributes: translated.attributes,
-            }
-            if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-              includeResource.relationships = translated.relationships
-            }
-            addSelfLink(includeResource, targetDescriptor.resource)
+            const includeResource = buildIncludedResource({
+              row,
+              descriptor: targetDescriptor,
+              context,
+              fieldSelectionInfo: selectionState.fieldSelectionInfo
+            })
             includes.push(includeResource)
             newResources.push(includeResource)
           }
@@ -1159,25 +1377,30 @@ export const RestApiAnyapiKnexPlugin = {
               continue
             }
 
-            const rows = await db(targetDescriptor.canonical.tableName)
+            let query = db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-              .whereIn('id', [...idSet])
+              .whereIn(getLogicalResourceIdColumn(targetDescriptor), [...idSet])
+            const selectionState = await applyIncludeFieldSelection({
+              query,
+              resourceName: targetDescriptor.resource,
+              tableName: targetDescriptor.canonical.tableName,
+              context
+            })
+            query = selectionState.query
+            const rows = await query
 
             for (const row of rows) {
-              const includeKey = `${targetDescriptor.resource}:${row.id}`
+              const includeId = getLogicalResourceId(row, targetDescriptor)
+              const includeKey = `${targetDescriptor.resource}:${includeId}`
               if (seen.has(includeKey)) continue
               seen.add(includeKey)
-              const translated = translateRecordFromStorage(row, targetDescriptor)
-              const includeResource = {
-                type: targetDescriptor.resource,
-                id: String(row.id),
-                attributes: translated.attributes,
-              }
-              if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-                includeResource.relationships = translated.relationships
-              }
-              addSelfLink(includeResource, targetDescriptor.resource)
+              const includeResource = buildIncludedResource({
+                row,
+                descriptor: targetDescriptor,
+                context,
+                fieldSelectionInfo: selectionState.fieldSelectionInfo
+              })
               includes.push(includeResource)
               newResources.push(includeResource)
             }
@@ -1243,6 +1466,7 @@ export const RestApiAnyapiKnexPlugin = {
 
           let rows = []
           let groupingColumn = null
+          let fieldSelectionInfo = null
 
           if (hasManyInfo.foreignKey) {
             const foreignField = targetDescriptor.fields?.[hasManyInfo.foreignKey]
@@ -1250,21 +1474,53 @@ export const RestApiAnyapiKnexPlugin = {
               continue
             }
             groupingColumn = foreignField.slot
-            rows = await db(targetDescriptor.canonical.tableName)
+            let query = db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
               .whereIn(groupingColumn, parentIds)
+            const selectionState = await applyIncludeFieldSelection({
+              query,
+              resourceName: targetDescriptor.resource,
+              tableName: targetDescriptor.canonical.tableName,
+              context
+            })
+            query = selectionState.query
+            const scopedQueryState = await applyTargetScopeFilters({
+              query,
+              resourceName: targetDescriptor.resource,
+              tableName: targetDescriptor.canonical.tableName,
+              context
+            })
+            query = scopedQueryState.query
+            fieldSelectionInfo = selectionState.fieldSelectionInfo
+            rows = await query
           } else if (hasManyInfo.via) {
             const polyInfo = targetDescriptor.polymorphicBelongsTo?.[hasManyInfo.via]
             if (!polyInfo?.idColumn || !polyInfo?.typeColumn) {
               continue
             }
             groupingColumn = polyInfo.idColumn
-            rows = await db(targetDescriptor.canonical.tableName)
+            let query = db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
               .where(polyInfo.typeColumn, descriptor.resource)
               .whereIn(groupingColumn, queryIds)
+            const selectionState = await applyIncludeFieldSelection({
+              query,
+              resourceName: targetDescriptor.resource,
+              tableName: targetDescriptor.canonical.tableName,
+              context
+            })
+            query = selectionState.query
+            const scopedQueryState = await applyTargetScopeFilters({
+              query,
+              resourceName: targetDescriptor.resource,
+              tableName: targetDescriptor.canonical.tableName,
+              context
+            })
+            query = scopedQueryState.query
+            fieldSelectionInfo = selectionState.fieldSelectionInfo
+            rows = await query
           }
 
           if (!groupingColumn || rows.length === 0) {
@@ -1273,19 +1529,16 @@ export const RestApiAnyapiKnexPlugin = {
 
           const newResources = []
           for (const row of rows) {
-            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            const includeId = getLogicalResourceId(row, targetDescriptor)
+            const includeKey = `${targetDescriptor.resource}:${includeId}`
             if (seen.has(includeKey)) continue
             seen.add(includeKey)
-            const translated = translateRecordFromStorage(row, targetDescriptor)
-            const includeResource = {
-              type: targetDescriptor.resource,
-              id: String(row.id),
-              attributes: translated.attributes,
-            }
-            if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-              includeResource.relationships = translated.relationships
-            }
-            addSelfLink(includeResource, targetDescriptor.resource)
+            const includeResource = buildIncludedResource({
+              row,
+              descriptor: targetDescriptor,
+              context,
+              fieldSelectionInfo
+            })
             includes.push(includeResource)
             newResources.push(includeResource)
           }
@@ -1323,26 +1576,31 @@ export const RestApiAnyapiKnexPlugin = {
           const targetDescriptor = await registry.getDescriptor(tenantId, info.relInfo.target)
           if (!targetDescriptor) continue
 
-          const rows = await db(targetDescriptor.canonical.tableName)
+          let query = db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-            .whereIn('id', childIds)
+            .whereIn(getLogicalResourceIdColumn(targetDescriptor), childIds)
+          const selectionState = await applyIncludeFieldSelection({
+            query,
+            resourceName: targetDescriptor.resource,
+            tableName: targetDescriptor.canonical.tableName,
+            context
+          })
+          query = selectionState.query
+          const rows = await query
 
           const newResources = []
           for (const row of rows) {
-            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            const includeId = getLogicalResourceId(row, targetDescriptor)
+            const includeKey = `${targetDescriptor.resource}:${includeId}`
             if (seen.has(includeKey)) continue
             seen.add(includeKey)
-            const translated = translateRecordFromStorage(row, targetDescriptor)
-            const includeResource = {
-              type: targetDescriptor.resource,
-              id: String(row.id),
-              attributes: translated.attributes,
-            }
-            if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-              includeResource.relationships = translated.relationships
-            }
-            addSelfLink(includeResource, targetDescriptor.resource)
+            const includeResource = buildIncludedResource({
+              row,
+              descriptor: targetDescriptor,
+              context,
+              fieldSelectionInfo: selectionState.fieldSelectionInfo
+            })
             includes.push(includeResource)
             newResources.push(includeResource)
           }
@@ -1410,17 +1668,25 @@ export const RestApiAnyapiKnexPlugin = {
           if (!foreignField?.slot) continue
           const column = foreignField.slot
 
-          const rows = await db(targetDescriptor.canonical.tableName)
+          let query = db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
             .whereIn(column, normalizedParentIds)
+          const scopedQueryState = await applyTargetScopeFilters({
+            query,
+            resourceName: targetDescriptor.resource,
+            tableName: targetDescriptor.canonical.tableName,
+            context
+          })
+          query = scopedQueryState.query
+          const rows = await query
 
           const grouped = rows.reduce((acc, row) => {
             const parentId = row[column]
             if (parentId == null) return acc
             const key = String(parentId)
             acc[key] = acc[key] || []
-            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) })
+            acc[key].push({ type: targetDescriptor.resource, id: getLogicalResourceId(row, targetDescriptor) })
             return acc
           }, {})
 
@@ -1447,18 +1713,26 @@ export const RestApiAnyapiKnexPlugin = {
               .filter((value) => value !== null),
           ]))
 
-          const rows = await db(targetDescriptor.canonical.tableName)
+          let query = db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
             .where(polyInfo.typeColumn, descriptor.resource)
             .whereIn(polyInfo.idColumn, queryIds)
+          const scopedQueryState = await applyTargetScopeFilters({
+            query,
+            resourceName: targetDescriptor.resource,
+            tableName: targetDescriptor.canonical.tableName,
+            context
+          })
+          query = scopedQueryState.query
+          const rows = await query
 
           const grouped = rows.reduce((acc, row) => {
             const parentId = row[polyInfo.idColumn]
             if (parentId == null) return acc
             const key = String(parentId)
             acc[key] = acc[key] || []
-            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) })
+            acc[key].push({ type: targetDescriptor.resource, id: getLogicalResourceId(row, targetDescriptor) })
             return acc
           }, {})
 
@@ -1479,7 +1753,7 @@ export const RestApiAnyapiKnexPlugin = {
       const db = context.db || context.transaction || api.knex.instance
       const parentIds = resources.map((resource) => resource.id)
 
-      for (const [relName, relInfo] of manyEntries) {
+      for (const [relName] of manyEntries) {
         const info = await getManyToManyInfo(descriptor.resource, relName)
         if (!info) continue
         const rows = await fetchLinksForParents({
@@ -1512,6 +1786,7 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptor = await getDescriptor(scopeName)
       const { canonical } = descriptor
       const id = context.id
+      const logicalIdColumn = getLogicalResourceIdColumn(descriptor)
       const scope = api.resources?.[scopeName]
 
       let fieldSelectionInfo = null
@@ -1522,18 +1797,39 @@ export const RestApiAnyapiKnexPlugin = {
         context.computedDependencies = []
       }
 
-      const row = await context.db(canonical.tableName)
-        .where('id', id)
+      let query = context.db(canonical.tableName)
+        .where(logicalIdColumn, id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .first()
+
+      if (scope && fieldSelectionInfo) {
+        const selectionState = await applyFieldSelectionToQuery({
+          query,
+          scope,
+          fieldSelectionInfo,
+          tableName: canonical.tableName,
+          useTablePrefix: false,
+          storageAdapter,
+          db: context.db,
+          context,
+          scopeName
+        })
+        query = selectionState.query
+      }
+
+      const row = await query.first()
 
       if (!row) return null
 
-      const record = translateRecordFromStorage(row, descriptor)
+      const record = translateCanonicalRecordFromStorage(
+        row,
+        descriptor,
+        { allowedExtraFields: getAllowedQueryFieldNames(scopeName) }
+      )
+      const resourceId = getLogicalResourceId(row, descriptor)
       const data = {
         type: descriptor.resource,
-        id: String(row.id),
+        id: resourceId,
         attributes: record.attributes,
       }
 
@@ -1565,24 +1861,20 @@ export const RestApiAnyapiKnexPlugin = {
       }
 
       if (scope) {
-        data.links = data.links || {}
-        data.links.self = buildResourceUrl(context, scope, scopeName, data.id)
-        response.links = {
-          self: data.links.self,
-        }
+        decorateResourceLinks({ resource: data, scope, scopeName, context })
+        response.links = { self: data.links.self }
       }
 
       if (included.length > 0) {
         for (const includeResource of included) {
           const targetScope = api.resources?.[includeResource.type]
           if (!targetScope) continue
-          includeResource.links = includeResource.links || {}
-          includeResource.links.self = buildResourceUrl(
+          decorateResourceLinks({
+            resource: includeResource,
+            scope: targetScope,
+            scopeName: includeResource.type,
             context,
-            targetScope,
-            includeResource.type,
-            includeResource.id
-          )
+          })
         }
       }
 
@@ -1592,10 +1884,11 @@ export const RestApiAnyapiKnexPlugin = {
     const rehydrateSchemaInfo = async (scopeName) => {
       const scope = api.resources?.[scopeName] || scopes?.[scopeName] || {}
       const storedOptions = scopeOptionsRegistry.get(scopeName) || {}
+      const rawSchema = scope.scopeOptions?.schema || storedOptions.schema || {}
 
       if (!scope.scopeOptions) {
         scope.scopeOptions = {
-          schema: storedOptions.schema || {},
+          schema: rawSchema,
           relationships: storedOptions.relationships || {},
           searchSchema: storedOptions.searchSchema || null,
           tableName: storedOptions.tableName || scopeName,
@@ -1611,7 +1904,6 @@ export const RestApiAnyapiKnexPlugin = {
 
       const mergedSchema = { ...(existingInfo.schemaInstance?.structure || {}) }
       const computed = { ...(existingInfo.computed || {}) }
-
       for (const [fieldName, definition] of Object.entries(descriptor.schema || {})) {
         if (definition?.computed) {
           if (!computed[fieldName]) {
@@ -1699,53 +1991,15 @@ export const RestApiAnyapiKnexPlugin = {
       return { resourceToTableName, tableNameToResource }
     }
 
-    const translateSelectFieldsForAdapter = (fields, adapter) => {
-      if (!adapter || !fields) return fields
-
-      return fields.map((field) => {
-        if (typeof field !== 'string') return field
-
-        if (field === '*') return '*'
+    const queryHookDependencies = { log, scopes: api.resources, knex, getStorageAdapter: getScopeStorageAdapter }
 
-        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 translated = adapter.translateColumn(field)
-        return translated || field
-      })
+    const applyBuiltInAnyApiQueryFilters = async (context) => {
+      const hookParams = { context }
+      await polymorphicFiltersHook(hookParams, queryHookDependencies)
+      await crossTableFiltersHook(hookParams, queryHookDependencies)
+      await basicFiltersHook(hookParams, queryHookDependencies)
     }
 
-    const scopesProxy = new Proxy({}, {
-      get (_target, prop) {
-        if (typeof prop !== 'string') {
-          return undefined
-        }
-        const resource = api.resources?.[prop]
-        if (resource?.vars?.schemaInfo) {
-          return resource
-        }
-        return scopes?.[prop]
-      },
-    })
-
-    const queryHookDependencies = { log, scopes: scopesProxy, knex, getStorageAdapter: getScopeStorageAdapter }
-
-    addHook('knexQueryFiltering', 'polymorphicFiltersHook', {}, async (hookParams) =>
-      polymorphicFiltersHook(hookParams, queryHookDependencies)
-    )
-
-    addHook('knexQueryFiltering', 'crossTableFiltersHook', {}, async (hookParams) =>
-      crossTableFiltersHook(hookParams, queryHookDependencies)
-    )
-
-    addHook('knexQueryFiltering', 'basicFiltersHook', {}, async (hookParams) =>
-      basicFiltersHook(hookParams, queryHookDependencies)
-    )
-
     helpers.dataQuery = async ({ scopeName, context, runHooks }) => {
       const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
@@ -1801,6 +2055,8 @@ export const RestApiAnyapiKnexPlugin = {
         storageAdapter,
       }
 
+      await applyBuiltInAnyApiQueryFilters(context)
+
       if (runHooks) {
         await runHooks('knexQueryFiltering')
       }
@@ -1809,16 +2065,29 @@ export const RestApiAnyapiKnexPlugin = {
 
       const countQuery = queryBuilder.clone()
 
+      let selectionState = { query: queryBuilder, queryFieldRuntimeByField: new Map() }
+      if (scope && fieldSelectionInfo) {
+        selectionState = await applyFieldSelectionToQuery({
+          query: queryBuilder,
+          scope,
+          fieldSelectionInfo,
+          tableName: adapter.tableAlias,
+          useTablePrefix: false,
+          storageAdapter,
+          db,
+          context,
+          scopeName
+        })
+      }
+
       const sortDescriptors = applySortingToQuery({
-        query: queryBuilder,
+        query: selectionState.query,
         sort: queryParams.sort,
         descriptor,
         scope,
+        queryFieldRuntimeByField: selectionState.queryFieldRuntimeByField
       })
 
-      if (queryParams?.page?.after) {
-      }
-
       const paginationInfo = applyPaginationToQuery({
         query: queryBuilder,
         scope,
@@ -1827,14 +2096,6 @@ export const RestApiAnyapiKnexPlugin = {
         adapter,
       })
 
-      if (queryParams?.page?.after) {
-      }
-
-      if (fieldSelectionInfo && fieldSelectionInfo.fieldsToSelect && fieldSelectionInfo.fieldsToSelect.length > 0) {
-        const translatedSelect = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, adapter)
-        queryBuilder.select(translatedSelect)
-      }
-
       let rows = await queryBuilder
       let cursorRecords = null
       let hasMore = false
@@ -1845,7 +2106,9 @@ export const RestApiAnyapiKnexPlugin = {
           const record = {}
           for (const descriptorEntry of cursorDescriptors) {
             if (descriptorEntry.field === 'id') {
-              record.id = row.id
+              record.id = getLogicalResourceId(row, descriptor)
+            } else if (descriptorEntry.queryFieldRuntime) {
+              record[descriptorEntry.field] = row[descriptorEntry.field]
             } else if (descriptorEntry.column) {
               record[descriptorEntry.field] = row[descriptorEntry.column]
             }
@@ -1861,10 +2124,15 @@ export const RestApiAnyapiKnexPlugin = {
       }
 
       const data = rows.map((row) => {
-        const translated = translateRecordFromStorage(row, descriptor)
+        const translated = translateCanonicalRecordFromStorage(
+          row,
+          descriptor,
+          { allowedExtraFields: getAllowedQueryFieldNames(scopeName) }
+        )
+        const resourceId = getLogicalResourceId(row, descriptor)
         const resource = {
           type: descriptor.resource,
-          id: String(row.id),
+          id: resourceId,
           attributes: translated.attributes,
         }
         if (translated.relationships && Object.keys(translated.relationships).length > 0) {
@@ -1872,8 +2140,7 @@ export const RestApiAnyapiKnexPlugin = {
         }
         const resourceScope = scope
         if (resourceScope) {
-          resource.links = resource.links || {}
-          resource.links.self = buildResourceUrl(context, resourceScope, scopeName, resource.id)
+          decorateResourceLinks({ resource, scope: resourceScope, scopeName, context })
         }
         if (fieldSelectionInfo?.computedDependencies?.length) {
           resource.__$jsonrestapi_computed_deps$__ = fieldSelectionInfo.computedDependencies
@@ -1904,6 +2171,19 @@ export const RestApiAnyapiKnexPlugin = {
         response.included = included
       }
 
+      if (included.length > 0) {
+        for (const includeResource of included) {
+          const targetScope = api.resources?.[includeResource.type]
+          if (!targetScope) continue
+          decorateResourceLinks({
+            resource: includeResource,
+            scope: targetScope,
+            scopeName: includeResource.type,
+            context,
+          })
+        }
+      }
+
       context.returnMeta = context.returnMeta || {}
       context.returnMeta.queryString = buildQueryString(queryParams)
       delete context.returnMeta.paginationMeta
@@ -2194,64 +2474,3 @@ export const RestApiAnyapiKnexPlugin = {
     })
   },
 }
-
-const translateAttributesForStorage = (attributes, descriptor) => {
-  const row = {}
-  for (const [fieldName, value] of Object.entries(attributes)) {
-    const slot = descriptor.fields[fieldName]
-    if (!slot) continue
-
-    if (slot.slotType === 'belongsTo') {
-      row[slot.slot] = value == null ? null : String(value)
-    } else {
-      row[slot.slot] = value
-    }
-
-    if (slot.slotType === 'belongsTo') {
-      const alias = slot.alias || descriptor.fields[fieldName]?.alias
-      const belongsToInfo = alias ? descriptor.belongsTo?.[alias] : null
-      if (belongsToInfo) {
-        row[belongsToInfo.typeColumn] = value == null ? null : belongsToInfo.target
-      }
-    }
-  }
-  return row
-}
-
-const translateRecordFromStorage = (row, descriptor) => {
-  const attributes = {}
-  for (const [slot, logical] of Object.entries(descriptor.reverseAttributes)) {
-    if (slot in row) {
-      attributes[logical] = row[slot]
-    }
-  }
-
-  const relationships = {}
-  for (const [alias, info] of Object.entries(descriptor.belongsTo || {})) {
-    const idValue = row[info.idColumn]
-    const relationshipData = idValue == null
-      ? null
-      : { type: info.target, id: String(idValue) }
-
-    relationships[alias] = { data: relationshipData }
-  }
-
-  for (const [alias, info] of Object.entries(descriptor.polymorphicBelongsTo || {})) {
-    const typeValue = info.typeColumn ? row[info.typeColumn] : null
-    const idValue = info.idColumn ? row[info.idColumn] : null
-
-    let relationshipData = null
-    if (typeValue != null && idValue != null) {
-      relationshipData = {
-        type: String(typeValue),
-        id: String(idValue),
-      }
-    } else if (typeValue == null && idValue == null) {
-      relationshipData = null
-    }
-
-    relationships[alias] = { data: relationshipData }
-  }
-
-  return { attributes, relationships }
-}