json-rest-api 1.0.29 → 2.1.0

package/plugins/core/rest-api-plugin-methods/delete-relationship.js

@@ -1,7 +1,15 @@
+// @ts-check
+/** @import {
+ * Identifier, LifecycleResource, RelationshipWriteArguments, WriteRelationshipContext
+ * } from './lifecycle-types.js' */
+import { lockRelationshipParent } from '../lib/writing/relationship-processor.js'
+import { advanceResourceVersion } from '../lib/writing/resource-version.js'
+import { beginWriteTransaction } from '../../../lib/error-context.js'
+import { rejectRemovedOptions, resolveFormat } from '../lib/querying-writing/response-options.js'
+import { findRelationshipDefinition } from '../lib/querying-writing/relationship-contracts.js'
 import { RestApiResourceError, RestApiValidationError } from '../../../lib/rest-api-errors.js'
 import {
   commitOwnedTransaction,
-  findRelationshipDefinition,
   getVisibleRelationshipParent,
   handleWriteMethodError,
   validateRelationshipRoutePayload
@@ -10,32 +18,33 @@ import {
   normalizeRelationshipIdentifiers,
   requireExistingResourceId
 } from '../lib/querying-writing/resource-id-normalization.js'
+import { updateReverseRelationship } from '../lib/writing/reverse-relationship-manipulations.js'
+import { invalidateRemovedPivotVersions } from '../lib/writing/many-to-many-manipulations.js'
+import { getStorageColumn } from '../lib/storage/storage-mapping.js'
+import { RELATIONSHIP_WRITE_BATCH_SIZE } from '../lib/querying-writing/knex-constants.js'
 
 /**
- * DELETE RELATIONSHIP
- * Removes specific members from a to-many relationship
- * DELETE /api/articles/1/relationships/tags
- *
- * @param {string} id - The ID of the resource
- * @param {string} relationshipName - The name of the relationship
- * @param {array} relationshipData - Array of resource identifiers to remove
- * @returns {Promise<void>} 204 No Content
+ * Remove the identifiers in params.relationshipData from a to-many relationship.
+ * Authorization and parent/version locking precede mutation. The method
+ * returns no resource and completes only an owned transaction.
+ * @param {RelationshipWriteArguments<Identifier[]>} args
  */
-export default async function deleteRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeOptions, scopeName, api, log }) {
-  context.method = 'deleteRelationship'
-  context.id = requireExistingResourceId(params.id, {
+export default async function deleteRelationshipMethod ({ params, context: callerContext, vars, helpers, scope, scopes, runHooks, scopeOptions, scopeName, api, log }) {
+  rejectRemovedOptions(params)
+  if (params.format !== undefined) resolveFormat(params.format)
+  callerContext.method = 'deleteRelationship'
+  callerContext.scopeName = scopeName
+  callerContext.id = requireExistingResourceId(params.id, {
     scopeOptions,
     vars,
     scopeName
   })
-  context.relationshipName = params.relationshipName
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo
+  callerContext.relationshipName = params.relationshipName
+  callerContext.schemaInfo = scope.vars.schemaInfo
 
-  // Transaction handling
-  context.transaction = params.transaction ||
-    (helpers.newTransaction && !params.transaction ? await helpers.newTransaction() : null)
-  context.shouldCommit = !params.transaction && !!context.transaction
-  context.db = context.transaction || api.knex.instance
+  await beginWriteTransaction(callerContext, params.transaction, helpers.newTransaction, runHooks)
+  callerContext.db = callerContext.transaction || api.knex.instance
+  const context = /** @type {WriteRelationshipContext} */ (callerContext)
 
   try {
     // Validate
@@ -61,7 +70,7 @@ export default async function deleteRelationshipMethod ({ params, context, vars,
       operation: 'deleteRelationship',
       relationshipData: params.relationshipData
     })
-    params.relationshipData = normalizeRelationshipIdentifiers(params.relationshipData, { api })
+    params.relationshipData = /** @type {Identifier[]} */ (normalizeRelationshipIdentifiers(params.relationshipData, { api }))
 
     // Check permissions
     await runHooks('checkPermissions')
@@ -78,6 +87,14 @@ export default async function deleteRelationshipMethod ({ params, context, vars,
     if (!parentRecord) {
       throw new RestApiResourceError('Resource not found', { subtype: 'not_found' })
     }
+    context.minimalRecord = parentRecord
+    context.originalMinimalRecord = parentRecord
+
+    await runHooks('beforeDataCall')
+    await runHooks('beforeDataCallDeleteRelationship')
+
+    const revision = await advanceResourceVersion({ scopeName, context, helpers, expectedVersion: params.expectedVersion })
+    if (revision === undefined) await lockRelationshipParent({ context, helpers, scopeName })
 
     // Remove relationships
     if (relDef?.through) {
@@ -92,45 +109,30 @@ export default async function deleteRelationshipMethod ({ params, context, vars,
       } else {
         const knex = api.knex?.instance || helpers.db
         const pivotResource = relDef.through
-        const pivotScope = api.resources[pivotResource]
+        const pivotScope = /** @type {LifecycleResource} */ (api.resources[pivotResource])
         const pivotTable = pivotScope?.vars?.schemaInfo?.tableName || pivotResource
-        const localKey = relDef.foreignKey
-        const foreignKey = relDef.otherKey
+        const localKey = getStorageColumn(pivotScope.vars.schemaInfo, /** @type {string} */ (relDef.foreignKey))
+        const foreignKey = getStorageColumn(pivotScope.vars.schemaInfo, /** @type {string} */ (relDef.otherKey))
 
-        for (const identifier of params.relationshipData) {
-          await knex(pivotTable)
+        const ids = [...new Set(params.relationshipData.map(identifier => identifier.id))]
+        for (let offset = 0; offset < ids.length; offset += RELATIONSHIP_WRITE_BATCH_SIZE) {
+          const removals = knex(pivotTable)
             .where(localKey, context.id)
-            .where(foreignKey, identifier.id)
-            .delete()
+            .whereIn(foreignKey, ids.slice(offset, offset + RELATIONSHIP_WRITE_BATCH_SIZE))
             .transacting(context.transaction)
+          await invalidateRemovedPivotVersions(api, relDef, removals, context.transaction)
+          await removals.delete()
         }
       }
     } else {
-      // Null out foreign keys for hasMany
-      const targetType = relDef.target
-      for (const identifier of params.relationshipData) {
-        await api.resources[targetType].patch({
-          id: identifier.id,
-          inputRecord: {
-            data: {
-              type: targetType,
-              id: identifier.id,
-              attributes: { [relDef.foreignKey]: null }
-            }
-          },
-          transaction: context.transaction,
-          simplified: false
-        }, { ...context })
-      }
+      await updateReverseRelationship({ api, helpers, context, scopeName, relDef, relData: params.relationshipData, operation: 'remove' })
     }
 
     await runHooks('finish')
     await runHooks('finishDeleteRelationship')
 
-    await commitOwnedTransaction(context, runHooks)
-
-    // 204 No Content
+    await commitOwnedTransaction(context)
   } catch (error) {
-    await handleWriteMethodError(error, context, 'DELETE_RELATIONSHIP', scopeName, log, runHooks)
+    await handleWriteMethodError(error, context, 'DELETE_RELATIONSHIP', scopeName, log)
   }
 }

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

@@ -1,52 +1,56 @@
+// @ts-check
+/** @import {
+ * IdentityContext, LifecycleArguments
+ * } from './lifecycle-types.js' */
+import { initializeResourceVersion, applyResourceVersion, captureInverseVersions, invalidateInverseVersions } from '../lib/writing/resource-version.js'
+import { beginWriteTransaction } from '../../../lib/error-context.js'
+import { rejectRemovedOptions, resolveFormat } from '../lib/querying-writing/response-options.js'
 import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
-import { commitOwnedTransaction, handleWriteMethodError } from './common.js'
+import { commitOwnedTransaction, handleWriteMethodError, writePrecondition } from './common.js'
 import { requireExistingResourceId } from '../lib/querying-writing/resource-id-normalization.js'
 
 /**
- * DELETE
- * Permanently deletes a resource.
- * Returns 204 No Content on success, indicating the resource has been removed.
- * This method does not return the deleted resource.
+ * Delete an existing resource and complete only an owned transaction.
+ * The programmatic method returns no resource; connectors choose HTTP status.
+ * @param {LifecycleArguments} args
  */
 export default async function deleteMethod ({
   params,
-  context,
+  context: callerContext,
   vars,
   helpers,
   scope,
   scopes,
   runHooks,
-  apiOptions,
-  pluginOptions,
   scopeOptions,
   scopeName,
   api,
   log
 }) {
   // Make the method available to all hooks
-  context.method = 'delete'
+  rejectRemovedOptions(params)
+  if (params.format !== undefined) resolveFormat(params.format)
+  callerContext.method = 'delete'
 
   // Set the ID in context
-  context.id = requireExistingResourceId(params.id, {
+  callerContext.id = requireExistingResourceId(params.id, {
     scopeOptions,
     vars,
     scopeName
   })
 
   // Set scopeName in context (needed for broadcasting)
-  context.scopeName = scopeName
+  callerContext.scopeName = scopeName
 
   // Set schema info even for DELETE (needed by storage layer)
-  context.schemaInfo = scopes[scopeName].vars.schemaInfo
+  callerContext.schemaInfo = scope.vars.schemaInfo
 
-  // Transaction handling
-  context.transaction = params.transaction ||
-      (helpers.newTransaction && !params.transaction ? await helpers.newTransaction() : null)
-  context.shouldCommit = !params.transaction && !!context.transaction
-  context.db = context.transaction || api.knex.instance
+  await beginWriteTransaction(callerContext, params.transaction, helpers.newTransaction, runHooks)
+  callerContext.db = callerContext.transaction || api.knex.instance
+  const context = /** @type {IdentityContext} */ (callerContext)
 
   try {
-    // No payload validation needed for DELETE
+    const versionState = initializeResourceVersion({ context, expectedVersion: params.expectedVersion })
 
     // Fetch minimal record for authorization and logging
     const minimalRecord = await helpers.dataGetMinimal({
@@ -69,12 +73,13 @@ export default async function deleteMethod ({
     context.originalMinimalRecord = minimalRecord
     context.minimalRecord = minimalRecord
 
-    // Centralised checkPermissions function
     await scope.checkPermissions({
       method: 'delete',
       originalContext: context,
     })
 
+    await params[writePrecondition]?.()
+
     // Before data operations
     await runHooks('beforeDataCall')
     await runHooks('beforeDataCallDelete')
@@ -82,24 +87,25 @@ export default async function deleteMethod ({
     // Initialize record context for hooks
     context.record = {}
 
+    const inverseVersions = await captureInverseVersions({ api, helpers, context, scopeName })
+    await applyResourceVersion({ state: versionState, context, helpers, scopeName })
+
     // Call the storage helper
     await helpers.dataDelete({
       scopeName,
       context
     })
 
+    await invalidateInverseVersions({ state: inverseVersions, context, helpers, api, isDelete: true })
+
     await runHooks('afterDataCallDelete')
     await runHooks('afterDataCall')
 
-    // No return record for DELETE (204 No Content)
-
     await runHooks('finish')
     await runHooks('finishDelete')
 
-    await commitOwnedTransaction(context, runHooks)
-
-    // DELETE typically returns void/undefined (204 No Content)
+    await commitOwnedTransaction(context)
   } catch (error) {
-    await handleWriteMethodError(error, context, 'DELETE', scopeName, log, runHooks)
+    await handleWriteMethodError(error, context, 'DELETE', scopeName, log)
   }
 }

package/plugins/core/rest-api-plugin-methods/enrich-attributes.js

@@ -1,57 +1,69 @@
-import { filterHiddenFields } from '../lib/querying-writing/field-utils.js'
-import { isRestApiError } from '../../../lib/error-context.js'
-
-/**
- * enrichAttributes
- * Runs the enrichAttributes hook for a specific scope to allow plugins to modify attributes
- * before they are returned to the client. This is a scope method so each resource type
- * can have its own attribute enrichment logic.
- *
- *
- */
+// @ts-check
+/** @import {
+ * EnrichmentArguments, Field, LifecycleContext, LifecycleResource, LifecycleSchema
+ * } from './lifecycle-types.js' */
+import { filterHiddenFields, getResourceFieldset, parseFieldset } from '../lib/querying-writing/field-utils.js'
+import { wrapUnexpectedError } from '../../../lib/error-context.js'
+import { getFieldDependencyClosure } from '../lib/querying-writing/schema-helpers.js'
+import { getRequestedComputedFields } from '../lib/querying-writing/knex-field-helpers.js'
+
+// Resolve field dependencies before filtering and running resource enrichment hooks.
+/** @param {EnrichmentArguments} args */
 export default async function enrichAttributesMethod ({ context, params, runHooks, scopeName, scopes, api, helpers }) {
-  // Extract parameters passed to enrichAttributes
-  // - attributes: The raw attributes from database
-  // - parentContext: The context from the calling method (has queryParams, transaction, etc.)
-  // - requestedComputedFields: Which computed fields to calculate (from sparse fieldsets)
-  // - isMainResource: Whether this is the main resource or an included one
-  // - computedDependencies: Fields fetched only for computation (to be removed)
-  // Extract parameters passed to enrichAttributes
-  // - attributes: The raw attributes from database
-  // - parentContext: The context from the calling method (has queryParams, transaction, etc.)
-  // - requestedComputedFields: Which computed fields to calculate (from sparse fieldsets)
-  // - isMainResource: Whether this is the main resource or an included one
-  // - computedDependencies: Fields fetched only for computation (to be removed)
-  const { attributes, parentContext, requestedComputedFields, isMainResource, computedDependencies } = params || {}
-
-  // Return empty object if no attributes provided
+  const { id, attributes, parentContext, requestedComputedFields, isMainResource } = params || {}
+
   if (!attributes) {
     return {}
   }
 
-  // Get schema, computed field definitions
-  const schemaStructure = scopes[scopeName]?.vars?.schemaInfo?.schemaStructure || {}
-  const computedFields = scopes[scopeName]?.vars?.schemaInfo?.computed || {}
-  const fieldGetters = scopes[scopeName]?.vars?.schemaInfo?.fieldGetters || {}
-  const sortedGetterFields = scopes[scopeName]?.vars?.schemaInfo?.sortedGetterFields || []
-  const queryFields = scopes[scopeName]?.vars?.queryFields || {}
+  const schemaInfo = scopes[scopeName]?.vars?.schemaInfo || /** @type {Partial<LifecycleSchema>} */ ({})
+  const schemaStructure = schemaInfo.schemaStructure || {}
+  const computedFields = schemaInfo.computed || {}
+  const fieldGetters = schemaInfo.fieldGetters || {}
+  const sortedGetterFields = schemaInfo.sortedGetterFields || []
 
-  // Make a copy of attributes for transformation
   const transformedAttributes = { ...attributes }
+  const resourceFieldset = getResourceFieldset(parentContext?.queryParams?.fields, scopeName)
+  const requestedFields = parseFieldset(resourceFieldset)
+  const selectedComputedFields = requestedComputedFields ?? getRequestedComputedFields(
+    scopeName, resourceFieldset, computedFields
+  )
+  const selectedVirtualFields = Object.keys(schemaStructure).filter(name => {
+    const definition = /** @type {Field} */ (schemaStructure[name])
+    return definition.virtual === true && definition.hidden !== true &&
+      (requestedFields === null ? definition.normallyHidden !== true : requestedFields.includes(name))
+  })
+  const neededFields = getFieldDependencyClosure(schemaInfo, [
+    ...Object.keys(attributes), ...selectedComputedFields, ...selectedVirtualFields
+  ])
+
+  // Virtual input belongs only to the resource that was written.
+  const inputData = parentContext?.inputRecord?.data
+  if (isMainResource !== false && inputData?.type === scopeName &&
+      inputData.id !== undefined && String(inputData.id) === String(id) && inputData.attributes) {
+    const inputAttrs = inputData.attributes
+    Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+      if (fieldDef.virtual === true && neededFields.has(fieldName) && Object.hasOwn(inputAttrs, fieldName) && inputAttrs[fieldName] !== undefined && inputAttrs[fieldName] !== null) {
+        if (!Object.hasOwn(transformedAttributes, fieldName)) {
+          transformedAttributes[fieldName] = inputAttrs[fieldName]
+        }
+      }
+    })
+  }
 
-  // STEP 1: Apply field getters in dependency order (before filtering)
-  // This ensures getters see all fields including hidden ones
+  const originalAttributes = { ...transformedAttributes }
+  // Getters run in dependency order while hidden dependencies are still available.
   for (const fieldName of sortedGetterFields) {
-    // Only process if field exists in attributes
-    if (fieldName in transformedAttributes) {
-      const getterInfo = fieldGetters[fieldName]
+    if (Object.hasOwn(transformedAttributes, fieldName)) {
+      const getterInfo = /** @type {NonNullable<LifecycleSchema['fieldGetters'][string]>} */ (fieldGetters[fieldName])
       try {
         const getterContext = {
-          attributes: transformedAttributes, // Current state with previous getters applied
+          id,
+          attributes: transformedAttributes,
           fieldName,
-          originalValue: attributes[fieldName], // Original untransformed value
-          originalAttributes: attributes, // All original attributes
-          record: transformedAttributes, // Alias for compatibility
+          originalValue: originalAttributes[fieldName],
+          originalAttributes,
+          record: transformedAttributes,
           parentContext,
           scopeName,
           api,
@@ -59,128 +71,55 @@ export default async function enrichAttributesMethod ({ context, params, runHook
           isMainResource: isMainResource !== false
         }
 
-        // Apply getter (can be async)
         transformedAttributes[fieldName] = await getterInfo.getter(
           transformedAttributes[fieldName],
           getterContext
         )
       } catch (error) {
-        if (isRestApiError(error)) throw error
-        console.error(`Error in getter for field '${fieldName}' in ${scopeName}:`, error)
-        // Keep current value on error (don't break the whole request)
+        throw wrapUnexpectedError(error, {
+          message: `Getter for field '${fieldName}' failed`,
+          context: { scopeName, fieldName, phase: 'getter' }
+        })
       }
     }
   }
 
-  // Filter hidden fields from attributes based on visibility rules
-  // This removes hidden:true fields and normallyHidden:true fields (unless requested)
-  const requestedFields = parentContext?.queryParams?.fields?.[scopeName]
-  const filteredAttributes = filterHiddenFields(
-    transformedAttributes,
-    { structure: { ...schemaStructure, ...queryFields } },
-    requestedFields
-  )
-
-  // Handle virtual fields - they need to be added from parent context if available
-  // Virtual fields come from input and need to be preserved in responses
-  if (parentContext && parentContext.inputRecord?.data?.attributes) {
-    const inputAttrs = parentContext.inputRecord.data.attributes
-    Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
-      if (fieldDef.virtual === true && fieldName in inputAttrs && inputAttrs[fieldName] !== undefined && inputAttrs[fieldName] !== null) {
-        // Add virtual field to filtered attributes if not already there
-        if (!(fieldName in filteredAttributes)) {
-          filteredAttributes[fieldName] = inputAttrs[fieldName]
-        }
-      }
-    })
-  }
-
-  // Now handle sparse fieldsets for virtual fields
-  if (requestedFields && requestedFields.length > 0) {
-    const requestedFieldsList = typeof requestedFields === 'string'
-      ? requestedFields.split(',').map(f => f.trim())
-      : requestedFields
+  const fieldsToCompute = (schemaInfo.sortedComputedFields || []).filter(field => neededFields.has(field))
 
-    // Remove virtual fields that weren't requested
-    Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
-      if (fieldDef.virtual === true && fieldName in filteredAttributes) {
-        if (!requestedFieldsList.includes(fieldName)) {
-          delete filteredAttributes[fieldName]
-        }
-      }
-    })
-  }
-
-  // Determine which computed fields to calculate
-  // We only compute fields that are requested to optimize performance
-  let fieldsToCompute = []
-  if (requestedComputedFields) {
-    // Explicit list provided (from sparse fieldsets)
-    // Example: ?fields[products]=name,profit_margin -> only compute profit_margin
-    fieldsToCompute = requestedComputedFields
-  } else if (isMainResource || !parentContext?.queryParams?.fields) {
-    // No sparse fieldsets or this is the main resource - compute all fields
-    // This ensures all computed fields are available when no filtering is applied
-    fieldsToCompute = Object.keys(computedFields)
-  }
-
-  // Create compute context with all available resources
-  // IMPORTANT: We pass the TRANSFORMED attributes (after getters) to compute functions
-  // This ensures computed fields see the getter-processed values
-  // Example: if price getter converts string to number, profit_margin sees the number
+  // Computations receive getter-transformed values and earlier computed results.
   const computeContext = {
-    attributes: transformedAttributes,   // Transformed attributes after getters
-    record: { ...transformedAttributes }, // Full record for convenience
+    id,
+    attributes: transformedAttributes,
+    record: { ...transformedAttributes },
     context: parentContext,
-    helpers,                             // API helpers for complex operations
-    api,                                 // Full API instance
+    helpers,
+    api,
   }
 
-  // Auto-compute fields that have compute functions
   for (const fieldName of fieldsToCompute) {
     const fieldDef = computedFields[fieldName]
     if (fieldDef && fieldDef.compute) {
       try {
-        // Call the compute function with full context
-        // Example: profit_margin compute gets { attributes: { price: 100, cost: 60 } }
-        // and returns: ((100 - 60) / 100 * 100) = "40.00"
-        filteredAttributes[fieldName] = await fieldDef.compute(computeContext)
+        const value = await fieldDef.compute(computeContext)
+        transformedAttributes[fieldName] = value
+        computeContext.record[fieldName] = value
       } catch (error) {
-        if (isRestApiError(error)) throw error
-        // Log error but don't fail the request - computed fields shouldn't break API
-        console.error(`Error computing field '${fieldName}' for ${scopeName}:`, error)
-        filteredAttributes[fieldName] = null
+        throw wrapUnexpectedError(error, {
+          message: `Computation for field '${fieldName}' failed`,
+          context: { scopeName, fieldName, phase: 'computed' }
+        })
       }
     }
   }
 
-  // Remove fields that were only fetched as dependencies
-  // This is the key to the dependency resolution feature:
-  // 1. We fetched dependencies from DB (e.g., 'cost' for profit_margin)
-  // 2. We used them in compute functions
-  // 3. Now we remove them if they weren't explicitly requested
-  // Example: User requests profit_margin, we fetch cost, compute, then remove cost
-  const finalAttributes = { ...filteredAttributes }
-  if (requestedFields && computedDependencies && computedDependencies.length > 0) {
-    // Parse requested fields if it's a string
-    const requested = typeof requestedFields === 'string'
-      ? requestedFields.split(',').map(f => f.trim()).filter(f => f)
-      : requestedFields
-
-    for (const dep of computedDependencies) {
-      // Only remove if it wasn't explicitly requested
-      // Example: 'cost' is removed unless user explicitly asked for it
-      if (!requested.includes(dep)) {
-        delete finalAttributes[dep]
-      }
-    }
-  }
-
-  if (requestedFields && requestedFields.length > 0) {
-    const requestedList = typeof requestedFields === 'string'
-      ? requestedFields.split(',').map((field) => field.trim()).filter((field) => field)
-      : requestedFields
-    const allowed = new Set(requestedList)
+  // Remove private fields and values fetched only for computation.
+  const finalAttributes = filterHiddenFields(
+    transformedAttributes,
+    { structure: schemaInfo.outputFields },
+    requestedFields
+  )
+  if (requestedFields !== null) {
+    const allowed = new Set(requestedFields)
     Object.keys(finalAttributes).forEach((key) => {
       if (!allowed.has(key)) {
         delete finalAttributes[key]
@@ -188,20 +127,41 @@ export default async function enrichAttributesMethod ({ context, params, runHook
     })
   }
 
-  // Create context for enrichAttributes hooks
   Object.assign(context, {
     parentContext,
-    attributes: finalAttributes,  // Use the final attributes after dependency removal
+    attributes: finalAttributes,
     computedFields,
-    requestedComputedFields: fieldsToCompute,
+    requestedComputedFields: selectedComputedFields,
     scopeName,
     helpers,
     api
   })
 
-  // Run enrichAttributes hooks for additional/override computations
   await runHooks('enrichAttributes')
 
-  // Return the attributes from context, which hooks may have modified
-  return context.attributes
-};
+  return /** @type {import('../lib/storage/storage-types.js').StorageRow} */ (context.attributes)
+}
+
+// Preserve include order and each resource's enrichment hooks and fieldset.
+/** @param {LifecycleContext} context @param {Record<string, LifecycleResource>} scopes */
+export async function enrichIncludedAttributes (context, scopes) {
+  for (const entry of (context.record?.included || [])) {
+    const entryScope = /** @type {LifecycleResource} */ (scopes[entry.type])
+    const entryComputed = entryScope.vars.schemaInfo?.computed || {}
+    const entryRequestedFields = getResourceFieldset(context.queryParams?.fields, entry.type)
+    const entryRequestedComputed = getRequestedComputedFields(
+      entry.type,
+      entryRequestedFields,
+      entryComputed
+    )
+
+    entry.attributes = await entryScope.enrichAttributes({
+      id: entry.id,
+      attributes: entry.attributes,
+      parentContext: context,
+      requestedComputedFields: entryRequestedComputed,
+      isMainResource: false,
+      computedDependencies: entry.__$jsonrestapi_computed_deps$__
+    })
+  }
+}