json-rest-api 1.0.22 → 1.0.24

package/plugins/core/rest-api-plugin-hooks/register-relationship-routes.js

@@ -36,35 +36,40 @@ export default async function registerRelationshipRoutes ({ context, api, log })
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id/relationships/:relationshipName`,
-    handler: createRouteHandler('getRelationship')
+    handler: createRouteHandler('getRelationship'),
+    routeMeta: { kind: 'relationship', scopeName, operation: 'getRelationship' }
   })
 
   // GET /api/{scope}/{id}/{relationshipName}
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id/:relationshipName`,
-    handler: createRouteHandler('getRelated')
+    handler: createRouteHandler('getRelated'),
+    routeMeta: { kind: 'relationship', scopeName, operation: 'getRelated' }
   })
 
   // POST /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'POST',
     path: `${scopePath}/:id/relationships/:relationshipName`,
-    handler: createRouteHandler('postRelationship')
+    handler: createRouteHandler('postRelationship'),
+    routeMeta: { kind: 'relationship', scopeName, operation: 'postRelationship' }
   })
 
   // PATCH /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'PATCH',
     path: `${scopePath}/:id/relationships/:relationshipName`,
-    handler: createRouteHandler('patchRelationship')
+    handler: createRouteHandler('patchRelationship'),
+    routeMeta: { kind: 'relationship', scopeName, operation: 'patchRelationship' }
   })
 
   // DELETE /api/{scope}/{id}/relationships/{relationshipName}
   await api.addRoute({
     method: 'DELETE',
     path: `${scopePath}/:id/relationships/:relationshipName`,
-    handler: createRouteHandler('deleteRelationship')
+    handler: createRouteHandler('deleteRelationship'),
+    routeMeta: { kind: 'relationship', scopeName, operation: 'deleteRelationship' }
   })
 
   log.trace(`Registered relationship routes for scope: ${scopeName}`)

package/plugins/core/rest-api-plugin-hooks/register-scope-routes.js

@@ -60,42 +60,48 @@ export default async function registerScopeRoutes ({ context, api, vars, log })
   await api.addRoute({
     method: 'GET',
     path: scopePath,
-    handler: createRouteHandler(scopeName, 'query')
+    handler: createRouteHandler(scopeName, 'query'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'query' }
   })
 
   // GET /api/{scope}/{id} - Get single resource
   await api.addRoute({
     method: 'GET',
     path: `${scopePath}/:id`,
-    handler: createRouteHandler(scopeName, 'get')
+    handler: createRouteHandler(scopeName, 'get'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'get' }
   })
 
   // POST /api/{scope} - Create resource
   await api.addRoute({
     method: 'POST',
     path: scopePath,
-    handler: createRouteHandler(scopeName, 'post')
+    handler: createRouteHandler(scopeName, 'post'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'post' }
   })
 
   // PUT /api/{scope}/{id} - Replace resource
   await api.addRoute({
     method: 'PUT',
     path: `${scopePath}/:id`,
-    handler: createRouteHandler(scopeName, 'put')
+    handler: createRouteHandler(scopeName, 'put'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'put' }
   })
 
   // PATCH /api/{scope}/{id} - Update resource
   await api.addRoute({
     method: 'PATCH',
     path: `${scopePath}/:id`,
-    handler: createRouteHandler(scopeName, 'patch')
+    handler: createRouteHandler(scopeName, 'patch'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'patch' }
   })
 
   // DELETE /api/{scope}/{id} - Delete resource
   await api.addRoute({
     method: 'DELETE',
     path: `${scopePath}/:id`,
-    handler: createRouteHandler(scopeName, 'delete')
+    handler: createRouteHandler(scopeName, 'delete'),
+    routeMeta: { kind: 'resource', scopeName, operation: 'delete' }
   })
 
   log.info(`Routes registered for scope '${scopeName}'`)

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

