json-rest-api 1.0.23 → 1.0.25

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

@@ -8,9 +8,8 @@ import {
   generateKnexMigrationDiff
 } from './lib/dbTablesOperations.js'
 import { introspectKnexTableSnapshot } from './lib/dbIntrospection.js'
-import { applyFieldSelectionToQuery, buildFieldSelection, isNonDatabaseField } from './lib/querying-writing/knex-field-helpers.js'
-import { getForeignKeyFields } from './lib/querying-writing/field-utils.js'
-import { toJsonApiRecord, buildJsonApiResponse } from './lib/querying/knex-json-api-transformers-querying.js'
+import { applyFieldSelectionToQuery, buildFieldSelection } from './lib/querying-writing/knex-field-helpers.js'
+import { buildJsonApiResponse } from './lib/querying/knex-json-api-transformers-querying.js'
 import { processBelongsToRelationships } from './lib/writing/knex-json-api-transformers-writing.js'
 import { toJsonApiRecordWithBelongsTo } from './lib/querying-writing/knex-json-api-transformers.js'
 import { processIncludes } from './lib/querying/knex-process-includes.js'
@@ -39,6 +38,7 @@ import {
   parseSortEntry
 } from './lib/querying/query-field-sort-helpers.js'
 import { unwrapQueryBuilderState } from './lib/querying/query-builder-utils.js'
