json-rest-api 1.0.23 → 1.0.25

package/plugins/core/lib/querying-writing/relationship-contracts.js

@@ -0,0 +1,56 @@
+import { RestApiValidationError } from '../../../../lib/rest-api-errors.js'
+
+export function getRelationshipCardinality (relDef) {
+  if (!relDef) return null
+
+  if (
+    relDef.belongsTo ||
+    relDef.belongsToPolymorphic ||
+    relDef.type === 'hasOne'
+  ) {
+    return 'one'
+  }
+
+  if (relDef.type === 'hasMany' || relDef.type === 'manyToMany') {
+    return 'many'
+  }
+
+  return null
+}
+
+export function validateRelationshipDataCardinality ({
+  relationshipName,
+  relDef,
+  data,
+  fieldPath = `data.relationships.${relationshipName}.data`
+}) {
+  const cardinality = getRelationshipCardinality(relDef)
+
+  if (cardinality === 'one' && Array.isArray(data)) {
+    throw new RestApiValidationError(
+      `Relationship '${relationshipName}' expects a single resource identifier or null`,
+      {
+        fields: [fieldPath],
+        violations: [{
+          field: fieldPath,
+          rule: 'relationship_cardinality',
+          message: 'Expected a single resource identifier or null'
+        }]
+      }
+    )
+  }
+
+  if (cardinality === 'many' && !Array.isArray(data)) {
+    throw new RestApiValidationError(
+      `Relationship '${relationshipName}' expects an array of resource identifiers`,
+      {
+        fields: [fieldPath],
+        violations: [{
+          field: fieldPath,
+          rule: 'relationship_cardinality',
+          message: 'Expected an array of resource identifiers'
+        }]
+      }
+    )
+  }
+}

package/plugins/core/lib/querying-writing/request-contracts.js

@@ -1,5 +1,6 @@
 import { addType, addValidator, createSchema } from 'json-rest-schema'
 import { RestApiValidationError } from '../../../../lib/rest-api-errors.js'
+import { getRelationshipCardinality } from './relationship-contracts.js'
 
 function isPlainObject (value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
@@ -28,9 +29,20 @@ function buildResourceIdentifierTransportSchema (allowedTypes = null) {
   }
 }
 