@@ -24,6 +24,7 @@ export default async function turnScopeInitIntoVars ({ context, scopes, vars: ap
 
   // 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/apply-query-filters.js

@@ -0,0 +1,41 @@
+export default async function applyQueryFiltersMethod ({ context, params = {}, runHooks }) {
+  const { query, filters, storageAdapter, ...knexQuery } = params
+
+  if (!query) {
+    return query
+  }
+
+  const previousKnexQuery = context.knexQuery
+  const previousStorageAdapter = context.storageAdapter
+
+  context.knexQuery = {
+    query,
+    filters,
+    storageAdapter,
+    adapter: storageAdapter,
+    ...knexQuery
+  }
+
+  if (storageAdapter) {
+    context.storageAdapter = storageAdapter
+  }
+
+  try {
+    await runHooks('knexQueryFiltering')
+    return {
+      query: context.knexQuery?.query || query
+    }
+  } finally {
+    if (previousKnexQuery === undefined) {
+      delete context.knexQuery
+    } else {
+      context.knexQuery = previousKnexQuery
+    }
+
+    if (previousStorageAdapter === undefined) {
+      delete context.storageAdapter
+    } else {
+      context.storageAdapter = previousStorageAdapter
+    }
+  }
+}

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

@@ -1,9 +1,11 @@
 import {
-  RestApiValidationError,
-  RestApiPayloadError
+  RestApiResourceError,
+  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'
 
 /**
  * Gets an enhanced logger instance with full error details and stack traces
@@ -140,56 +142,6 @@ export async function setupCommonRequest ({ params, context, vars, scopes, scope
       { inputRecord: context.inputRecord },
       { context: { scopeName, schemaStructure, schemaRelationships } }
     )
-  } else {
-    // Strict mode: validate no belongsTo fields in attributes
-    if (context.inputRecord?.data?.attributes) {
-      for (const [key, fieldDef] of Object.entries(schemaStructure)) {
-        if (fieldDef.belongsTo && key in context.inputRecord.data.attributes) {
-          throw new RestApiValidationError(
-            `Field '${key}' is a foreign key and must be set via relationships, not attributes`,
-            { fields: [`data.attributes.${key}`] }
-          )
-        }
-      }
-    }
-  }
-
-  if (context.inputRecord.data.type !== scopeName) {
-    throw new RestApiValidationError(
-      `Resource type mismatch. Expected '${scopeName}' but got '${context.inputRecord.data.type}'`,
-      {
-        fields: ['data.type'],
-        violations: [{
-          field: 'data.type',
-          rule: 'resource_type_match',
-          message: `Resource type must be '${scopeName}'`
-        }]
-      }
-    )
-  }
-
-  // Remove included validation since JSON:API doesn't support it
-  if (context.inputRecord.included) {
-    throw new RestApiPayloadError(
-      context.method + ' requests cannot include an "included" array. JSON:API does not support creating multiple resources in a single request.',
-      { path: 'included', expected: 'undefined', received: 'array' }
-    )
-  }
-
-  // If both URL path ID and request body ID are provided, they must match
-  // Convert both to strings for comparison since databases may return numeric IDs
-  if (context.id && context.inputRecord.data.id && String(context.id) !== String(context.inputRecord.data.id)) {
-    throw new RestApiValidationError(
-      `ID mismatch. URL path ID '${context.id}' does not match request body ID '${context.inputRecord.data.id}'`,
-      {
-        fields: ['data.id'],
-        violations: [{
-          field: 'data.id',
-          rule: 'id_consistency',
-          message: 'Request body ID must match URL path ID when both are provided'
-        }]
-      }
-    )
   }
 
   // Return key schema-related objects for direct use in the main methods
@@ -261,6 +213,61 @@ export const getMethodHookSuffix = (method) => {
   return method.charAt(0).toUpperCase() + method.slice(1)
 }
 
+export const validateCompleteReplacePayload = ({
+  context,
+  belongsToUpdates
+}) => {
+  const schemaInfo = context.schemaInfo || {}
+  const schemaStructure = schemaInfo.schemaStructure || {}
+  const idProperty = schemaInfo.idProperty || 'id'
+  const originalInputAttributes = context.originalInputAttributes || context.inputRecord?.data?.attributes || {}
+  const missingFields = []
+
+  for (const [fieldName, fieldDef] of Object.entries(schemaStructure)) {
+    if (!fieldDef) continue
+    if (fieldName === idProperty) continue
+    if (fieldDef.computed === true || fieldDef.virtual === true) continue
+    if (fieldDef.type === undefined) continue
+
+    if (fieldDef.belongsTo && fieldDef.as) {
+      if (Object.hasOwn(belongsToUpdates, fieldName)) continue
+
+      const existingRelationshipData = context.minimalRecord?.relationships?.[fieldDef.as]?.data
+      if (existingRelationshipData?.id !== undefined && existingRelationshipData?.id !== null) {
+        missingFields.push({
+          field: `data.relationships.${fieldDef.as}.data.id`,
+          message: `PUT requests must explicitly include relationship '${fieldDef.as}' when it already has a value`
+        })
+      }
+      continue
+    }
+
+    if (Object.hasOwn(originalInputAttributes, fieldName)) continue
+
+    const existingValue = context.minimalRecord?.attributes?.[fieldName]
+    if (existingValue !== undefined && existingValue !== null) {
+      missingFields.push({
+        field: `data.attributes.${fieldName}`,
+        message: `PUT requests must explicitly include attribute '${fieldName}' when it already has a value`
+      })
+    }
+  }
+
+  if (missingFields.length > 0) {
+    throw new RestApiValidationError(
+      'PUT request omits persisted fields that already have stored values',
+      {
+        fields: missingFields.map(({ field }) => field),
+        violations: missingFields.map(({ field, message }) => ({
+          field,
+          rule: 'complete_replacement',
+          message
+        }))
+      }
+    )
+  }
+}
+
 /**
  * Validates resource attributes before write operations
  *
@@ -285,22 +292,25 @@ export const validateResourceAttributesBeforeWrite = async ({
   await runHooks('beforeSchemaValidate')
   await runHooks(`beforeSchemaValidate${methodSpecificHookSuffix}`)
 
-  // Store original input attributes before validation adds defaults (primarily for POST)
-  // Only if it's not already set and the current method is POST
-  if (!context.originalInputAttributes && context.method === 'post') {
+  // Store original input attributes before validation adds defaults or casts.
+  if (!context.originalInputAttributes) {
     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
@@ -361,17 +371,22 @@ export const validateResourceAttributesBeforeWrite = async ({
       return acc
     }, {})
 
-  const validationOptions = isPartialValidation ? { onlyObjectValues: true } : {}
+  const validationMethod = isPartialValidation
+    ? 'patch'
+    : context.method === 'put'
+      ? 'replace'
+      : 'create'
 
-  const { validatedObject, errors } = await schema.validate(attributesForValidation, validationOptions)
+  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) {
@@ -391,7 +406,6 @@ export const validateResourceAttributesBeforeWrite = async ({
         message: error.message
       }
     })
-    // --- END OF MODIFICATION ---
 
     throw new RestApiValidationError(
       'Schema validation failed for resource attributes',
@@ -402,9 +416,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')
@@ -416,18 +435,25 @@ export const validateResourceAttributesBeforeWrite = async ({
  * @param {object} context - The context object containing authentication info
  * @param {object} inputRecord - The input record containing relationships to validate
  * @param {object} helpers - Data helpers including dataGetMinimal
- * @param {function} runHooks - Function to run hooks
  * @param {object} api - API instance to access resources
  * @throws {Error} If user doesn't have access to any related resource
  */
-export const validateRelationshipAccess = async (context, inputRecord, helpers, runHooks, api) => {
+export const validateRelationshipAccess = async (context, inputRecord, helpers, api) => {
   if (!inputRecord?.data?.relationships) return
 
   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
@@ -442,19 +468,47 @@ export const validateRelationshipAccess = async (context, inputRecord, helpers,
         id: item.id,
         schemaInfo: relatedScope.vars.schemaInfo,
         scopeName: item.type,
+        queryParams: {},
         method: 'get', // We're checking read permission
         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,
-        runHooks
+        applyQueryFilters
       })
 
       if (!record) {
-        throw new Error(`Cannot create relationship to non-existent ${item.type} with id ${item.id}`)
+        throw new RestApiResourceError(
+          `Cannot create relationship to non-existent ${item.type} with id ${item.id}`,
+          {
+            subtype: 'not_found',
+            resourceType: item.type,
+            resourceId: item.id
+          }
+        )
       }
 
       // Check permissions using the related scope's checkPermissions
@@ -493,29 +547,31 @@ export const applyFieldSetters = async (attributes, schemaInfo, context, api, he
   const transformedAttributes = { ...attributes }
 
   for (const fieldName of sortedSetterFields) {
-    // Only process fields that exist in the attributes
-    if (fieldName in transformedAttributes) {
-      const setterInfo = fieldSetters[fieldName]
-      try {
-        const setterContext = {
-          attributes: transformedAttributes, // Current state with previous setters applied
-          fieldName,
-          originalValue: attributes[fieldName],
-          originalAttributes: attributes,
-          scopeName: context.scopeName,
-          method: context.method,
-          api,
-          helpers,
-          auth: context.auth
-        }
-        transformedAttributes[fieldName] = await setterInfo.setter(
-          transformedAttributes[fieldName],
-          setterContext
-        )
-      } catch (error) {
-        console.warn(`Setter for field '${fieldName}' failed:`, error)
-        // Keep original value if setter fails
+    const setterInfo = fieldSetters[fieldName]
+    const fieldPresent = fieldName in transformedAttributes
+    const hasDependencies = Array.isArray(setterInfo.runSetterAfter) && setterInfo.runSetterAfter.length > 0
+
+    if (!fieldPresent && !hasDependencies) continue
+
+    try {
+      const setterContext = {
+        attributes: transformedAttributes, // Current state with previous setters applied
+        fieldName,
+        originalValue: attributes[fieldName],
+        originalAttributes: attributes,
+        scopeName: context.scopeName,
+        method: context.method,
+        api,
+        helpers,
+        auth: context.auth
       }
+      transformedAttributes[fieldName] = await setterInfo.setter(
+        transformedAttributes[fieldName],
+        setterContext
+      )
+    } catch (error) {
+      console.warn(`Setter for field '${fieldName}' failed:`, error)
+      // Keep original value if setter fails
     }
   }
 
@@ -629,7 +685,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
     }

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

@@ -1,5 +1,9 @@
 import { RestApiResourceError, RestApiValidationError, RestApiPayloadError } from '../../../lib/rest-api-errors.js'
 import { findRelationshipDefinition, handleWriteMethodError } from './common.js'
+import {
+  normalizeRelationshipIdentifiers,
+  requireExistingResourceId
+} from '../lib/querying-writing/resource-id-normalization.js'
 
 /**
  * DELETE RELATIONSHIP
@@ -11,9 +15,13 @@ import { findRelationshipDefinition, handleWriteMethodError } from './common.js'
  * @param {array} relationshipData - Array of resource identifiers to remove
  * @returns {Promise<void>} 204 No Content
  */
-export default async function deleteRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api, log }) {
+export default async function deleteRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeOptions, scopeName, api, log }) {
   context.method = 'deleteRelationship'
-  context.id = params.id
+  context.id = requireExistingResourceId(params.id, {
+    scopeOptions,
+    vars,
+    scopeName
+  })
   context.relationshipName = params.relationshipName
   context.schemaInfo = scopes[scopeName].vars.schemaInfo
 
@@ -43,6 +51,7 @@ export default async function deleteRelationshipMethod ({ params, context, vars,
     if (!Array.isArray(params.relationshipData)) {
       throw new RestApiPayloadError('DELETE from relationship requires array of resource identifiers')
     }
+    params.relationshipData = normalizeRelationshipIdentifiers(params.relationshipData, { api })
 
     // Check permissions
     await runHooks('checkPermissions')

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

@@ -1,5 +1,6 @@
 import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
 import { handleWriteMethodError } from './common.js'
+import { requireExistingResourceId } from '../lib/querying-writing/resource-id-normalization.js'
 
 /**
  * DELETE
@@ -26,7 +27,11 @@ export default async function deleteMethod ({
   context.method = 'delete'
 
   // Set the ID in context
-  context.id = params.id
+  context.id = requireExistingResourceId(params.id, {
+    scopeOptions,
+    vars,
+    scopeName
+  })
 
   // Set scopeName in context (needed for broadcasting)
   context.scopeName = scopeName

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

@@ -33,6 +33,7 @@ export default async function enrichAttributesMethod ({ context, params, runHook
   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 || {}
 
   // Make a copy of attributes for transformation
   const transformedAttributes = { ...attributes }
@@ -72,7 +73,11 @@ export default async function enrichAttributesMethod ({ context, params, runHook
   // 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 }, requestedFields)
+  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

package/plugins/core/rest-api-plugin-methods/get-related.js

@@ -1,6 +1,7 @@
 import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
 import { findRelationshipDefinition } from './common.js'
 import { buildRelationshipUrl } from '../lib/querying/url-helpers.js'
+import { requireExistingResourceId } from '../lib/querying-writing/resource-id-normalization.js'
 
 /**
  * GET RELATED
@@ -12,9 +13,13 @@ import { buildRelationshipUrl } from '../lib/querying/url-helpers.js'
  * @param {object} queryParams - Standard query parameters
  * @returns {Promise<object>} Related resources with full data
  */
-export default async function getRelatedMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api }) {
+export default async function getRelatedMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeOptions, scopeName, api }) {
   context.method = 'getRelated'
-  context.id = params.id
+  context.id = requireExistingResourceId(params.id, {
+    scopeOptions,
+    vars,
+    scopeName
+  })
   context.relationshipName = params.relationshipName
   context.queryParams = params.queryParams || {}
   context.schemaInfo = scopes[scopeName].vars.schemaInfo

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

@@ -1,6 +1,7 @@
 import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
 import { findRelationshipDefinition } from './common.js'
 import { buildRelationshipUrl } from '../lib/querying/url-helpers.js'
+import { requireExistingResourceId } from '../lib/querying-writing/resource-id-normalization.js'
 
 /**
  * GET RELATIONSHIP
@@ -11,9 +12,13 @@ import { buildRelationshipUrl } from '../lib/querying/url-helpers.js'
  * @param {string} relationshipName - The name of the relationship
  * @returns {Promise<object>} Relationship linkage with links
  */
-export default async function getRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeName, api }) {
+export default async function getRelationshipMethod ({ params, context, vars, helpers, scope, scopes, runHooks, scopeOptions, scopeName, api }) {
   context.method = 'getRelationship'
-  context.id = params.id
+  context.id = requireExistingResourceId(params.id, {
+    scopeOptions,
+    vars,
+    scopeName
+  })
   context.relationshipName = params.relationshipName
   context.schemaInfo = scopes[scopeName].vars.schemaInfo