json-rest-api 1.0.21 → 1.0.23

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

@@ -1,9 +1,15 @@
 import { requirePackage } from 'hooked-api'
 import { createSchema } from 'json-rest-schema'
-import { createKnexTable, addKnexFields, alterKnexFields } from './lib/dbTablesOperations.js'
-import { buildFieldSelection, isNonDatabaseField } from './lib/querying-writing/knex-field-helpers.js'
+import {
+  createKnexTable,
+  addKnexFields,
+  alterKnexFields,
+  generateKnexMigration,
+  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 { buildQuerySelection } from './lib/querying/knex-query-helpers-base.js'
 import { toJsonApiRecord, 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'
@@ -26,30 +32,13 @@ import {
 } from './lib/querying/knex-pagination-helpers.js'
 import { getUrlPrefix } from './lib/querying/url-helpers.js'
 import { createStorageAdapter } from './lib/storage/storage-adapter.js'
-
-/**
- * Strips non-database fields (computed and virtual) from attributes before database operations
- * @param {Object} attributes - The attributes object
- * @param {Object} schemaInfo - The schema info containing computed field definitions and schema structure
- * @returns {Object} Attributes with computed and virtual fields removed
- */
-const stripNonDatabaseFields = (attributes, schemaInfo) => {
-  if (!attributes || !schemaInfo) return attributes || {}
-
-  const { computed = {}, schemaStructure = {} } = schemaInfo
-  return Object.entries(attributes)
-    .filter(([key]) => {
-      // Remove computed fields
-      if (key in computed) return false
-      // Remove fields marked as virtual in the schema
-      const fieldDef = schemaStructure[key]
-      if (fieldDef && fieldDef.virtual === true) {
-        return false
-      }
-      return true
-    })
-    .reduce((acc, [key, val]) => ({ ...acc, [key]: val }), {})
-}
+import {
+  applyCursorPredicate,
+  applyQueryFieldOrder,
+  buildEffectiveSortList,
+  parseSortEntry
+} from './lib/querying/query-field-sort-helpers.js'
+import { unwrapQueryBuilderState } from './lib/querying/query-builder-utils.js'
 
 export const RestApiKnexPlugin = {
   name: 'rest-api-knex',
@@ -99,22 +88,89 @@ export const RestApiKnexPlugin = {
     api.knex.helpers.getStorageAdapter = getScopeStorageAdapter
     helpers.getStorageAdapter = getScopeStorageAdapter
 
-    const createSelectTranslator = (adapter) => {
-      if (!adapter) return null
-      return (field, alias) => {
-        if (field === '*') {
-          return alias ? `${alias}.*` : '*'
+    const buildScopeTableSchema = (vars = {}) => {
+      const schemaStructure = vars.schemaInfo?.schemaStructure || {}
+      const filteredSchema = {}
+
+      Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
+        if (!fieldDef.virtual) {
+          filteredSchema[fieldName] = fieldDef
+        }
+      })
+
+      return {
+        structure: filteredSchema,
+        indexes: vars.schemaInfo?.indexes || [],
+        foreignKeys: vars.schemaInfo?.foreignKeys || [],
+        checkConstraints: vars.schemaInfo?.checkConstraints || []
+      }
+    }
+
+    const buildLegacySortDescriptors = ({
+      query,
+      sort,
+      schemaInfo,
+      sortableFields,
+      storageAdapter,
+      defaultSort,
+      queryFieldRuntimeByField = new Map()
+    }) => {
+      const effectiveSort = buildEffectiveSortList(sort, { defaultSort, idField: 'id' })
+      const descriptors = []
+
+      for (const sortEntry of effectiveSort) {
+        const { field, direction, sqlDirection } = parseSortEntry(sortEntry)
+
+        if (field !== 'id' && sortableFields?.length > 0 && !sortableFields.includes(field)) {
+          log.warn(`Ignoring non-sortable field: ${field}`)
+          continue
         }
-        const translated = adapter.translateColumn(field)
-        const result = translated || field
-        if (!alias) {
-          return result
+
+        const queryFieldRuntime = queryFieldRuntimeByField.get(field)
+        if (queryFieldRuntime) {
+          applyQueryFieldOrder(query, queryFieldRuntime, sqlDirection)
+          descriptors.push({
+            field,
+            direction: sqlDirection,
+            queryFieldRuntime,
+            definition: queryFieldRuntime.definition,
+            isRelationship: false
+          })
+          continue
         }
-        if (result.includes('.')) {
-          return result
+
+        let dbField = field
+        const searchField = schemaInfo.searchSchemaStructure?.[field]
+        if (searchField?.actualField) {
+          dbField = searchField.actualField
         }
-        return `${alias}.${result}`
+
+        const translatedField = storageAdapter?.translateColumn
+          ? storageAdapter.translateColumn(dbField)
+          : dbField
+
+        query.orderBy(translatedField, direction)
+        descriptors.push({
+          field,
+          direction: sqlDirection,
+          column: translatedField,
+          definition: schemaInfo.schemaStructure?.[field] || { type: field === 'id' ? 'id' : undefined },
+          isRelationship: Boolean(searchField?.isRelationship)
+        })
+      }
+
+      if (descriptors.length === 0) {
+        query.orderBy('id', 'asc')
+        descriptors.push({
+          field: 'id',
+          direction: 'ASC',
+          column: 'id',
+          definition: { type: 'id' },
+          isRelationship: false
+        })
       }
+
+      return descriptors
     }
 
     // Check database capabilities
@@ -170,21 +226,45 @@ export const RestApiKnexPlugin = {
 
     // Helper scope method to get all schema-related information
     addScopeMethod('createKnexTable', async ({ vars, scope, scopeName, scopeOptions, runHooks }) => {
-      // Create a filtered schema that excludes virtual fields
-      const schemaStructure = vars.schemaInfo.schemaStructure || {}
-      const filteredSchema = {}
+      const tableSchemaInstance = buildScopeTableSchema(vars)
+      await createKnexTable(api.knex.instance, vars.schemaInfo, tableSchemaInstance, scopeOptions)
+    })
 
-      // Copy only non-virtual fields to the filtered schema
-      Object.entries(schemaStructure).forEach(([fieldName, fieldDef]) => {
-        if (!fieldDef.virtual) {
-          filteredSchema[fieldName] = fieldDef
-        }
+    addScopeMethod('introspectKnexTableSnapshot', async ({ vars }) => {
+      return introspectKnexTableSnapshot(api.knex.instance, {
+        tableName: vars.schemaInfo.tableName,
+        idColumn: vars.schemaInfo.idProperty
       })
+    })
 
-      // Create schema object from filtered fields
-      const tableSchemaInstance = createSchema(filteredSchema)
+    addScopeMethod('generateKnexMigration', async ({ vars, scopeOptions }) => {
+      return generateKnexMigration(
+        vars.schemaInfo.tableName,
+        buildScopeTableSchema(vars),
+        {
+          ...scopeOptions,
+          idProperty: vars.schemaInfo.idProperty,
+          dialect: api.knex.instance?.client?.config?.client
+        }
+      )
+    })
 
-      await createKnexTable(api.knex.instance, vars.schemaInfo, tableSchemaInstance, scopeOptions)
+    addScopeMethod('generateKnexMigrationDiff', async ({ vars, params }) => {
+      const snapshot = await introspectKnexTableSnapshot(api.knex.instance, {
+        tableName: vars.schemaInfo.tableName,
+        idColumn: vars.schemaInfo.idProperty
+      })
+
+      return generateKnexMigrationDiff(
+        vars.schemaInfo.tableName,
+        snapshot,
+        buildScopeTableSchema(vars),
+        {
+          ...(params?.options || {}),
+          idProperty: vars.schemaInfo.idProperty,
+          dialect: snapshot.dialect || api.knex.instance?.client?.config?.client
+        }
+      )
     })
 
     // Helper scope method to alter existing fields in a table
@@ -198,7 +278,7 @@ export const RestApiKnexPlugin = {
         api.knex.instance,
         vars.schemaInfo.tableName,
         params.fields,
-        params.options // Pass through any additional options
+        { ...params.options, idProperty: vars.schemaInfo.idProperty }
       )
     })
 
@@ -207,7 +287,12 @@ export const RestApiKnexPlugin = {
       // Create schema object from filtered fields
       const partialTableSchema = createSchema(params.fields)
 
-      await addKnexFields(api.knex.instance, vars.schemaInfo.tableName, partialTableSchema)
+      await addKnexFields(
+        api.knex.instance,
+        vars.schemaInfo.tableName,
+        partialTableSchema,
+        { idProperty: vars.schemaInfo.idProperty }
+      )
     })
 
     helpers.newTransaction = async () => {
@@ -317,15 +402,18 @@ export const RestApiKnexPlugin = {
       // Permission checks will handle access control
       let query = db(tableName).where(idProperty, id)
 
-      // Apply field selection
-      const selectTranslator = createSelectTranslator(storageAdapter)
-      query = buildQuerySelection(
+      const selectionState = await applyFieldSelectionToQuery({
         query,
+        scope,
+        fieldSelectionInfo,
         tableName,
-        fieldSelectionInfo.fieldsToSelect,
-        false,
-        selectTranslator ? { translateColumn: selectTranslator } : undefined
-      )
+        useTablePrefix: false,
+        storageAdapter,
+        db,
+        context,
+        scopeName
+      })
+      query = selectionState.query
 
       const record = await query.first()
 
@@ -342,7 +430,7 @@ export const RestApiKnexPlugin = {
 
       // Load relationship identifiers for all hasMany relationships
       const records = [record] // Wrap in array for processing
-      await loadRelationshipIdentifiers(records, scopeName, scopes, db)
+      await loadRelationshipIdentifiers(records, scopeName, scopes, db, context)
 
       // Process includes
       const included = await processIncludes(scope, records, {
@@ -369,7 +457,7 @@ 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 }) => {
+    helpers.dataGetMinimal = async ({ scopeName, context, runHooks, applyQueryFilters }) => {
       const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
         context.storageAdapter = storageAdapter
@@ -382,8 +470,9 @@ export const RestApiKnexPlugin = {
 
       log.debug(`[Knex] GET_MINIMAL ${tableName}/${id}`)
 
-      // Build query - no filtering hooks for single records
-      // Permission checks will handle access control
+      // Build query.
+      // Single-record lookups still go through knexQueryFiltering when hooks are available,
+      // so resource scoping plugins can treat GET/PUT/PATCH/DELETE the same way as collections.
       let query = db(tableName).where(idProperty, id)
 
       // Add alias if idProperty is not 'id'
@@ -391,6 +480,35 @@ export const RestApiKnexPlugin = {
         query = query.select('*', `${idProperty} as id`)
       }
 
+      if (typeof applyQueryFilters === 'function') {
+        const scopedQueryState = await applyQueryFilters({
+          query,
+          filters: context.queryParams?.filters,
+          tableName,
+          db,
+          scopeName,
+          storageAdapter
+        })
+        query = unwrapQueryBuilderState(scopedQueryState, query)
+      } else if (runHooks) {
+        context.knexQuery = {
+          query,
+          filters: context.queryParams?.filters,
+          schemaInfo: context.schemaInfo,
+          scopeName,
+          tableName,
+          db,
+          adapter: storageAdapter,
+          storageAdapter,
+        }
+
+        await runHooks('knexQueryFiltering')
+
+        if (context.knexQuery) {
+          delete context.knexQuery
+        }
+      }
+
       // Execute query
       const record = await query.first()
 
@@ -461,14 +579,19 @@ export const RestApiKnexPlugin = {
       // Start building query with table prefix (for JOIN support)
       let query = db(tableName)
 
-      const selectTranslator = createSelectTranslator(storageAdapter)
-      query = buildQuerySelection(
+      const selectionState = await applyFieldSelectionToQuery({
         query,
+        scope,
+        fieldSelectionInfo,
         tableName,
-        fieldSelectionInfo.fieldsToSelect,
-        true,
-        selectTranslator ? { translateColumn: selectTranslator } : undefined
-      )
+        useTablePrefix: true,
+        storageAdapter,
+        db,
+        context,
+        scopeName
+      })
+      query = selectionState.query
+      const queryFieldRuntimeByField = selectionState.queryFieldRuntimeByField
 
       /* ═══════════════════════════════════════════════════════════════════
        * FILTERING HOOKS
@@ -513,33 +636,15 @@ export const RestApiKnexPlugin = {
 
       log.trace('[DATA-QUERY] Finished knexQueryFiltering hook')
 
-      // Apply sorting directly (no hooks)
-      if (queryParams.sort && queryParams.sort.length > 0) {
-        queryParams.sort.forEach(sortField => {
-          const desc = sortField.startsWith('-')
-          const field = desc ? sortField.substring(1) : sortField
-
-          // Check if field is sortable
-          if (sortableFields && sortableFields.length > 0 && !sortableFields.includes(field)) {
-            log.warn(`Ignoring non-sortable field: ${field}`)
-            return // Skip non-sortable fields
-          }
-
-          // Map relationship names to actual database columns for sorting
-          // Check if this is a relationship field that needs to be mapped
-          let dbField = field
-          const searchField = schemaInfo.searchSchemaStructure?.[field]
-          if (searchField?.actualField) {
-            // This is a relationship field, use the actual database column
-            dbField = searchField.actualField
-          }
-          const translatedField = storageAdapter?.translateColumn
-            ? storageAdapter.translateColumn(dbField)
-            : dbField
-
-          query.orderBy(translatedField, desc ? 'desc' : 'asc')
-        })
-      }
+      const sortDescriptors = buildLegacySortDescriptors({
+        query,
+        sort: queryParams.sort,
+        schemaInfo,
+        sortableFields,
+        defaultSort: scope.vars.defaultSort,
+        storageAdapter,
+        queryFieldRuntimeByField
+      })
 
       // Apply pagination
       // Check if page object has any actual pagination parameters
@@ -583,9 +688,6 @@ export const RestApiKnexPlugin = {
           // Fetch one extra record to determine if there are more
           query.limit(pageSize + 1)
 
-          // Get the configured ID property
-          const idProperty = context.schemaInfo.idProperty || 'id'
-
           if (queryParams.page.after) {
             let cursorData
             try {
@@ -604,56 +706,16 @@ export const RestApiKnexPlugin = {
               )
             }
 
-            // Build sort fields array with directions
-            const sortFields = []
-            if (queryParams.sort && queryParams.sort.length > 0) {
-              queryParams.sort.forEach(sortField => {
-                const desc = sortField.startsWith('-')
-                const field = desc ? sortField.substring(1) : sortField
-                sortFields.push({ field, direction: desc ? 'DESC' : 'ASC' })
-              })
-            } else if (scope.vars.defaultSort) {
-              sortFields.push({
-                field: scope.vars.defaultSort.field || idProperty,
-                direction: scope.vars.defaultSort.direction || 'ASC'
-              })
-            } else {
-              sortFields.push({ field: idProperty, direction: 'ASC' })
-            }
-
-            // Build compound WHERE clause for multi-field cursor
-            query.where(function () {
-              sortFields.forEach((sortInfo, index) => {
-                const { field, direction } = sortInfo
-                const qualifiedField = `${tableName}.${field}`
-                const cursorValue = cursorData[field]
-
-                if (cursorValue === undefined) {
-                  log.warn(`Cursor missing value for sort field: ${field}`)
-                  return
-                }
-
-                // Build condition for this level and all previous levels
-                this.orWhere(function () {
-                  // All previous fields must be equal
-                  for (let i = 0; i < index; i++) {
-                    const prevField = sortFields[i].field
-                    const prevQualifiedField = `${tableName}.${prevField}`
-                    const prevValue = cursorData[prevField]
-                    if (prevValue !== undefined) {
-                      this.where(prevQualifiedField, '=', prevValue)
-                    }
-                  }
-
-                  // Current field must be greater/less than cursor value
-                  if (direction === 'DESC') {
-                    this.where(qualifiedField, '<', cursorValue)
-                  } else {
-                    this.where(qualifiedField, '>', cursorValue)
-                  }
-                })
-              })
-            })
+            applyCursorPredicate(
+              query,
+              sortDescriptors,
+              cursorData,
+              (direction) => (direction === 'DESC' ? '<' : '>'),
+              (builder, descriptor, operator, value) => builder.where(descriptor.column, operator, value),
+              {
+                onMissingValue: (fieldName) => log.warn(`Cursor missing value for sort field: ${fieldName}`)
+              }
+            )
           } else if (queryParams.page.before) {
             let cursorData
             try {
@@ -672,56 +734,16 @@ export const RestApiKnexPlugin = {
               )
             }
 
-            // Build sort fields array with directions
-            const sortFields = []
-            if (queryParams.sort && queryParams.sort.length > 0) {
-              queryParams.sort.forEach(sortField => {
-                const desc = sortField.startsWith('-')
-                const field = desc ? sortField.substring(1) : sortField
-                sortFields.push({ field, direction: desc ? 'DESC' : 'ASC' })
-              })
-            } else if (scope.vars.defaultSort) {
-              sortFields.push({
-                field: scope.vars.defaultSort.field || idProperty,
-                direction: scope.vars.defaultSort.direction || 'ASC'
-              })
-            } else {
-              sortFields.push({ field: idProperty, direction: 'ASC' })
-            }
-
-            // Build compound WHERE clause for multi-field cursor (reversed for before)
-            query.where(function () {
-              sortFields.forEach((sortInfo, index) => {
-                const { field, direction } = sortInfo
-                const qualifiedField = `${tableName}.${field}`
-                const cursorValue = cursorData[field]
-
-                if (cursorValue === undefined) {
-                  log.warn(`Cursor missing value for sort field: ${field}`)
-                  return
-                }
-
-                // Build condition for this level and all previous levels
-                this.orWhere(function () {
-                  // All previous fields must be equal
-                  for (let i = 0; i < index; i++) {
-                    const prevField = sortFields[i].field
-                    const prevQualifiedField = `${tableName}.${prevField}`
-                    const prevValue = cursorData[prevField]
-                    if (prevValue !== undefined) {
-                      this.where(prevQualifiedField, '=', prevValue)
-                    }
-                  }
-
-                  // Current field must be less/greater than cursor value (reversed)
-                  if (direction === 'DESC') {
-                    this.where(qualifiedField, '>', cursorValue)
-                  } else {
-                    this.where(qualifiedField, '<', cursorValue)
-                  }
-                })
-              })
-            })
+            applyCursorPredicate(
+              query,
+              sortDescriptors,
+              cursorData,
+              (direction) => (direction === 'DESC' ? '>' : '<'),
+              (builder, descriptor, operator, value) => builder.where(descriptor.column, operator, 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"
@@ -844,12 +866,7 @@ export const RestApiKnexPlugin = {
           records.pop()
         }
 
-        // Determine sort fields for cursor
-        const idProperty = context.schemaInfo.idProperty || 'id'
-        let sortFields = [idProperty]
-        if (queryParams.sort && queryParams.sort.length > 0) {
-          sortFields = queryParams.sort.map(s => s.startsWith('-') ? s.substring(1) : s)
-        }
+        const sortFields = sortDescriptors.map((descriptor) => descriptor.field)
 
         context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields)
         const urlPrefix = getUrlPrefix(context, scope)
@@ -865,7 +882,7 @@ export const RestApiKnexPlugin = {
       }
 
       // Load relationship identifiers for all hasMany relationships
-      await loadRelationshipIdentifiers(records, scopeName, scopes, db)
+      await loadRelationshipIdentifiers(records, scopeName, scopes, db, context)
 
       // Process includes
       const included = await processIncludes(scope, records, {
@@ -909,11 +926,22 @@ export const RestApiKnexPlugin = {
 
       log.debug(`[Knex] POST ${tableName}`, inputRecord)
 
-      // Extract attributes from JSON:API format
-      const attributes = inputRecord.data.attributes
+      // Extract attributes from JSON:API format.
+      // POST may legitimately provide a resource id when the table uses a custom primary key
+      // (for example, one-to-one rows keyed by user_id/workspace_id). Keep that id in the
+      // attribute bag so storage translation can write it to the configured id column.
+      const attributes = {
+        ...(inputRecord.data.attributes || {}),
+        ...(inputRecord.data.id !== undefined ? { id: inputRecord.data.id } : {})
+      }
 
       // Strip non-database fields (computed and virtual) before insert
-      const dbAttributes = stripNonDatabaseFields(attributes, context.schemaInfo)
+      const dbAttributes = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(attributes, {
+          context,
+          operation: 'post'
+        })
+        : attributes
 
       // Insert and get the new ID
       const result = await db(tableName).insert(dbAttributes).returning(idProperty)
@@ -964,7 +992,12 @@ export const RestApiKnexPlugin = {
       const mergedAttributes = { ...attributes, ...foreignKeyUpdates }
 
       // Strip non-database fields (computed and virtual) before database operation
-      const finalAttributes = stripNonDatabaseFields(mergedAttributes, context.schemaInfo)
+      const finalAttributes = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(mergedAttributes, {
+          context,
+          operation: 'put'
+        })
+        : mergedAttributes
 
       // Map 'id' to actual idProperty if needed (for PUT with specific ID)
       if (idProperty !== 'id' && inputRecord.data.id) {
@@ -1063,7 +1096,12 @@ export const RestApiKnexPlugin = {
       const mergedAttributes = { ...attributes, ...foreignKeyUpdates }
 
       // Strip non-database fields (computed and virtual) before database operation
-      const finalAttributes = stripNonDatabaseFields(mergedAttributes, context.schemaInfo)
+      const finalAttributes = storageAdapter?.toStorageRow
+        ? storageAdapter.toStorageRow(mergedAttributes, {
+          context,
+          operation: 'patch'
+        })
+        : mergedAttributes
 
       log.debug('[Knex] PATCH finalAttributes:', finalAttributes)
 

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}`)