-function buildRelationshipDataTransportSchema (allowedTypes = null) {
+function buildRelationshipDataTransportSchema (allowedTypes = null, cardinality = null) {
   const identifierSchema = buildResourceIdentifierTransportSchema(allowedTypes)
 
+  if (cardinality === 'one') {
+    return identifierSchema
+  }
+
+  if (cardinality === 'many') {
+    return {
+      type: 'array',
+      items: identifierSchema
+    }
+  }
+
   return {
     anyOf: [
       identifierSchema,
@@ -156,16 +168,31 @@ function installRequestContractSupport () {
     const allowedTypes = Array.isArray(context.definition.allowedTypes)
       ? context.definition.allowedTypes
       : null
+    const cardinality = context.definition.cardinality || null
 
     if (Array.isArray(context.value)) {
+      if (cardinality === 'one') {
+        context.throwParamError(
+          'INVALID_RELATIONSHIP_CARDINALITY',
+          'Relationship data must be a single resource identifier or null.'
+        )
+      }
       context.value.forEach((entry) => validateResourceIdentifierValue(entry, context, allowedTypes))
       return context.value
     }
 
+    if (cardinality === 'many') {
+      context.throwParamError(
+        'INVALID_RELATIONSHIP_CARDINALITY',
+        'Relationship data must be an array of resource identifiers.'
+      )
+    }
+
     return validateResourceIdentifierValue(context.value, context, allowedTypes)
   }
   jsonApiRelationshipDataType.toJsonSchema = ({ definition }) => buildRelationshipDataTransportSchema(
-    Array.isArray(definition.allowedTypes) ? definition.allowedTypes : null
+    Array.isArray(definition.allowedTypes) ? definition.allowedTypes : null,
+    definition.cardinality || null
   )
   addType('jsonApiRelationshipData', jsonApiRelationshipDataType)
 
@@ -379,6 +406,7 @@ function buildRelationshipStructure (schemaInfo = {}) {
           type: 'jsonApiRelationshipData',
           required: true,
           nullable: true,
+          cardinality: 'one',
           allowedTypes: [fieldDef.belongsTo]
         }
       })
@@ -386,13 +414,15 @@ function buildRelationshipStructure (schemaInfo = {}) {
   }
 
   for (const [relName, relDef] of Object.entries(schemaRelationships)) {
+    const cardinality = getRelationshipCardinality(relDef)
     relationshipStructure[relName] = {
       type: 'object',
       schema: createSchema({
         data: {
           type: 'jsonApiRelationshipData',
           required: true,
-          nullable: true,
+          nullable: cardinality === 'one',
+          cardinality,
           allowedTypes: resolveRelationshipAllowedTypes(relName, relDef)
         }
       })
@@ -520,6 +550,22 @@ function buildQueryRequestContract ({ includeDepthLimit, sortableFields, searchS
   }
 }
 
+function buildRelationshipRouteBodyContract (operation) {
+  const isPatch = operation === 'patchRelationship'
+
+  return {
+    schema: createSchema({
+      data: {
+        type: 'jsonApiRelationshipData',
+        required: true,
+        nullable: isPatch,
+        cardinality: isPatch ? null : 'many'
+      }
+    }),
+    mode: 'replace'
+  }
+}
+
 function buildRequestContracts ({ scopeName, schemaInfo, includeDepthLimit, sortableFields }) {
   return {
     post: buildWriteDocumentContract(scopeName, schemaInfo, 'post'),
@@ -530,7 +576,10 @@ function buildRequestContracts ({ scopeName, schemaInfo, includeDepthLimit, sort
       includeDepthLimit,
       sortableFields,
       searchSchemaInstance: schemaInfo.searchSchemaInstance
-    })
+    }),
+    postRelationship: buildRelationshipRouteBodyContract('postRelationship'),
+    patchRelationship: buildRelationshipRouteBodyContract('patchRelationship'),
+    deleteRelationship: buildRelationshipRouteBodyContract('deleteRelationship')
   }
 }
 

package/plugins/core/lib/querying-writing/resource-id-normalization.js

@@ -0,0 +1,131 @@
+import {
+  RestApiResourceError,
+  RestApiValidationError
+} from '../../../../lib/rest-api-errors.js'
+
+export function defaultNormalizeResourceId (value) {
+  if (value === null || value === undefined) {
+    return null
+  }
+
+  if (typeof value === 'string') {
+    const normalized = value.trim()
+    return normalized || null
+  }
+
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? String(value) : null
+  }
+
+  if (typeof value === 'bigint') {
+    return String(value)
+  }
+
+  const normalized = String(value).trim()
+  return normalized || null
+}
+
+export function resolveResourceIdNormalizer ({ scopeOptions = null, vars = null } = {}) {
+  if (typeof scopeOptions?.normalizeId === 'function') {
+    return scopeOptions.normalizeId
+  }
+
+  if (typeof vars?.normalizeId === 'function') {
+    return vars.normalizeId
+  }
+
+  return defaultNormalizeResourceId
+}
+
+export function normalizeResourceId (value, options = {}) {
+  const normalizer = resolveResourceIdNormalizer(options)
+  return defaultNormalizeResourceId(normalizer(value))
+}
+
+export function requireExistingResourceId (value, {
+  scopeOptions = null,
+  vars = null,
+  scopeName = ''
+} = {}) {
+  const normalizedId = normalizeResourceId(value, { scopeOptions, vars })
+  if (normalizedId) {
+    return normalizedId
+  }
+
+  throw new RestApiResourceError(
+    'Resource not found',
+    {
+      subtype: 'not_found',
+      resourceType: scopeName,
+      resourceId: value == null ? null : String(value)
+    }
+  )
+}
+
+export function requireDocumentResourceId (value, {
+  scopeOptions = null,
+  vars = null
+} = {}) {
+  const normalizedId = normalizeResourceId(value, { scopeOptions, vars })
+  if (normalizedId) {
+    return normalizedId
+  }
+
+  throw new RestApiValidationError(
+    'Resource document id is invalid',
+    {
+      fields: ['data.id'],
+      violations: [{
+        field: 'data.id',
+        rule: 'invalid_resource_id',
+        message: 'Resource document id must normalize to a non-empty value.'
+      }]
+    }
+  )
+}
+
+function resolveResourceNormalizationOptions (resourceType, { api } = {}) {
+  const scope = api?.resources?.[resourceType]
+  return {
+    scopeOptions: scope?.scopeOptions || scope?._scopeOptions || null,
+    vars: scope?.vars || null,
+    scopeName: resourceType
+  }
+}
+
+export function requireReferencedResourceId (resourceType, value, { api } = {}) {
+  return requireExistingResourceId(
+    value,
+    resolveResourceNormalizationOptions(resourceType, { api })
+  )
+}
+
+function normalizeRelationshipIdentifier (identifier, { api } = {}) {
+  if (!identifier || typeof identifier !== 'object' || Array.isArray(identifier)) {
+    return identifier
+  }
+
+  const type = typeof identifier.type === 'string' ? identifier.type : ''
+  if (!type || !Object.hasOwn(identifier, 'id')) {
+    return {
+      ...identifier
+    }
+  }
+
+  return {
+    ...identifier,
+    id: requireReferencedResourceId(type, identifier.id, { api })
+  }
+}
+
+export function normalizeRelationshipIdentifiers (relationshipData, { api } = {}) {
+  if (Array.isArray(relationshipData)) {
+    return relationshipData.map((identifier) => normalizeRelationshipIdentifier(identifier, { api }))
+  }
+
+  if (relationshipData == null) {
+    return relationshipData
+  }
+
+  return normalizeRelationshipIdentifier(relationshipData, { api })
+}

package/plugins/core/lib/querying-writing/return-record-settings.js

@@ -0,0 +1,47 @@
+const RETURN_RECORD_METHODS = ['post', 'put', 'patch']
+const RETURN_RECORD_MODES = ['no', 'minimal', 'full']
+
+export function normalizeReturnRecordMode (value, defaultValue = 'no') {
+  if (value === true) return 'full'
+  if (value === false) return 'no'
+  if (RETURN_RECORD_MODES.includes(value)) return value
+
+  if (defaultValue === true) return 'full'
+  if (defaultValue === false) return 'no'
+  if (RETURN_RECORD_MODES.includes(defaultValue)) return defaultValue
+
+  return 'no'
+}
+
+function defaultModeForMethod (defaultValue, method) {
+  if (defaultValue && typeof defaultValue === 'object' && !Array.isArray(defaultValue)) {
+    return normalizeReturnRecordMode(defaultValue[method], 'no')
+  }
+
+  return normalizeReturnRecordMode(defaultValue, 'no')
+}
+
+export function normalizeReturnRecordSetting (value, defaultValue = 'no') {
+  if (value === undefined) {
+    return Object.fromEntries(
+      RETURN_RECORD_METHODS.map(method => [
+        method,
+        defaultModeForMethod(defaultValue, method)
+      ])
+    )
+  }
+
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return Object.fromEntries(
+      RETURN_RECORD_METHODS.map(method => [
+        method,
+        normalizeReturnRecordMode(value[method], defaultModeForMethod(defaultValue, method))
+      ])
+    )
+  }
+
+  const normalized = normalizeReturnRecordMode(value, defaultModeForMethod(defaultValue, 'post'))
+  return Object.fromEntries(
+    RETURN_RECORD_METHODS.map(method => [method, normalized])
+  )
+}

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