+import { serializeJsonApiQuery } from './lib/querying-writing/connectors-query-parser.js'
 
 export const RestApiKnexPlugin = {
   name: 'rest-api-knex',
@@ -46,9 +46,8 @@ export const RestApiKnexPlugin = {
 
   async install ({ helpers, vars, pluginOptions, api, log, scopes, addHook, addScopeMethod }) {
     // Try to import knex dynamically
-    let knexLib
     try {
-      knexLib = await import('knex')
+      await import('knex')
     } catch (e) {
       requirePackage('knex', 'rest-api-knex',
         'Knex.js is required for database operations. This is a peer dependency that allows you to control the version.')
@@ -100,6 +99,7 @@ export const RestApiKnexPlugin = {
 
       return {
         structure: filteredSchema,
+        storage: vars.schemaInfo?.storage,
         indexes: vars.schemaInfo?.indexes || [],
         foreignKeys: vars.schemaInfo?.foreignKeys || [],
         checkConstraints: vars.schemaInfo?.checkConstraints || []
@@ -457,7 +457,14 @@ export const RestApiKnexPlugin = {
      * @param {Object} params.context.db - Database connection (knex instance or transaction)
      * @returns {Promise<Object|null>} JSON:API formatted resource with belongsTo relationships, or null if not found
      */
-    helpers.dataGetMinimal = async ({ scopeName, context, runHooks, applyQueryFilters }) => {
+    helpers.dataGetMinimal = async ({
+      scopeName,
+      context,
+      runHooks,
+      applyQueryFilters,
+      filters = context.queryParams?.filters,
+      queryPurpose = 'single'
+    }) => {
       const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
         context.storageAdapter = storageAdapter
@@ -483,29 +490,37 @@ export const RestApiKnexPlugin = {
       if (typeof applyQueryFilters === 'function') {
         const scopedQueryState = await applyQueryFilters({
           query,
-          filters: context.queryParams?.filters,
+          filters,
           tableName,
           db,
           scopeName,
+          queryPurpose,
           storageAdapter
         })
         query = unwrapQueryBuilderState(scopedQueryState, query)
       } else if (runHooks) {
+        const previousKnexQuery = context.knexQuery
         context.knexQuery = {
           query,
-          filters: context.queryParams?.filters,
+          filters,
           schemaInfo: context.schemaInfo,
           scopeName,
           tableName,
           db,
+          queryPurpose,
           adapter: storageAdapter,
           storageAdapter,
         }
 
-        await runHooks('knexQueryFiltering')
-
-        if (context.knexQuery) {
-          delete context.knexQuery
+        try {
+          await runHooks('knexQueryFiltering')
+          query = context.knexQuery?.query || query
+        } finally {
+          if (previousKnexQuery === undefined) {
+            delete context.knexQuery
+          } else {
+            context.knexQuery = previousKnexQuery
+          }
         }
       }
 
@@ -621,7 +636,9 @@ export const RestApiKnexPlugin = {
           scopeName,
           tableName,
           db,
+          queryPurpose: 'collection',
           adapter: storageAdapter,
+          storageAdapter,
         }
 
         log.trace('[DATA-QUERY] Stored data in context', { hasStoredData: !!context.knexQuery, filters: queryParams.filters })
@@ -682,9 +699,7 @@ export const RestApiKnexPlugin = {
           query
             .limit(pageSize)
             .offset((pageNumber - 1) * pageSize)
-        }
-        // Cursor-based pagination
-        else if (queryParams.page.after || queryParams.page.before) {
+        } else if (queryParams.page.after || queryParams.page.before) {
           // Fetch one extra record to determine if there are more
           query.limit(pageSize + 1)
 
@@ -711,7 +726,13 @@ export const RestApiKnexPlugin = {
               sortDescriptors,
               cursorData,
               (direction) => (direction === 'DESC' ? '<' : '>'),
-              (builder, descriptor, operator, value) => builder.where(descriptor.column, operator, value),
+              (builder, descriptor, operator, value) => builder.where(
+                descriptor.column,
+                operator,
+                storageAdapter?.translateFilterValue
+                  ? storageAdapter.translateFilterValue(descriptor.field, value)
+                  : value
+              ),
               {
                 onMissingValue: (fieldName) => log.warn(`Cursor missing value for sort field: ${fieldName}`)
               }
@@ -739,15 +760,19 @@ export const RestApiKnexPlugin = {
               sortDescriptors,
               cursorData,
               (direction) => (direction === 'DESC' ? '>' : '<'),
-              (builder, descriptor, operator, value) => builder.where(descriptor.column, operator, value),
+              (builder, descriptor, operator, value) => builder.where(
+                descriptor.column,
+                operator,
+                storageAdapter?.translateFilterValue
+                  ? storageAdapter.translateFilterValue(descriptor.field, value)
+                  : value
+              ),
               {
                 onMissingValue: (fieldName) => log.warn(`Cursor missing value for sort field: ${fieldName}`)
               }
             )
           }
-        }
-        // Default pagination if only size is specified - treat as cursor-based for "load more"
-        else {
+        } else {
           // Fetch one extra to detect hasMore
           query.limit(pageSize + 1)
         }
@@ -760,38 +785,10 @@ export const RestApiKnexPlugin = {
       // Execute query
       const records = await query
 
-      // Store query string for response building
-      const queryParts = []
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          // Handle arrays (like sort, include)
-          if (value.length > 0) {
-            queryParts.push(`${key}=${value.map(v => encodeURIComponent(v)).join(',')}`)
-          }
-        } else if (typeof value === 'object' && value !== null) {
-          // Handle nested objects (like filters, fields, page)
-          Object.entries(value).forEach(([subKey, subValue]) => {
-            if (subValue !== undefined && subValue !== null) {
-              if (typeof subValue === 'object' && !Array.isArray(subValue)) {
-                // Handle deeply nested objects (like filters[country][code])
-                Object.entries(subValue).forEach(([subSubKey, subSubValue]) => {
-                  if (subSubValue !== undefined && subSubValue !== null) {
-                    queryParts.push(`${key}[${subKey}][${subSubKey}]=${encodeURIComponent(subSubValue)}`)
-                  }
-                })
-              } else {
-                queryParts.push(`${key}[${subKey}]=${encodeURIComponent(subValue)}`)
-              }
-            }
-          })
-        } else if (value !== undefined && value !== null) {
-          queryParts.push(`${key}=${encodeURIComponent(value)}`)
-        }
-      })
-
       // Initialize returnMeta namespace for thread-safe metadata
       context.returnMeta = context.returnMeta || {}
-      context.returnMeta.queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : ''
+      const queryString = serializeJsonApiQuery(queryParams)
+      context.returnMeta.queryString = queryString ? `?${queryString}` : ''
 
       // Execute count query for pagination if offset-based pagination is used
       if (queryParams.page?.number !== undefined || (queryParams.page?.size !== undefined && !queryParams.page?.after && !queryParams.page?.before)) {
@@ -801,28 +798,31 @@ export const RestApiKnexPlugin = {
         // Only execute count query if enabled
         if (scope.vars.enablePaginationCounts) {
           // Build count query with same filters as main query
-          const countQuery = db(tableName)
-
-          // Apply filters through hooks (same as main query)
-          if (queryParams.filters && Object.keys(queryParams.filters).length > 0) {
-            // Store query data in context for hooks
-            if (context) {
-              context.knexQuery = {
-                query: countQuery,
-                filters: queryParams.filters,
-                scopeName,
-                tableName,
-                schemaInfo,
-                db
-              }
-            }
+          let countQuery = db(tableName)
+
+          // Mandatory server-side filters must also run when the client supplied no filters.
+          // Otherwise pagination metadata can disclose or count rows excluded from the page.
+          const previousKnexQuery = context.knexQuery
+          context.knexQuery = {
+            query: countQuery,
+            filters: queryParams.filters,
+            scopeName,
+            tableName,
+            schemaInfo,
+            db,
+            queryPurpose: 'count',
+            adapter: storageAdapter,
+            storageAdapter
+          }
 
-            // Run the same filtering hooks
+          try {
             await runHooks('knexQueryFiltering')
-
-            // Clean up
-            if (context && context.knexQuery) {
+            countQuery = context.knexQuery?.query || countQuery
+          } finally {
+            if (previousKnexQuery === undefined) {
               delete context.knexQuery
+            } else {
+              context.knexQuery = previousKnexQuery
             }
           }
 
@@ -868,7 +868,9 @@ export const RestApiKnexPlugin = {
 
         const sortFields = sortDescriptors.map((descriptor) => descriptor.field)
 
-        context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields)
+        context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields, {
+          schemaInfo
+        })
         const urlPrefix = getUrlPrefix(context, scope)
         context.returnMeta.paginationLinks = generateCursorPaginationLinks(
           urlPrefix,
@@ -877,7 +879,10 @@ export const RestApiKnexPlugin = {
           records,
           pageSize,
           hasMore,
-          sortFields
+          sortFields,
+          {
+            schemaInfo
+          }
         )
       }
 
@@ -918,7 +923,6 @@ export const RestApiKnexPlugin = {
       if (storageAdapter) {
         context.storageAdapter = storageAdapter
       }
-      const scope = api.resources[scopeName]
       const tableName = storageAdapter?.getTableName?.() || context.schemaInfo.tableName
       const idProperty = storageAdapter?.getIdColumn?.() || context.schemaInfo.idProperty
       const db = context.db || api.knex.instance
@@ -943,12 +947,26 @@ export const RestApiKnexPlugin = {
         })
         : attributes
 
+      const explicitId = dbAttributes[idProperty] ?? inputRecord.data.id
+
       // Insert and get the new ID
       const result = await db(tableName).insert(dbAttributes).returning(idProperty)
 
-      // Extract the ID value (SQLite returns array of objects)
-      const id = result[0]?.[idProperty] || result[0]
-      return id
+      // Extract the ID value. Some dialects ignore .returning() for inserts and can
+      // yield 0 even when the caller explicitly supplied the primary key.
+      const returnedId = Array.isArray(result)
+        ? (result[0]?.[idProperty] ?? result[0])
+        : (result?.[idProperty] ?? result)
+
+      if (
+        explicitId !== undefined &&
+        explicitId !== null &&
+        (returnedId === undefined || returnedId === null || returnedId === 0 || returnedId === '0')
+      ) {
+        return explicitId
+      }
+
+      return returnedId
     }
 
     /**
@@ -1135,7 +1153,6 @@ export const RestApiKnexPlugin = {
       if (storageAdapter) {
         context.storageAdapter = storageAdapter
       }
-      const scope = api.resources[scopeName]
       const id = context.id
 
       const tableName = storageAdapter?.getTableName?.() || context.schemaInfo.tableName

package/plugins/core/rest-api-plugin-hooks/turn-scope-init-into-vars.js

@@ -1,3 +1,5 @@
+import { normalizeReturnRecordSetting } from '../lib/querying-writing/return-record-settings.js'
+
 export default async function turnScopeInitIntoVars ({ context, scopes, vars: apiVars }) {
   // Refer to the scope's vars
   const scope = scopes[context.scopeName]
@@ -19,11 +21,16 @@ export default async function turnScopeInitIntoVars ({ context, scopes, vars: ap
   if (typeof scopeOptions.simplifiedTransport !== 'undefined') vars.simplifiedTransport = scopeOptions.simplifiedTransport
 
   // Set returnRecord settings as scope vars
-  if (typeof scopeOptions.returnRecordApi !== 'undefined') vars.returnRecordApi = scopeOptions.returnRecordApi
-  if (typeof scopeOptions.returnRecordTransport !== 'undefined') vars.returnRecordTransport = scopeOptions.returnRecordTransport
+  if (typeof scopeOptions.returnRecordApi !== 'undefined') {
+    vars.returnRecordApi = normalizeReturnRecordSetting(scopeOptions.returnRecordApi, vars.returnRecordApi || 'full')
+  }
+  if (typeof scopeOptions.returnRecordTransport !== 'undefined') {
+    vars.returnRecordTransport = normalizeReturnRecordSetting(scopeOptions.returnRecordTransport, vars.returnRecordTransport || 'no')
+  }
 
   // Set idProperty as scope var
   if (typeof scopeOptions.idProperty !== 'undefined') vars.idProperty = scopeOptions.idProperty
+  if (typeof scopeOptions.normalizeId === 'function') vars.normalizeId = scopeOptions.normalizeId
 
   // Add validation for query limits
   if (vars.queryDefaultLimit && vars.queryMaxLimit) {

package/plugins/core/rest-api-plugin-methods/common.js

@@ -3,8 +3,18 @@ import {
   RestApiValidationError
 } from '../../../lib/rest-api-errors.js'
 import { transformSimplifiedToJsonApi } from '../lib/querying-writing/simplified-helpers.js'
+import { normalizeRelationshipIdentifiers } from '../lib/querying-writing/resource-id-normalization.js'
 import { createEnhancedLogger } from '../../../lib/enhanced-logger.js'
-import { unwrapQueryBuilderState } from '../lib/querying/query-builder-utils.js'
+import {
+  normalizeReturnRecordMode,
+  normalizeReturnRecordSetting
+} from '../lib/querying-writing/return-record-settings.js'
+import {
+  getRequestContracts,
+  validateRequestContractOrThrow
+} from '../lib/querying-writing/request-contracts.js'
+
+export { normalizeReturnRecordMode as normalizeReturnValue }
 
 /**
  * Gets an enhanced logger instance with full error details and stack traces
@@ -28,16 +38,6 @@ export const getEnhancedLogger = (log) => {
 export const cascadeConfig = (settingName, sources, defaultValue) =>
   sources.find(source => source?.[settingName] !== undefined)?.[settingName] ?? defaultValue
 
-/**
- * Normalizes return record settings to valid values
- * @param {string|boolean} value - The value to normalize
- * @returns {string} Normalized value: 'no', 'minimal', or 'full'
- */
-export function normalizeReturnValue (value) {
-  if (['no', 'minimal', 'full'].includes(value)) return value
-  return 'no' // default
-}
-
 /**
  * Sets up common request context for REST API methods
  * Handles simplified mode, transaction setup, and initial validation
@@ -75,7 +75,7 @@ export async function setupCommonRequest ({ params, context, vars, scopes, scope
     } else {
       context.inputRecord = params
       // Preserve returnFullRecord if specified in params
-      context.params = params.returnFullRecord ? { returnFullRecord: params.returnFullRecord } : {}
+      context.params = params.returnFullRecord !== undefined ? { returnFullRecord: params.returnFullRecord } : {}
     }
   } else {
     context.inputRecord = params.inputRecord
@@ -89,33 +89,10 @@ export async function setupCommonRequest ({ params, context, vars, scopes, scope
   const defaultReturnFullRecord = isTransport ? vars.returnRecordTransport : vars.returnRecordApi
 
   // Get return record setting - from params only (per-call override) or use default
-  const returnFullRecordRaw = context.params.returnFullRecord !== undefined
-    ? context.params.returnFullRecord
-    : defaultReturnFullRecord
-
-  // Normalize return record setting to always be an object with method keys
-  if (typeof returnFullRecordRaw === 'object' && returnFullRecordRaw !== null) {
-    // It's already an object, normalize the values
-    context.returnRecordSetting = {
-      post: normalizeReturnValue(returnFullRecordRaw.post),
-      put: normalizeReturnValue(returnFullRecordRaw.put),
-      patch: normalizeReturnValue(returnFullRecordRaw.patch)
-    }
-  } else {
-    // It's a single value (string or boolean), apply to all methods
-    const normalized = normalizeReturnValue(returnFullRecordRaw)
-    context.returnRecordSetting = {
-      post: normalized,
-      put: normalized,
-      patch: normalized
-    }
-  }
-
-  // Helper function to normalize return values (same as above)
-  function normalizeReturnValue (value) {
-    if (['no', 'minimal', 'full'].includes(value)) return value
-    return 'no' // default
-  }
+  context.returnRecordSetting = normalizeReturnRecordSetting(
+    context.params.returnFullRecord,
+    defaultReturnFullRecord
+  )
 
   // These only make sense as parameter per query, not in vars etc.
   context.queryParams = params.queryParams || {}
@@ -160,7 +137,7 @@ export async function setupCommonRequest ({ params, context, vars, scopes, scope
  */
 export const handleWriteMethodError = async (error, context, method, scopeName, log, runHooks) => {
   // Rollback transaction if we created it
-  if (context.shouldCommit) {
+  if (context.shouldCommit && !context.transactionCommitted) {
     await context.transaction.rollback()
     await runHooks('afterRollback')
   }
@@ -178,6 +155,39 @@ export const handleWriteMethodError = async (error, context, method, scopeName,
   throw error
 }
 
+export const commitOwnedTransaction = async (context, runHooks) => {
+  if (!context.shouldCommit) {
+    return
+  }
+
+  await context.transaction.commit()
+  context.transactionCommitted = true
+  await runHooks('afterCommit')
+}
+
+export const validateRelationshipRoutePayload = ({
+  context,
+  vars,
+  scopeName,
+  operation,
+  relationshipData
+}) => {
+  const contracts = getRequestContracts({
+    scopeName,
+    schemaInfo: context.schemaInfo,
+    includeDepthLimit: vars.includeDepthLimit,
+    sortableFields: vars.sortableFields
+  })
+
+  const validated = validateRequestContractOrThrow(
+    contracts[operation],
+    { data: relationshipData },
+    `${operation} relationship request body is invalid`
+  )
+
+  return validated.data
+}
+
 /**
  * Validates that a pivot resource exists for many-to-many relationships
  *
@@ -296,16 +306,20 @@ export const validateResourceAttributesBeforeWrite = async ({
     context.originalInputAttributes = { ...(context.inputRecord.data.attributes || {}) }
   }
 
+  const schemaStructure = context.schemaInfo.schemaStructure || {}
+  const hasLogicalIdField = Object.hasOwn(schemaStructure, 'id')
+  const resourceId = context.inputRecord?.data?.id
+
   // Merge belongsTo updates with attributes for validation
   const attributesToValidate = {
     ...context.inputRecord.data.attributes,
-    ...belongsToUpdates
+    ...belongsToUpdates,
+    ...(hasLogicalIdField && resourceId !== undefined ? { id: resourceId } : {})
   }
 
   // Extract computed fields and foreign key fields before validation
   const computedFields = {}
   const foreignKeyFields = {}
-  const schemaStructure = context.schemaInfo.schemaStructure || {}
   Object.entries(attributesToValidate).forEach(([key, value]) => {
     const fieldDef = schemaStructure[key]
     // Computed fields should be stripped from input
@@ -375,12 +389,13 @@ export const validateResourceAttributesBeforeWrite = async ({
   const { validatedObject, errors } = await schema[validationMethod](attributesForValidation)
 
   if (Object.keys(errors).length > 0) {
-    // --- START OF MODIFICATION ---
-    const schemaStructure = context.schemaInfo.schemaInstance.structure // Get the schema structure for lookup
-
     const violations = Object.entries(errors).map(([field, error]) => {
       let fieldPath = `data.attributes.${field}` // Default path for attributes
 
+      if (field === 'id' && hasLogicalIdField) {
+        fieldPath = 'data.id'
+      }
+
       // Check if this field is a foreign key that has an 'as' alias
       const fieldDef = schemaStructure[field]
       if (fieldDef && fieldDef.belongsTo && fieldDef.as) {
@@ -400,7 +415,6 @@ export const validateResourceAttributesBeforeWrite = async ({
         message: error.message
       }
     })
-    // --- END OF MODIFICATION ---
 
     throw new RestApiValidationError(
       'Schema validation failed for resource attributes',
@@ -411,9 +425,14 @@ export const validateResourceAttributesBeforeWrite = async ({
     )
   }
 
+  if (Object.hasOwn(validatedObject, 'id')) {
+    context.inputRecord.data.id = validatedObject.id
+  }
+  const { id: _validatedId, ...validatedAttributes } = validatedObject
+
   // Update attributes with validated values
   // Virtual fields have now been validated and cast properly
-  context.inputRecord.data.attributes = validatedObject
+  context.inputRecord.data.attributes = validatedAttributes
 
   await runHooks(`afterSchemaValidate${methodSpecificHookSuffix}`)
   await runHooks('afterSchemaValidate')
@@ -434,8 +453,16 @@ export const validateRelationshipAccess = async (context, inputRecord, helpers,
   for (const [relName, relData] of Object.entries(inputRecord.data.relationships)) {
     if (!relData?.data) continue
 
+    const normalizedRelationshipData = normalizeRelationshipIdentifiers(relData.data, { api })
+    inputRecord.data.relationships[relName] = {
+      ...relData,
+      data: normalizedRelationshipData
+    }
+
     // Handle both single and array relationships
-    const relatedItems = Array.isArray(relData.data) ? relData.data : [relData.data]
+    const relatedItems = Array.isArray(normalizedRelationshipData)
+      ? normalizedRelationshipData
+      : [normalizedRelationshipData]
 
     for (const item of relatedItems) {
       // Get the scope for the related resource
@@ -455,31 +482,18 @@ export const validateRelationshipAccess = async (context, inputRecord, helpers,
         isUpdate: false
       }
 
-      const targetScope = api.resources?.[item.type]
-      const applyQueryFilters = targetScope?.applyQueryFilters
-        ? async ({ query, filters, tableName, db, scopeName, storageAdapter, isAnyApi }) => {
-          const queryState = await targetScope.applyQueryFilters({
-            query,
-            filters,
-            schemaInfo: getContext.schemaInfo,
-            scopeName,
-            tableName,
-            db,
-            isAnyApi,
-            storageAdapter
-          }, getContext)
-
-          return {
-            query: unwrapQueryBuilderState(queryState, query)
-          }
-        }
-        : undefined
-
       // Get the minimal record
       const record = await helpers.dataGetMinimal({
         scopeName: item.type,
         context: getContext,
-        applyQueryFilters
+        applyQueryFilters: relatedScope.applyQueryFilters
+          ? (filterParams) => relatedScope.applyQueryFilters({
+              ...filterParams,
+              schemaInfo: getContext.schemaInfo
+            }, getContext)
+          : undefined,
+        filters: {},
+        queryPurpose: 'relationship-validation'
       })
 
       if (!record) {
@@ -506,6 +520,22 @@ export const validateRelationshipAccess = async (context, inputRecord, helpers,
   }
 }
 
+export const getVisibleRelationshipParent = async ({
+  context,
+  helpers,
+  scopeName,
+  runHooks
+}) => {
+  // Related-route filters belong to the target resource, not its parent.
+  return helpers.dataGetMinimal({
+    scopeName,
+    context,
+    runHooks,
+    filters: {},
+    queryPurpose: 'relationship-parent'
+  })
+}
+
 /**
  * Applies field setters to transform attribute values before storage
  * Setters are applied in dependency order to handle interdependent fields
@@ -552,8 +582,18 @@ export const applyFieldSetters = async (attributes, schemaInfo, context, api, he
         setterContext
       )
     } catch (error) {
-      console.warn(`Setter for field '${fieldName}' failed:`, error)
-      // Keep original value if setter fails
+      const message = error instanceof Error ? error.message : String(error)
+      throw new RestApiValidationError(
+        `Setter for field '${fieldName}' failed: ${message}`,
+        {
+          fields: [`data.attributes.${fieldName}`],
+          violations: [{
+            field: `data.attributes.${fieldName}`,
+            rule: 'setter_failed',
+            message
+          }]
+        }
+      )
     }
   }
 
@@ -667,7 +707,7 @@ export const findRelationshipDefinition = (schemaInfo, relationshipName) => {
   }
 
   // Then check schema fields for belongsTo relationships with matching 'as' property
-  for (const [fieldName, fieldDef] of Object.entries(schemaInfo.schemaStructure || {})) {
+  for (const [, fieldDef] of Object.entries(schemaInfo.schemaStructure || {})) {
     if (fieldDef.as === relationshipName && fieldDef.belongsTo) {
       return fieldDef
     }