@@ -9,8 +9,6 @@
  * - Detecting circular dependencies in field definitions
  */
 
-import { RestApiValidationError } from '../../../../lib/rest-api-errors.js'
-
 /**
  * Marks all fields in a searchSchema as indexed for database optimization
  *
@@ -98,6 +96,36 @@ export function ensureSearchFieldsAreIndexed (searchSchema) {
   })
 }
 
+function createRelationshipSearchEntries (fieldName, fieldDef, searchEntry) {
+  if (!fieldDef?.belongsTo || !fieldDef?.as) {
+    return [[fieldName, searchEntry]]
+  }
+
+  const relationshipEntry = {
+    ...searchEntry,
+    actualField: fieldName,
+    isRelationship: true,
+    targetResource: fieldDef.belongsTo
+  }
+
+  return [
+    [fieldDef.as, relationshipEntry],
+    [fieldName, {
+      ...relationshipEntry
+    }]
+  ]
+}
+
+function registerSearchEntries (searchSchema, entries = []) {
+  for (const [searchFieldName, searchEntry] of entries) {
+    if (!searchFieldName || searchSchema[searchFieldName]) {
+      continue
+    }
+
+    searchSchema[searchFieldName] = searchEntry
+  }
+}
+
 /**
  * Generates complete searchSchema by merging schema search definitions with explicit searchSchema
  *
@@ -243,31 +271,12 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
 
     if (effectiveSearch) {
       if (effectiveSearch === true) {
-        // For belongsTo relationships, use the relationship name (as property) instead of the field name
-        const searchFieldName = (fieldDef.belongsTo && fieldDef.as) ? fieldDef.as : fieldName
-
-        // Check if field already exists in explicit searchSchema
-        if (searchSchema[searchFieldName]) {
-          // Skip - explicit searchSchema takes precedence
-          // This allows searchSchema to override fields marked with search:true
-          return
-        }
-
         // Simple boolean - copy entire field definition (except search)
         const { search, ...fieldDefWithoutSearch } = fieldDef
-        const searchEntry = {
+        registerSearchEntries(searchSchema, createRelationshipSearchEntries(fieldName, fieldDef, {
           ...fieldDefWithoutSearch,
           // Do not set filterOperator here; centralized resolver will apply sensible defaults
-        }
-
-        // For belongsTo relationships, add metadata to map back to the actual field
-        if (fieldDef.belongsTo && fieldDef.as) {
-          searchEntry.actualField = fieldName  // Maps to the DB column
-          searchEntry.isRelationship = true
-          searchEntry.targetResource = fieldDef.belongsTo
-        }
-
-        searchSchema[searchFieldName] = searchEntry
+        }))
       } else if (typeof effectiveSearch === 'object') {
         // Check if search defines multiple filter fields
         const hasNestedFilters = Object.values(effectiveSearch).some(
@@ -290,29 +299,11 @@ export const generateSearchSchemaFromSchema = (schema, explicitSearchSchema) =>
             }
           })
         } else {
-          // For belongsTo relationships, use the relationship name (as property) instead of the field name
-          const searchFieldName = (fieldDef.belongsTo && fieldDef.as) ? fieldDef.as : fieldName
-
-          // Check if field already exists in explicit searchSchema
-          if (searchSchema[searchFieldName]) {
-            // Skip - explicit searchSchema takes precedence
-            return
-          }
-
           // Single filter with config
-          const searchEntry = {
+          registerSearchEntries(searchSchema, createRelationshipSearchEntries(fieldName, fieldDef, {
             type: fieldDef.type,
             ...effectiveSearch
-          }
-
-          // For belongsTo relationships, add metadata to map back to the actual field
-          if (fieldDef.belongsTo && fieldDef.as) {
-            searchEntry.actualField = fieldName  // Maps to the DB column
-            searchEntry.isRelationship = true
-            searchEntry.targetResource = fieldDef.belongsTo
-          }
-
-          searchSchema[searchFieldName] = searchEntry
+          }))
         }
       }
     }

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

@@ -280,22 +280,15 @@ export const transformSimplifiedToJsonApi = (scope, deps) => {
         relationshipsData[relName] = {
           data: value.map(relId => ({ type: targetType, id: String(relId) }))
         }
-      }
-      // Handle hasOne relationships
-      else if (relConfig.type === 'hasOne' && value !== undefined) {
+      } else if (relConfig.type === 'hasOne' && value !== undefined) {
         relationshipsData[relName] = {
           data: value ? { type: relConfig.target, id: String(value) } : null
         }
-      }
-      // Handle single belongsTo relationships if they were also defined in 'relationships'
-      // (though typically they are defined in schema.belongsTo)
-      else if (relConfig.belongsTo && value !== undefined) {
+      } else if (relConfig.belongsTo && value !== undefined) {
         relationshipsData[relName] = {
           data: value ? { type: relConfig.belongsTo, id: String(value) } : null
         }
-      }
-      // Handle polymorphic belongsTo relationships with minimal object format
-      else if (relConfig.belongsToPolymorphic && value !== undefined) {
+      } else if (relConfig.belongsToPolymorphic && value !== undefined) {
         if (value === null) {
           relationshipsData[relName] = { data: null }
         } else if (typeof value === 'object' && value !== null && value.id && value._type) {
@@ -780,7 +773,7 @@ export const transformSingleJsonApiToSimplified = (scope, deps) => {
       const schemaEntry = Object.entries(schema).find(([_, def]) => def.as === relName)
 
       if (schemaEntry) {
-        const [fieldName, fieldDef] = schemaEntry
+        const [, fieldDef] = schemaEntry
         if (fieldDef.belongsTo && relData.data) {
           // Create minimal relationship object (no more foreign key field)
           simplified[relName] = { id: relData.data.id }

package/plugins/core/lib/storage/canonical-storage-mapping.js

@@ -23,9 +23,29 @@ export const translateCanonicalAttributesForStorage = (attributes = {}, descript
   return row
 }
 
+export const getCanonicalResourceIdColumn = (descriptor = {}) => (
+  descriptor?.canonical?.logicalIdColumn || 'logical_id'
+)
+
+export const getCanonicalResourceId = (row = {}, descriptor = {}) => {
+  const logicalIdColumn = getCanonicalResourceIdColumn(descriptor)
+  const logicalId = row?.[logicalIdColumn]
+
+  if (logicalId !== undefined && logicalId !== null) {
+    return String(logicalId)
+  }
+
+  if (row?.id !== undefined && row?.id !== null) {
+    return String(row.id)
+  }
+
+  return null
+}
+
 export const translateCanonicalRecordFromStorage = (row = {}, descriptor = {}, options = {}) => {
   const attributes = {}
-  const consumedColumns = new Set(['id'])
+  const logicalIdColumn = getCanonicalResourceIdColumn(descriptor)
+  const consumedColumns = new Set(['id', logicalIdColumn])
   const allowedExtraFields = new Set(options.allowedExtraFields || [])
 
   for (const [slot, logical] of Object.entries(descriptor.reverseAttributes || {})) {
@@ -96,8 +116,9 @@ export const translateCanonicalRecordFromStorage = (row = {}, descriptor = {}, o
 export const getCanonicalFieldValue = (row, descriptor = {}, fieldName) => {
   if (!row || !fieldName) return undefined
 
-  if (fieldName === 'id') {
-    return row.id
+  const idProperty = descriptor.idProperty || 'id'
+  if (fieldName === 'id' || fieldName === idProperty) {
+    return getCanonicalResourceId(row, descriptor)
   }
 
   const fieldInfo = descriptor.fields?.[fieldName]

package/plugins/core/lib/storage/storage-adapter.js

@@ -6,8 +6,10 @@ import {
 } from './storage-mapping.js'
 import {
   getCanonicalFieldValue,
+  getCanonicalResourceIdColumn,
   translateCanonicalAttributesForStorage,
 } from './canonical-storage-mapping.js'
+import { normalizeDateValue } from '../querying-writing/database-value-normalizers.js'
 
 const passthrough = (value) => value
 const identityTranslate = (_field, value) => value
@@ -33,6 +35,54 @@ const normalizeBelongsToValue = (value) => {
   return String(value)
 }
 
+const normalizeBooleanValue = (value) => {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase()
+    if (normalized === 'true' || normalized === '1') return true
+    if (normalized === 'false' || normalized === '0') return false
+  }
+  if (typeof value === 'number') {
+    if (value === 1) return true
+    if (value === 0) return false
+  }
+  return Boolean(value)
+}
+
+const normalizeFilterValueForDefinition = (value, definition = {}, { isRelationship = false } = {}) => {
+  if (value === null || value === undefined) return value
+  if (Array.isArray(value)) {
+    return normalizeArray(
+      value,
+      (entry) => normalizeFilterValueForDefinition(entry, definition, { isRelationship })
+    )
+  }
+
+  if (isRelationship) {
+    return normalizeBelongsToValue(value)
+  }
+
+  const type = definition?.type || definition?.dataType
+  if (!type) {
+    return value
+  }
+
+  if (['number', 'integer', 'float', 'decimal'].includes(type)) {
+    const numeric = Number(value)
+    return Number.isNaN(numeric) ? value : numeric
+  }
+
+  if (type === 'boolean') {
+    return normalizeBooleanValue(value)
+  }
+
+  if (['date', 'dateTime', 'time'].includes(type)) {
+    return normalizeDateValue(value, type)
+  }
+
+  return value
+}
+
 const translateSourceColumn = (source, adapter) => {
   if (!adapter || source === '*') return source
   return adapter.translateColumn(source) || source
@@ -123,13 +173,24 @@ const createLegacyAdapter = ({ knex, schemaInfo }) => {
   const translateColumn = (field) => getStorageColumn(schemaInfo, field)
   const toStorageRow = (attributes, options = {}) => translateAttributesForStorage(attributes, schemaInfo, options)
   const getFieldValue = (record, fieldName) => getLegacyFieldValue(record, schemaInfo, fieldName)
+  const translateFilterValue = (field, value) => {
+    const searchField = schemaInfo.searchSchemaStructure?.[field]
+    const schemaField = schemaInfo.schemaStructure?.[field]
+    const definition = searchField || schemaField || {}
+    const isRelationship = Boolean(
+      searchField?.isRelationship ||
+      schemaField?.belongsTo ||
+      schemaField?.belongsToPolymorphic
+    )
+    return normalizeFilterValueForDefinition(value, definition, { isRelationship })
+  }
 
   return baseAdapter({
     knex,
     tableName,
     idColumn,
     translateColumn,
-    translateFilterValue: identityTranslate,
+    translateFilterValue,
     applyResourceScope: identityScope,
     toStorageRow,
     getFieldValue,
@@ -143,10 +204,15 @@ const createCanonicalAdapter = ({ knex, schemaInfo }) => {
   const canonicalFieldMap = descriptor.canonicalFieldMap || {}
   const fieldsInfo = descriptor.fields || {}
   const belongsToInfo = descriptor.belongsTo || {}
+  const idProperty = schemaInfo.idProperty || descriptor.idProperty || 'id'
+  const isLogicalIdField = (field) => field === 'id' || field === idProperty
+  const descriptorWithIdProperty = descriptor.idProperty === idProperty
+    ? descriptor
+    : { ...descriptor, idProperty }
 
   const translateColumn = (field) => {
     if (!field) return field
-    if (field === 'id') return 'id'
+    if (isLogicalIdField(field)) return getCanonicalResourceIdColumn(descriptor)
 
     const canonicalEntry = canonicalFieldMap[field]
     if (typeof canonicalEntry === 'string') {
@@ -182,8 +248,6 @@ const createCanonicalAdapter = ({ knex, schemaInfo }) => {
   }
 
   const translateFilterValue = (field, value) => {
-    if (value === null || value === undefined) return value
-
     const searchField = schemaInfo.searchSchemaStructure?.[field]
     const schemaField = schemaInfo.schemaStructure?.[field]
     const isRelationship = Boolean(
@@ -191,15 +255,9 @@ const createCanonicalAdapter = ({ knex, schemaInfo }) => {
       schemaField?.belongsTo ||
       schemaField?.belongsToPolymorphic
     )
+    const definition = searchField || schemaField || {}
 
-    if (!isRelationship) {
-      if (Array.isArray(value)) {
-        return normalizeArray(value, passthrough)
-      }
-      return value
-    }
-
-    return normalizeBelongsToValue(value)
+    return normalizeFilterValueForDefinition(value, definition, { isRelationship })
   }
 
   const applyResourceScope = (query) => {
@@ -209,12 +267,16 @@ const createCanonicalAdapter = ({ knex, schemaInfo }) => {
   }
 
   const toStorageRow = (attributes) => translateCanonicalAttributesForStorage(attributes, descriptor)
-  const getFieldValue = (record, fieldName) => getCanonicalFieldValue(record, descriptor, fieldName)
+  const getFieldValue = (record, fieldName) => (
+    isLogicalIdField(fieldName)
+      ? getCanonicalFieldValue(record, descriptorWithIdProperty, fieldName)
+      : getCanonicalFieldValue(record, descriptor, fieldName)
+  )
 
   return baseAdapter({
     knex,
     tableName: canonical.tableName,
-    idColumn: 'id',
+    idColumn: getCanonicalResourceIdColumn(descriptor),
     translateColumn,
     translateFilterValue,
     applyResourceScope,