json-rest-api 1.0.13 → 1.0.15

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

@@ -1,232 +1,232 @@
-import { ensureAnyApiSchema } from './lib/anyapi/schema-utils.js';
-import { AnyapiRegistry } from './lib/anyapi/anyapi-registry.js';
-import { RestApiValidationError } from '../../lib/rest-api-errors.js';
-import { createSchema } from 'json-rest-schema';
+import { ensureAnyApiSchema } from './lib/anyapi/schema-utils.js'
+import { AnyapiRegistry } from './lib/anyapi/anyapi-registry.js'
+import { RestApiValidationError } from '../../lib/rest-api-errors.js'
+import { createSchema } from 'json-rest-schema'
 import {
   DEFAULT_QUERY_LIMIT,
   DEFAULT_MAX_QUERY_LIMIT,
-} from './lib/querying-writing/knex-constants.js';
+} from './lib/querying-writing/knex-constants.js'
 import {
   calculatePaginationMeta,
   generatePaginationLinks,
   generateCursorPaginationLinks,
   buildCursorMeta,
   parseCursor,
-} from './lib/querying/knex-pagination-helpers.js';
-import { getUrlPrefix, buildResourceUrl } from './lib/querying/url-helpers.js';
+} from './lib/querying/knex-pagination-helpers.js'
+import { getUrlPrefix, buildResourceUrl } from './lib/querying/url-helpers.js'
 import {
   normalizeId,
   resolveFieldInfo,
   coerceValueForDefinition,
   normalizeFilterValues,
   ensureFilterableField,
-} from './lib/anyapi/utils/descriptor-helpers.js';
+} from './lib/anyapi/utils/descriptor-helpers.js'
 import {
   AnyapiQueryAdapter,
   preloadRelatedDescriptors,
-} from './lib/anyapi/query/anyapi-query-adapter.js';
+} from './lib/anyapi/query/anyapi-query-adapter.js'
 import {
   ensureSearchFieldsAreIndexed,
   generateSearchSchemaFromSchema,
-} from './lib/querying-writing/schema-helpers.js';
-import { buildFieldSelection } from './lib/querying-writing/knex-field-helpers.js';
+} from './lib/querying-writing/schema-helpers.js'
+import { buildFieldSelection } from './lib/querying-writing/knex-field-helpers.js'
 import {
   polymorphicFiltersHook,
   crossTableFiltersHook,
   basicFiltersHook,
-} from './lib/querying/knex-query-helpers.js';
-import { createStorageAdapter } from './lib/storage/storage-adapter.js';
+} from './lib/querying/knex-query-helpers.js'
+import { createStorageAdapter } from './lib/storage/storage-adapter.js'
 
-const DEFAULT_TENANT = 'default';
-const LINKS_TABLE = 'any_links';
+const DEFAULT_TENANT = 'default'
+const LINKS_TABLE = 'any_links'
 
 export const RestApiAnyapiKnexPlugin = {
   name: 'rest-api-anyapi-knex',
   dependencies: ['rest-api'],
 
-  async install({ helpers, vars, pluginOptions, api, log, addHook, addScopeMethod, scopes }) {
-    const options = pluginOptions || {};
-    const knex = options.knex;
-    const tenantId = options.tenantId || DEFAULT_TENANT;
+  async install ({ helpers, vars, pluginOptions, api, log, addHook, addScopeMethod, scopes }) {
+    const options = pluginOptions || {}
+    const knex = options.knex
+    const tenantId = options.tenantId || DEFAULT_TENANT
 
     if (!knex) {
-      throw new Error('AnyapiKnexPlugin requires a knex instance');
+      throw new Error('AnyapiKnexPlugin requires a knex instance')
     }
 
-    await ensureAnyApiSchema(knex);
+    await ensureAnyApiSchema(knex)
 
-    const registry = new AnyapiRegistry({ knex, log });
+    const registry = new AnyapiRegistry({ knex, log })
 
-    api.anyapi = api.anyapi || {};
-    api.anyapi.registry = registry;
-    api.anyapi.tenantId = tenantId;
+    api.anyapi = api.anyapi || {}
+    api.anyapi.registry = registry
+    api.anyapi.tenantId = tenantId
     api.knex = {
       instance: knex,
       helpers: {},
-    };
+    }
 
-    const storageAdapterCache = new Map();
+    const storageAdapterCache = new Map()
 
     const getScopeStorageAdapter = (scopeName) => {
-      if (!scopeName) return null;
-      const resource = api.resources?.[scopeName] || scopes?.[scopeName];
-      const schemaInfo = resource?.vars?.schemaInfo;
-      if (!schemaInfo) return null;
+      if (!scopeName) return null
+      const resource = api.resources?.[scopeName] || scopes?.[scopeName]
+      const schemaInfo = resource?.vars?.schemaInfo
+      if (!schemaInfo) return null
 
-      const cached = storageAdapterCache.get(scopeName);
+      const cached = storageAdapterCache.get(scopeName)
       if (cached && cached.schemaInfo === schemaInfo) {
-        return cached.adapter;
+        return cached.adapter
       }
 
-      const adapter = createStorageAdapter({ knex, schemaInfo });
-      storageAdapterCache.set(scopeName, { adapter, schemaInfo });
+      const adapter = createStorageAdapter({ knex, schemaInfo })
+      storageAdapterCache.set(scopeName, { adapter, schemaInfo })
       if (resource?.vars) {
-        resource.vars.storageAdapter = adapter;
+        resource.vars.storageAdapter = adapter
       }
-      return adapter;
-    };
+      return adapter
+    }
 
-    api.knex.helpers.getStorageAdapter = getScopeStorageAdapter;
-    helpers.getStorageAdapter = getScopeStorageAdapter;
+    api.knex.helpers.getStorageAdapter = getScopeStorageAdapter
+    helpers.getStorageAdapter = getScopeStorageAdapter
 
-    const scopeOptionsRegistry = new Map();
+    const scopeOptionsRegistry = new Map()
 
-    helpers.newTransaction = async () => knex.transaction();
+    helpers.newTransaction = async () => knex.transaction()
 
     addHook('release', 'anyapi-knex-release', {}, async ({ api }) => {
       if (api.knex?.instance) {
-        await api.knex.instance.destroy();
+        await api.knex.instance.destroy()
       }
-    });
+    })
 
     const getDescriptor = async (scopeName) => {
-      const descriptor = await registry.getDescriptor(tenantId, scopeName);
+      const descriptor = await registry.getDescriptor(tenantId, scopeName)
       if (!descriptor) {
-        throw new Error(`Descriptor not found for resource '${scopeName}'`);
+        throw new Error(`Descriptor not found for resource '${scopeName}'`)
       }
-      return descriptor;
-    };
+      return descriptor
+    }
 
     const applyFiltersToQuery = ({ query, filters, descriptor, searchSchema, adapter }) => {
-      if (!filters || Object.keys(filters).length === 0) return;
+      if (!filters || Object.keys(filters).length === 0) return
 
       for (const [field, rawValue] of Object.entries(filters)) {
-        const searchDef = searchSchema ? searchSchema[field] : null;
+        const searchDef = searchSchema ? searchSchema[field] : null
         if (searchDef) {
           const isAdvanced = Boolean(
-            searchDef.actualField?.includes('.')
-            || (Array.isArray(searchDef.oneOf) && searchDef.oneOf.some((entry) => entry.includes('.')))
-            || searchDef.polymorphicField
-            || typeof searchDef.applyFilter === 'function'
-          );
+            searchDef.actualField?.includes('.') ||
+            (Array.isArray(searchDef.oneOf) && searchDef.oneOf.some((entry) => entry.includes('.'))) ||
+            searchDef.polymorphicField ||
+            typeof searchDef.applyFilter === 'function'
+          )
           if (!isAdvanced && adapter) {
-            const columnRef = adapter.translateColumn(searchDef.actualField || field);
-            const operator = (searchDef.filterOperator || '=').toLowerCase();
+            const columnRef = adapter.translateColumn(searchDef.actualField || field)
+            const operator = (searchDef.filterOperator || '=').toLowerCase()
             const normalizedValues = normalizeFilterValues(rawValue, searchDef, {
               isRelationship: Boolean(searchDef.isRelationship),
-            });
-            const primaryValue = normalizedValues[0];
+            })
+            const primaryValue = normalizedValues[0]
             switch (operator) {
               case 'like':
-                query.whereRaw(`${columnRef} like ?`, [`%${primaryValue}%`]);
-                break;
+                query.whereRaw(`${columnRef} like ?`, [`%${primaryValue}%`])
+                break
               case 'in':
                 if (normalizedValues.includes(null) && normalizedValues.length === 1) {
-                  query.whereNull(columnRef);
+                  query.whereNull(columnRef)
                 } else if (normalizedValues.length > 1) {
-                  query.whereIn(columnRef, normalizedValues);
+                  query.whereIn(columnRef, normalizedValues)
                 } else if (primaryValue === null) {
-                  query.whereNull(columnRef);
+                  query.whereNull(columnRef)
                 } else {
-                  query.whereRaw(`${columnRef} = ?`, [primaryValue]);
+                  query.whereRaw(`${columnRef} = ?`, [primaryValue])
                 }
-                break;
+                break
               case 'between':
                 if (normalizedValues.length === 2) {
-                  query.whereBetween(columnRef, normalizedValues);
+                  query.whereBetween(columnRef, normalizedValues)
                 } else if (primaryValue === null) {
-                  query.whereNull(columnRef);
+                  query.whereNull(columnRef)
                 } else {
-                  query.whereRaw(`${columnRef} = ?`, [primaryValue]);
+                  query.whereRaw(`${columnRef} = ?`, [primaryValue])
                 }
-                break;
+                break
               default:
                 if (primaryValue === null) {
-                  query.whereNull(columnRef);
+                  query.whereNull(columnRef)
                 } else {
-                  query.whereRaw(`${columnRef} ${operator || '='} ?`, [primaryValue]);
+                  query.whereRaw(`${columnRef} ${operator || '='} ?`, [primaryValue])
                 }
-                break;
+                break
             }
-            continue;
+            continue
           }
           // Leave advanced search fields to downstream hooks
-          continue;
+          continue
         }
-        const fieldInfo = ensureFilterableField(descriptor, field);
+        const fieldInfo = ensureFilterableField(descriptor, field)
 
         const values = normalizeFilterValues(rawValue, fieldInfo.definition, {
           isRelationship: fieldInfo.isRelationship,
-        });
+        })
 
-        const nonNullValues = values.filter((value) => value !== null);
-        const hasNull = values.length !== nonNullValues.length;
+        const nonNullValues = values.filter((value) => value !== null)
+        const hasNull = values.length !== nonNullValues.length
 
         if (nonNullValues.length === 0 && hasNull) {
-          query.whereNull(fieldInfo.column);
-          continue;
+          query.whereNull(fieldInfo.column)
+          continue
         }
 
         if (nonNullValues.length === 1 && !hasNull) {
-          query.where(fieldInfo.column, nonNullValues[0]);
-          continue;
+          query.where(fieldInfo.column, nonNullValues[0])
+          continue
         }
 
         if (nonNullValues.length > 1 && !hasNull) {
-          query.whereIn(fieldInfo.column, nonNullValues);
-          continue;
+          query.whereIn(fieldInfo.column, nonNullValues)
+          continue
         }
 
         if (nonNullValues.length > 0 && hasNull) {
-          query.where(function filterGroup() {
-            this.whereIn(fieldInfo.column, nonNullValues).orWhereNull(fieldInfo.column);
-          });
+          query.where(function filterGroup () {
+            this.whereIn(fieldInfo.column, nonNullValues).orWhereNull(fieldInfo.column)
+          })
         }
       }
-    };
+    }
 
     const applySortingToQuery = ({ query, sort, descriptor, scope }) => {
-      let sortList = Array.isArray(sort) ? sort : (sort ? [sort] : []);
+      let sortList = Array.isArray(sort) ? sort : (sort ? [sort] : [])
 
       if (sortList.length === 0 && scope?.vars?.defaultSort) {
-        const defaultSort = scope.vars.defaultSort;
+        const defaultSort = scope.vars.defaultSort
         if (Array.isArray(defaultSort)) {
-          sortList = defaultSort;
+          sortList = defaultSort
         } else if (typeof defaultSort === 'string') {
-          sortList = [defaultSort];
+          sortList = [defaultSort]
         } else if (defaultSort && typeof defaultSort === 'object') {
-          const field = defaultSort.field || defaultSort.column || 'id';
-          const direction = (defaultSort.direction || '').toLowerCase() === 'desc' ? '-' : '';
-          sortList = [`${direction}${field}`];
+          const field = defaultSort.field || defaultSort.column || 'id'
+          const direction = (defaultSort.direction || '').toLowerCase() === 'desc' ? '-' : ''
+          sortList = [`${direction}${field}`]
         }
       }
 
-      const effectiveSort = sortList.length > 0 ? sortList : ['id'];
-      const descriptors = [];
+      const effectiveSort = sortList.length > 0 ? sortList : ['id']
+      const descriptors = []
 
       for (const entry of effectiveSort) {
-        const desc = typeof entry === 'string' && entry.startsWith('-');
-        const field = typeof entry === 'string' ? (desc ? entry.slice(1) : entry) : entry;
-        const fieldInfo = resolveFieldInfo(descriptor, field);
-        if (!fieldInfo?.column) continue;
-        query.orderBy(fieldInfo.column, desc ? 'desc' : 'asc');
+        const desc = typeof entry === 'string' && entry.startsWith('-')
+        const field = typeof entry === 'string' ? (desc ? entry.slice(1) : entry) : entry
+        const fieldInfo = resolveFieldInfo(descriptor, field)
+        if (!fieldInfo?.column) continue
+        query.orderBy(fieldInfo.column, desc ? 'desc' : 'asc')
         descriptors.push({
           field,
           column: fieldInfo.column,
           direction: desc ? 'desc' : 'asc',
           definition: fieldInfo.definition || null,
           isRelationship: fieldInfo.isRelationship || false,
-        });
+        })
       }
 
       if (descriptors.length === 0) {
@@ -236,39 +236,39 @@ export const RestApiAnyapiKnexPlugin = {
           direction: 'asc',
           definition: { type: 'id' },
           isRelationship: false,
-        });
+        })
       }
 
-      return descriptors;
-    };
+      return descriptors
+    }
 
     const buildQueryString = (queryParams = {}) => {
       const buildParts = (prefix, value) => {
-        const parts = [];
+        const parts = []
         if (Array.isArray(value)) {
-          if (value.length === 0) return parts;
-          parts.push(`${prefix}=${value.map((item) => encodeURIComponent(item)).join(',')}`);
-          return parts;
+          if (value.length === 0) return parts
+          parts.push(`${prefix}=${value.map((item) => encodeURIComponent(item)).join(',')}`)
+          return parts
         }
         if (value && typeof value === 'object') {
           for (const [key, subValue] of Object.entries(value)) {
-            if (subValue === undefined || subValue === null) continue;
-            const newPrefix = `${prefix}[${key}]`;
-            parts.push(...buildParts(newPrefix, subValue));
+            if (subValue === undefined || subValue === null) continue
+            const newPrefix = `${prefix}[${key}]`
+            parts.push(...buildParts(newPrefix, subValue))
           }
-          return parts;
+          return parts
         }
-        if (value === undefined || value === null) return parts;
-        parts.push(`${prefix}=${encodeURIComponent(value)}`);
-        return parts;
-      };
+        if (value === undefined || value === null) return parts
+        parts.push(`${prefix}=${encodeURIComponent(value)}`)
+        return parts
+      }
 
-      const parts = [];
+      const parts = []
       for (const [key, value] of Object.entries(queryParams)) {
-        parts.push(...buildParts(key, value));
+        parts.push(...buildParts(key, value))
       }
-      return parts.length > 0 ? `?${parts.join('&')}` : '';
-    };
+      return parts.length > 0 ? `?${parts.join('&')}` : ''
+    }
 
     const applyPaginationToQuery = ({
       query,
@@ -277,10 +277,10 @@ export const RestApiAnyapiKnexPlugin = {
       sortDescriptors,
       adapter,
     }) => {
-      const pageParams = queryParams?.page || {};
-      const scopeVars = scope?.vars || {};
-      const defaultLimit = scopeVars.queryDefaultLimit || DEFAULT_QUERY_LIMIT;
-      const maxLimit = scopeVars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT;
+      const pageParams = queryParams?.page || {}
+      const scopeVars = scope?.vars || {}
+      const defaultLimit = scopeVars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
+      const maxLimit = scopeVars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT
 
       const descriptors = (sortDescriptors && sortDescriptors.length > 0)
         ? sortDescriptors
@@ -290,15 +290,15 @@ export const RestApiAnyapiKnexPlugin = {
             direction: 'asc',
             definition: { type: 'id' },
             isRelationship: false,
-          }];
+          }]
 
-      const hasCursorParam = pageParams.after !== undefined || pageParams.before !== undefined;
-      const hasPageSize = pageParams.size !== undefined;
-      const hasPageNumber = pageParams.number !== undefined;
+      const hasCursorParam = pageParams.after !== undefined || pageParams.before !== undefined
+      const hasPageSize = pageParams.size !== undefined
+      const hasPageNumber = pageParams.number !== undefined
 
       const parseCursorOrThrow = (rawCursor, paramName) => {
         try {
-          return parseCursor(rawCursor);
+          return parseCursor(rawCursor)
         } catch (error) {
           throw new RestApiValidationError(
             `Invalid cursor format in ${paramName} parameter`,
@@ -309,88 +309,88 @@ export const RestApiAnyapiKnexPlugin = {
                 rule: 'invalid_cursor',
                 message: error.message,
               }],
-            },
-          );
+            }
+          )
         }
-      };
+      }
 
       const coerceCursorValues = (cursorMap) => {
-        const typed = {};
+        const typed = {}
         for (const descriptor of descriptors) {
-          if (descriptor.field === undefined) continue;
-          const raw = cursorMap[descriptor.field];
-          if (raw === undefined) continue;
+          if (descriptor.field === undefined) continue
+          const raw = cursorMap[descriptor.field]
+          if (raw === undefined) continue
           typed[descriptor.field] = coerceValueForDefinition(
             raw,
             descriptor.definition,
-            { isRelationship: descriptor.isRelationship },
-          );
+            { isRelationship: descriptor.isRelationship }
+          )
         }
-        return typed;
-      };
+        return typed
+      }
 
       const buildCursorPredicate = (cursorValues, operatorSelector) => {
         if (!descriptors || descriptors.length === 0) {
-          return;
+          return
         }
 
         if (descriptors.length === 1) {
-          const descriptor = descriptors[0];
-          const value = cursorValues[descriptor.field];
-          if (value === undefined) return;
-          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column;
-          const operator = operatorSelector(descriptor.direction);
+          const descriptor = descriptors[0]
+          const value = cursorValues[descriptor.field]
+          if (value === undefined) return
+          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
+          const operator = operatorSelector(descriptor.direction)
           if (adapter) {
-            query.whereRaw(`${columnRef} ${operator} ?`, [value]);
+            query.whereRaw(`${columnRef} ${operator} ?`, [value])
           } else {
-            query.where(columnRef, operator, value);
+            query.where(columnRef, operator, value)
           }
-          return;
+          return
         }
 
-        const translatedConditions = [];
+        const translatedConditions = []
 
         descriptors.forEach((descriptor, index) => {
-          const value = cursorValues[descriptor.field];
-          if (value === undefined) return;
+          const value = cursorValues[descriptor.field]
+          if (value === undefined) return
 
-          const chain = [];
+          const chain = []
           for (let i = 0; i < index; i += 1) {
-            const prev = descriptors[i];
-            const prevValue = cursorValues[prev.field];
-            if (prevValue === undefined) return;
-            const prevColumn = adapter ? adapter.translateColumn(prev.column) : prev.column;
-            chain.push({ column: prevColumn, operator: '=', value: prevValue });
+            const prev = descriptors[i]
+            const prevValue = cursorValues[prev.field]
+            if (prevValue === undefined) return
+            const prevColumn = adapter ? adapter.translateColumn(prev.column) : prev.column
+            chain.push({ column: prevColumn, operator: '=', value: prevValue })
           }
 
-          const operator = operatorSelector(descriptor.direction);
-          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column;
-          chain.push({ column: columnRef, operator, value });
-          translatedConditions.push(chain);
-        });
+          const operator = operatorSelector(descriptor.direction)
+          const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
+          chain.push({ column: columnRef, operator, value })
+          translatedConditions.push(chain)
+        })
 
         if (translatedConditions.length === 0) {
-          return;
+          return
         }
 
-        const predicateParts = [];
-        const predicateBindings = [];
+        const predicateParts = []
+        const predicateBindings = []
         translatedConditions.forEach((chain) => {
           const chainParts = chain.map(({ column, operator, value }) => {
-            predicateBindings.push(value);
-            return `${column} ${operator} ?`;
-          });
-          predicateParts.push(`(${chainParts.join(' AND ')})`);
-        });
+            predicateBindings.push(value)
+            return `${column} ${operator} ?`
+          })
+          predicateParts.push(`(${chainParts.join(' AND ')})`)
+        })
 
         if (predicateParts.length > 0) {
-          const combined = predicateParts.join(' OR ');
-          query.whereRaw(`(${combined})`, predicateBindings);
+          const combined = predicateParts.join(' OR ')
+          query.whereRaw(`(${combined})`, predicateBindings)
         }
-      };
+      }
 
       const ensurePageSize = () => {
-        const requestedSize = Number(pageParams.size ?? defaultLimit);
+        const requestedSize = Number(pageParams.size ?? defaultLimit)
         if (!Number.isFinite(requestedSize) || requestedSize <= 0) {
           throw new RestApiValidationError('Page size must be greater than 0', {
             fields: ['page.size'],
@@ -399,10 +399,10 @@ export const RestApiAnyapiKnexPlugin = {
               rule: 'min_value',
               message: 'Page size must be a positive number',
             }],
-          });
+          })
         }
-        return Math.min(Math.trunc(requestedSize), maxLimit);
-      };
+        return Math.min(Math.trunc(requestedSize), maxLimit)
+      }
 
       if (hasCursorParam || (hasPageSize && !hasPageNumber)) {
         if (pageParams.after && pageParams.before) {
@@ -415,54 +415,54 @@ export const RestApiAnyapiKnexPlugin = {
                 rule: 'conflict',
                 message: 'Provide either page[after] or page[before], not both',
               }],
-            },
-          );
+            }
+          )
         }
 
-        const pageSize = ensurePageSize();
-        query.limit(pageSize + 1);
-
-      if (pageParams.after) {
-        const cursorMap = parseCursorOrThrow(pageParams.after, 'after');
-        const cursorValues = coerceCursorValues(cursorMap);
-        buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '<' : '>'));
-      } else if (pageParams.before) {
-        const cursorMap = parseCursorOrThrow(pageParams.before, 'before');
-        const cursorValues = coerceCursorValues(cursorMap);
-        buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '>' : '<'));
-      }
+        const pageSize = ensurePageSize()
+        query.limit(pageSize + 1)
+
+        if (pageParams.after) {
+          const cursorMap = parseCursorOrThrow(pageParams.after, 'after')
+          const cursorValues = coerceCursorValues(cursorMap)
+          buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '<' : '>'))
+        } else if (pageParams.before) {
+          const cursorMap = parseCursorOrThrow(pageParams.before, 'before')
+          const cursorValues = coerceCursorValues(cursorMap)
+          buildCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '>' : '<'))
+        }
 
         return {
           mode: 'cursor',
           pageSize,
           sortDescriptors: descriptors,
-        };
+        }
       }
 
       if (hasPageSize || hasPageNumber) {
-        const pageSize = ensurePageSize();
-        const pageNumber = Math.trunc(Number(pageParams.number ?? 1));
-        const safePageNumber = Number.isFinite(pageNumber) && pageNumber > 0 ? pageNumber : 1;
-        const offset = (safePageNumber - 1) * pageSize;
+        const pageSize = ensurePageSize()
+        const pageNumber = Math.trunc(Number(pageParams.number ?? 1))
+        const safePageNumber = Number.isFinite(pageNumber) && pageNumber > 0 ? pageNumber : 1
+        const offset = (safePageNumber - 1) * pageSize
 
-        query.limit(pageSize).offset(offset);
+        query.limit(pageSize).offset(offset)
 
         return {
           mode: 'offset',
           page: safePageNumber,
           pageSize,
           sortDescriptors: descriptors,
-        };
+        }
       }
 
-      query.limit(defaultLimit);
+      query.limit(defaultLimit)
       return {
         mode: 'default',
         page: 1,
         pageSize: defaultLimit,
         sortDescriptors: descriptors,
-      };
-    };
+      }
+    }
 
     const canonicalizeLinkPair = ({
       tenantId,
@@ -473,11 +473,11 @@ export const RestApiAnyapiKnexPlugin = {
       rightResource,
       rightId,
     }) => {
-      const normalizedLeftId = normalizeId(leftId);
-      const normalizedRightId = normalizeId(rightId);
+      const normalizedLeftId = normalizeId(leftId)
+      const normalizedRightId = normalizeId(rightId)
 
       if (normalizedLeftId == null || normalizedRightId == null) {
-        return null;
+        return null
       }
 
       if (inverseRelationshipKey && inverseRelationshipKey < relationshipKey) {
@@ -489,7 +489,7 @@ export const RestApiAnyapiKnexPlugin = {
           left_id: normalizedRightId,
           right_resource: leftResource,
           right_id: normalizedLeftId,
-        };
+        }
       }
 
       return {
@@ -500,8 +500,8 @@ export const RestApiAnyapiKnexPlugin = {
         left_id: normalizedLeftId,
         right_resource: rightResource,
         right_id: normalizedRightId,
-      };
-    };
+      }
+    }
 
     const buildLinkIdentity = (canonicalRow) => ({
       tenant_id: canonicalRow.tenant_id,
@@ -510,63 +510,63 @@ export const RestApiAnyapiKnexPlugin = {
       left_id: canonicalRow.left_id,
       right_resource: canonicalRow.right_resource,
       right_id: canonicalRow.right_id,
-    });
+    })
 
     const findInverseManyToMany = async ({ descriptor, relInfo }) => {
-      if (!relInfo?.target) return null;
+      if (!relInfo?.target) return null
 
-      let targetDescriptor;
+      let targetDescriptor
       try {
-        targetDescriptor = await getDescriptor(relInfo.target);
+        targetDescriptor = await getDescriptor(relInfo.target)
       } catch (error) {
-        return null;
+        return null
       }
 
-      const entries = Object.entries(targetDescriptor.manyToMany || {});
+      const entries = Object.entries(targetDescriptor.manyToMany || {})
       for (const [candidateName, candidateInfo] of entries) {
-        const candidateTarget = candidateInfo.target || descriptor.resource;
-        if (candidateTarget !== descriptor.resource) continue;
+        const candidateTarget = candidateInfo.target || descriptor.resource
+        if (candidateTarget !== descriptor.resource) continue
 
         if (relInfo.through && candidateInfo.through && relInfo.through !== candidateInfo.through) {
-          continue;
+          continue
         }
 
         if (
           relInfo.foreignKey && relInfo.otherKey &&
           candidateInfo.foreignKey && candidateInfo.otherKey
         ) {
-          const foreignMatches = relInfo.foreignKey === candidateInfo.otherKey;
-          const otherMatches = relInfo.otherKey === candidateInfo.foreignKey;
-          if (!foreignMatches || !otherMatches) continue;
+          const foreignMatches = relInfo.foreignKey === candidateInfo.otherKey
+          const otherMatches = relInfo.otherKey === candidateInfo.foreignKey
+          if (!foreignMatches || !otherMatches) continue
         }
 
-        const relationshipKey = candidateInfo.relationship
-          || `${targetDescriptor.tenant}:${targetDescriptor.resource}:${candidateName}`;
+        const relationshipKey = candidateInfo.relationship ||
+          `${targetDescriptor.tenant}:${targetDescriptor.resource}:${candidateName}`
 
         return {
           descriptor: targetDescriptor,
           relName: candidateName,
           relInfo: candidateInfo,
           relationshipKey,
-        };
+        }
       }
 
-      return null;
-    };
+      return null
+    }
 
     const getManyToManyInfo = async (scopeName, relName) => {
-      const descriptor = await getDescriptor(scopeName);
-      const relInfo = descriptor.manyToMany?.[relName];
-      if (!relInfo) return null;
-      const relationshipKey = relInfo.relationship || `${descriptor.tenant}:${descriptor.resource}:${relName}`;
-      const inverse = await findInverseManyToMany({ descriptor, relInfo });
-      const inverseRelationshipKey = inverse?.relationshipKey || null;
-      return { descriptor, relInfo, relationshipKey, inverseRelationshipKey };
-    };
+      const descriptor = await getDescriptor(scopeName)
+      const relInfo = descriptor.manyToMany?.[relName]
+      if (!relInfo) return null
+      const relationshipKey = relInfo.relationship || `${descriptor.tenant}:${descriptor.resource}:${relName}`
+      const inverse = await findInverseManyToMany({ descriptor, relInfo })
+      const inverseRelationshipKey = inverse?.relationshipKey || null
+      return { descriptor, relInfo, relationshipKey, inverseRelationshipKey }
+    }
 
     const loadLinkRowsForResource = async ({ descriptor, relationshipKey, resourceId, db }) => {
-      const ownerId = normalizeId(resourceId);
-      if (ownerId == null) return new Map();
+      const ownerId = normalizeId(resourceId)
+      if (ownerId == null) return new Map()
 
       const rows = await db(LINKS_TABLE)
         .where('tenant_id', descriptor.tenant)
@@ -575,36 +575,36 @@ export const RestApiAnyapiKnexPlugin = {
             .where((q) => {
               q.where('relationship', relationshipKey)
                 .andWhere('left_resource', descriptor.resource)
-                .andWhere('left_id', ownerId);
+                .andWhere('left_id', ownerId)
             })
             .orWhere((q) => {
               q.where('inverse_relationship', relationshipKey)
                 .andWhere('right_resource', descriptor.resource)
-                .andWhere('right_id', ownerId);
-            });
+                .andWhere('right_id', ownerId)
+            })
         })
-        .select('id', 'relationship', 'inverse_relationship', 'left_resource', 'left_id', 'right_resource', 'right_id');
+        .select('id', 'relationship', 'inverse_relationship', 'left_resource', 'left_id', 'right_resource', 'right_id')
 
-      const map = new Map();
+      const map = new Map()
 
       for (const row of rows) {
-        let relatedResource;
-        let relatedId;
-        let otherKey = null;
+        let relatedResource
+        let relatedId
+        let otherKey = null
 
         if (row.relationship === relationshipKey && row.left_resource === descriptor.resource) {
-          relatedResource = row.right_resource;
-          relatedId = normalizeId(row.right_id);
-          otherKey = row.inverse_relationship || null;
+          relatedResource = row.right_resource
+          relatedId = normalizeId(row.right_id)
+          otherKey = row.inverse_relationship || null
         } else if (row.inverse_relationship === relationshipKey && row.right_resource === descriptor.resource) {
-          relatedResource = row.left_resource;
-          relatedId = normalizeId(row.left_id);
-          otherKey = row.relationship || null;
+          relatedResource = row.left_resource
+          relatedId = normalizeId(row.left_id)
+          otherKey = row.relationship || null
         } else {
-          continue;
+          continue
         }
 
-        if (relatedId == null) continue;
+        if (relatedId == null) continue
 
         const canonical = canonicalizeLinkPair({
           tenantId: descriptor.tenant,
@@ -614,27 +614,27 @@ export const RestApiAnyapiKnexPlugin = {
           leftId: ownerId,
           rightResource: relatedResource,
           rightId: relatedId,
-        });
+        })
 
-        if (!canonical) continue;
+        if (!canonical) continue
 
         map.set(relatedId, {
           rowId: row.id,
           relatedResource,
           canonical,
           otherKey,
-        });
+        })
       }
 
-      return map;
-    };
+      return map
+    }
 
     const fetchLinksForParents = async ({ descriptor, relationshipKey, parentIds, db }) => {
       const normalizedIds = parentIds
         .map((id) => normalizeId(id))
-        .filter((id) => id !== null);
+        .filter((id) => id !== null)
 
-      if (normalizedIds.length === 0) return [];
+      if (normalizedIds.length === 0) return []
 
       const rows = await db(LINKS_TABLE)
         .where('tenant_id', descriptor.tenant)
@@ -643,68 +643,68 @@ export const RestApiAnyapiKnexPlugin = {
             .where((q) => {
               q.where('relationship', relationshipKey)
                 .andWhere('left_resource', descriptor.resource)
-                .whereIn('left_id', normalizedIds);
+                .whereIn('left_id', normalizedIds)
             })
             .orWhere((q) => {
               q.where('inverse_relationship', relationshipKey)
                 .andWhere('right_resource', descriptor.resource)
-                .whereIn('right_id', normalizedIds);
-            });
+                .whereIn('right_id', normalizedIds)
+            })
         })
-        .select('relationship', 'inverse_relationship', 'left_resource', 'left_id', 'right_resource', 'right_id');
+        .select('relationship', 'inverse_relationship', 'left_resource', 'left_id', 'right_resource', 'right_id')
 
-      const results = [];
+      const results = []
 
       for (const row of rows) {
-        let parentId;
-        let childId;
-        let childType;
+        let parentId
+        let childId
+        let childType
 
         if (row.relationship === relationshipKey && row.left_resource === descriptor.resource) {
-          parentId = normalizeId(row.left_id);
-          childId = normalizeId(row.right_id);
-          childType = row.right_resource;
+          parentId = normalizeId(row.left_id)
+          childId = normalizeId(row.right_id)
+          childType = row.right_resource
         } else if (row.inverse_relationship === relationshipKey && row.right_resource === descriptor.resource) {
-          parentId = normalizeId(row.right_id);
-          childId = normalizeId(row.left_id);
-          childType = row.left_resource;
+          parentId = normalizeId(row.right_id)
+          childId = normalizeId(row.left_id)
+          childType = row.left_resource
         } else {
-          continue;
+          continue
         }
 
-        if (parentId == null || childId == null) continue;
+        if (parentId == null || childId == null) continue
 
-        results.push({ parentId, childId, childType });
+        results.push({ parentId, childId, childType })
       }
 
-      return results;
-    };
+      return results
+    }
 
     const ensureTargetsExist = async ({ relInfo, relData, transaction }) => {
-      const relArray = Array.isArray(relData) ? relData : [];
-      if (relArray.length === 0) return;
-      const targetScope = api.resources[relInfo.target];
+      const relArray = Array.isArray(relData) ? relData : []
+      if (relArray.length === 0) return
+      const targetScope = api.resources[relInfo.target]
       if (!targetScope) {
-        throw new Error(`Target resource '${relInfo.target}' not found`);
+        throw new Error(`Target resource '${relInfo.target}' not found`)
       }
       for (const identifier of relArray) {
         if (!identifier?.id) {
-          throw new Error('Relationship data requires resource identifier with id');
+          throw new Error('Relationship data requires resource identifier with id')
         }
         if (identifier.type && identifier.type !== relInfo.target) {
-          throw new Error(`Relationship expects type '${relInfo.target}' but received '${identifier.type}'`);
+          throw new Error(`Relationship expects type '${relInfo.target}' but received '${identifier.type}'`)
         }
-        await targetScope.get({ id: identifier.id, transaction, simplified: false });
+        await targetScope.get({ id: identifier.id, transaction, simplified: false })
       }
-    };
+    }
 
     const attachLinks = async ({ descriptor, relInfo, relationshipKey, inverseRelationshipKey, leftId, relData, db }) => {
-      const relArray = Array.isArray(relData) ? relData : [];
-      if (relArray.length === 0) return;
+      const relArray = Array.isArray(relData) ? relData : []
+      if (relArray.length === 0) return
 
       for (const identifier of relArray) {
-        const rightId = normalizeId(identifier.id);
-        if (rightId == null) continue;
+        const rightId = normalizeId(identifier.id)
+        if (rightId == null) continue
 
         const canonical = canonicalizeLinkPair({
           tenantId: descriptor.tenant,
@@ -714,15 +714,15 @@ export const RestApiAnyapiKnexPlugin = {
           leftId,
           rightResource: relInfo.target,
           rightId,
-        });
+        })
 
-        if (!canonical) continue;
+        if (!canonical) continue
 
-        const identity = buildLinkIdentity(canonical);
+        const identity = buildLinkIdentity(canonical)
 
         const existing = await db(LINKS_TABLE)
           .where(identity)
-          .first();
+          .first()
 
         if (existing) {
           if (!existing.inverse_relationship && canonical.inverse_relationship) {
@@ -731,9 +731,9 @@ export const RestApiAnyapiKnexPlugin = {
               .update({
                 inverse_relationship: canonical.inverse_relationship,
                 updated_at: db.fn.now(),
-              });
+              })
           }
-          continue;
+          continue
         }
 
         await db(LINKS_TABLE).insert({
@@ -741,19 +741,19 @@ export const RestApiAnyapiKnexPlugin = {
           payload: null,
           created_at: db.fn.now(),
           updated_at: db.fn.now(),
-        });
+        })
       }
-    };
+    }
 
     api.anyapi.links = {
       attachMany: async ({ context, scopeName, relName, relDef, relData }) => {
-        const info = await getManyToManyInfo(scopeName, relName);
+        const info = await getManyToManyInfo(scopeName, relName)
         if (!info) {
-          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`);
+          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`)
         }
-        const db = context.transaction || context.db || api.knex.instance;
-        const leftId = normalizeId(context.id);
-        await ensureTargetsExist({ relInfo: info.relInfo, relData, transaction: context.transaction });
+        const db = context.transaction || context.db || api.knex.instance
+        const leftId = normalizeId(context.id)
+        await ensureTargetsExist({ relInfo: info.relInfo, relData, transaction: context.transaction })
         await attachLinks({
           descriptor: info.descriptor,
           relInfo: info.relInfo,
@@ -762,16 +762,16 @@ export const RestApiAnyapiKnexPlugin = {
           leftId,
           relData,
           db,
-        });
+        })
       },
       syncMany: async ({ context, scopeName, relName, relDef, relData, isUpdate }) => {
-        const info = await getManyToManyInfo(scopeName, relName);
+        const info = await getManyToManyInfo(scopeName, relName)
         if (!info) {
-          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`);
+          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`)
         }
-        const db = context.transaction || context.db || api.knex.instance;
-        const leftId = normalizeId(context.id);
-        await ensureTargetsExist({ relInfo: info.relInfo, relData, transaction: context.transaction });
+        const db = context.transaction || context.db || api.knex.instance
+        const leftId = normalizeId(context.id)
+        await ensureTargetsExist({ relInfo: info.relInfo, relData, transaction: context.transaction })
         if (isUpdate) {
           await syncLinks({
             descriptor: info.descriptor,
@@ -781,7 +781,7 @@ export const RestApiAnyapiKnexPlugin = {
             leftId,
             relData,
             db,
-          });
+          })
         } else {
           await attachLinks({
             descriptor: info.descriptor,
@@ -791,16 +791,16 @@ export const RestApiAnyapiKnexPlugin = {
             leftId,
             relData,
             db,
-          });
+          })
         }
       },
       removeMany: async ({ context, scopeName, relName, relData }) => {
-        const info = await getManyToManyInfo(scopeName, relName);
+        const info = await getManyToManyInfo(scopeName, relName)
         if (!info) {
-          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`);
+          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`)
         }
-        const db = context.transaction || context.db || api.knex.instance;
-        const leftId = normalizeId(context.id);
+        const db = context.transaction || context.db || api.knex.instance
+        const leftId = normalizeId(context.id)
         await removeLinks({
           descriptor: info.descriptor,
           relInfo: info.relInfo,
@@ -809,15 +809,15 @@ export const RestApiAnyapiKnexPlugin = {
           leftId,
           relData,
           db,
-        });
+        })
       },
       listMany: async ({ context, scopeName, relName }) => {
-        const info = await getManyToManyInfo(scopeName, relName);
+        const info = await getManyToManyInfo(scopeName, relName)
         if (!info) {
-          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`);
+          throw new Error(`Many-to-many relationship '${relName}' not found on '${scopeName}'`)
         }
-        const db = context.transaction || context.db || api.knex.instance;
-        const leftId = normalizeId(context.id);
+        const db = context.transaction || context.db || api.knex.instance
+        const leftId = normalizeId(context.id)
         return listLinks({
           descriptor: info.descriptor,
           relInfo: info.relInfo,
@@ -825,43 +825,43 @@ export const RestApiAnyapiKnexPlugin = {
           inverseRelationshipKey: info.inverseRelationshipKey,
           leftId,
           db,
-        });
+        })
       },
       fetchManyToManyRows: async ({ scopeName, relName, parentIds, context }) => {
-        const info = await getManyToManyInfo(scopeName, relName);
-        if (!info) return [];
-        const db = context.db || context.transaction || api.knex.instance;
+        const info = await getManyToManyInfo(scopeName, relName)
+        if (!info) return []
+        const db = context.db || context.transaction || api.knex.instance
         return fetchLinksForParents({
           descriptor: info.descriptor,
           relationshipKey: info.relationshipKey,
           parentIds,
           db,
-        });
+        })
       },
-    };
+    }
 
     const syncLinks = async ({ descriptor, relInfo, relationshipKey, inverseRelationshipKey, leftId, relData, db }) => {
-      const relArray = Array.isArray(relData) ? relData : [];
+      const relArray = Array.isArray(relData) ? relData : []
       const existingMap = await loadLinkRowsForResource({
         descriptor,
         relationshipKey,
         resourceId: leftId,
         db,
-      });
+      })
 
       const desired = new Set(
         relArray
           .map((identifier) => normalizeId(identifier.id))
-          .filter((id) => id !== null),
-      );
+          .filter((id) => id !== null)
+      )
 
-      const existingIds = new Set(existingMap.keys());
+      const existingIds = new Set(existingMap.keys())
 
-      const toAdd = [...desired].filter((id) => !existingIds.has(id));
-      const toRemove = [...existingIds].filter((id) => !desired.has(id));
+      const toAdd = [...desired].filter((id) => !existingIds.has(id))
+      const toRemove = [...existingIds].filter((id) => !desired.has(id))
 
       if (toAdd.length > 0) {
-        const data = toAdd.map((id) => ({ id }));
+        const data = toAdd.map((id) => ({ id }))
         await attachLinks({
           descriptor,
           relInfo,
@@ -870,41 +870,41 @@ export const RestApiAnyapiKnexPlugin = {
           leftId,
           relData: data,
           db,
-        });
+        })
       }
 
       if (toRemove.length > 0) {
         for (const id of toRemove) {
-          const entry = existingMap.get(id);
-          if (!entry?.canonical) continue;
+          const entry = existingMap.get(id)
+          if (!entry?.canonical) continue
           await db(LINKS_TABLE)
             .where(buildLinkIdentity(entry.canonical))
-            .delete();
+            .delete()
         }
       }
-    };
+    }
 
     const removeLinks = async ({ descriptor, relInfo, relationshipKey, inverseRelationshipKey, leftId, relData, db }) => {
-      const relArray = Array.isArray(relData) ? relData : [];
-      if (relArray.length === 0) return;
+      const relArray = Array.isArray(relData) ? relData : []
+      if (relArray.length === 0) return
 
       const existingMap = await loadLinkRowsForResource({
         descriptor,
         relationshipKey,
         resourceId: leftId,
         db,
-      });
+      })
 
       for (const identifier of relArray) {
-        const relatedId = normalizeId(identifier.id);
-        if (relatedId == null) continue;
+        const relatedId = normalizeId(identifier.id)
+        if (relatedId == null) continue
 
-        const entry = existingMap.get(relatedId);
+        const entry = existingMap.get(relatedId)
         if (entry?.canonical) {
           await db(LINKS_TABLE)
             .where(buildLinkIdentity(entry.canonical))
-            .delete();
-          continue;
+            .delete()
+          continue
         }
 
         const canonical = canonicalizeLinkPair({
@@ -915,15 +915,15 @@ export const RestApiAnyapiKnexPlugin = {
           leftId,
           rightResource: relInfo.target,
           rightId: relatedId,
-        });
+        })
 
-        if (!canonical) continue;
+        if (!canonical) continue
 
         await db(LINKS_TABLE)
           .where(buildLinkIdentity(canonical))
-          .delete();
+          .delete()
       }
-    };
+    }
 
     const listLinks = async ({ descriptor, relInfo, relationshipKey, leftId, db }) => {
       const existingMap = await loadLinkRowsForResource({
@@ -931,244 +931,244 @@ export const RestApiAnyapiKnexPlugin = {
         relationshipKey,
         resourceId: leftId,
         db,
-      });
+      })
 
       return [...existingMap.entries()].map(([relatedId, entry]) => ({
         type: entry.relatedResource || relInfo.target,
         id: relatedId,
-      }));
-    };
+      }))
+    }
 
     helpers.dataExists = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
 
       const row = await context.db(canonical.tableName)
         .select('id')
         .where(canonical.tenantColumn, descriptor.tenant)
         .where(canonical.resourceColumn, descriptor.resource)
         .where('id', id)
-        .first();
+        .first()
 
-      return !!row;
-    };
+      return !!row
+    }
 
     helpers.dataPost = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const attributes = context.inputRecord?.data?.attributes || {};
-      const row = translateAttributesForStorage(attributes, descriptor);
-      row[canonical.tenantColumn] = descriptor.tenant;
-      row[canonical.resourceColumn] = descriptor.resource;
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const attributes = context.inputRecord?.data?.attributes || {}
+      const row = translateAttributesForStorage(attributes, descriptor)
+      row[canonical.tenantColumn] = descriptor.tenant
+      row[canonical.resourceColumn] = descriptor.resource
 
       const result = await context.db(canonical.tableName)
         .insert(row)
-        .returning('id');
+        .returning('id')
 
-      const inserted = Array.isArray(result) ? result[0] : result;
+      const inserted = Array.isArray(result) ? result[0] : result
       if (inserted && typeof inserted === 'object' && 'id' in inserted) {
-        return inserted.id;
+        return inserted.id
       }
-      return inserted;
-    };
+      return inserted
+    }
 
     helpers.dataPut = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
-      const attributes = context.inputRecord?.data?.attributes || {};
-      const row = translateAttributesForStorage(attributes, descriptor);
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
+      const attributes = context.inputRecord?.data?.attributes || {}
+      const row = translateAttributesForStorage(attributes, descriptor)
 
-      row[canonical.resourceColumn] = descriptor.resource;
-      row[canonical.tenantColumn] = descriptor.tenant;
+      row[canonical.resourceColumn] = descriptor.resource
+      row[canonical.tenantColumn] = descriptor.tenant
 
       const updateRow = Object.fromEntries(
         Object.entries(row).filter(([, value]) => value !== undefined)
-      );
+      )
 
       if (Object.keys(updateRow).length === 0) {
-        return 0;
+        return 0
       }
 
       const result = await context.db(canonical.tableName)
         .where('id', id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .update(updateRow);
+        .update(updateRow)
 
-      return result;
-    };
+      return result
+    }
 
     helpers.dataPatch = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
-      const attributes = context.inputRecord?.data?.attributes || {};
-      const row = translateAttributesForStorage(attributes, descriptor);
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
+      const attributes = context.inputRecord?.data?.attributes || {}
+      const row = translateAttributesForStorage(attributes, descriptor)
 
       const updateRow = Object.fromEntries(
         Object.entries(row).filter(([, value]) => value !== undefined)
-      );
+      )
 
       if (Object.keys(updateRow).length === 0) {
-        return 0;
+        return 0
       }
 
       const result = await context.db(canonical.tableName)
         .where('id', id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .update(updateRow);
+        .update(updateRow)
 
-      return result;
-    };
+      return result
+    }
 
     helpers.dataDelete = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
 
       const result = await context.db(canonical.tableName)
         .where('id', id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .delete();
+        .delete()
 
-      return result;
-    };
+      return result
+    }
 
     helpers.dataGetMinimal = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
-      const scope = api.resources?.[scopeName];
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
+      const scope = api.resources?.[scopeName]
 
       const row = await context.db(canonical.tableName)
         .where('id', id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .first();
+        .first()
 
-      if (!row) return null;
-      const translated = translateRecordFromStorage(row, descriptor);
+      if (!row) return null
+      const translated = translateRecordFromStorage(row, descriptor)
       const minimal = {
         type: descriptor.resource,
         id: String(row.id),
         attributes: translated.attributes,
         relationships: translated.relationships,
-      };
+      }
       if (scope) {
         minimal.links = {
           self: buildResourceUrl(context, scope, scopeName, minimal.id),
-        };
+        }
       }
-      return minimal;
-    };
+      return minimal
+    }
 
     const parseIncludeTree = (includeParam) => {
-      const tree = {};
-      if (!includeParam) return tree;
+      const tree = {}
+      if (!includeParam) return tree
 
       const pushPath = (raw) => {
-        if (!raw) return;
-        const segments = raw.split('.').map((segment) => segment.trim()).filter(Boolean);
-        if (segments.length === 0) return;
-        let node = tree;
+        if (!raw) return
+        const segments = raw.split('.').map((segment) => segment.trim()).filter(Boolean)
+        if (segments.length === 0) return
+        let node = tree
         for (const segment of segments) {
-          node[segment] = node[segment] || {};
-          node = node[segment];
+          node[segment] = node[segment] || {}
+          node = node[segment]
         }
-      };
+      }
 
       if (Array.isArray(includeParam)) {
         for (const entry of includeParam) {
-          String(entry).split(',').forEach((part) => pushPath(part.trim()));
+          String(entry).split(',').forEach((part) => pushPath(part.trim()))
         }
       } else {
-        String(includeParam).split(',').forEach((part) => pushPath(part.trim()));
+        String(includeParam).split(',').forEach((part) => pushPath(part.trim()))
       }
 
-      return tree;
-    };
+      return tree
+    }
 
     const collectIncludes = async ({ descriptor, resources, includeTree, context, includes, seen }) => {
-      const entries = Object.entries(includeTree || {});
-      if (entries.length === 0 || !resources || resources.length === 0) return;
+      const entries = Object.entries(includeTree || {})
+      if (entries.length === 0 || !resources || resources.length === 0) return
 
-      const db = context.db || context.transaction || api.knex.instance;
+      const db = context.db || context.transaction || api.knex.instance
       const addSelfLink = (resource, resourceType) => {
-        const targetScope = api.resources?.[resourceType];
-        if (!targetScope) return;
-        resource.links = resource.links || {};
-        resource.links.self = buildResourceUrl(context, targetScope, resourceType, resource.id);
-      };
+        const targetScope = api.resources?.[resourceType]
+        if (!targetScope) return
+        resource.links = resource.links || {}
+        resource.links.self = buildResourceUrl(context, targetScope, resourceType, resource.id)
+      }
 
       for (const [relName, childTree] of entries) {
-        const childKeys = Object.keys(childTree || {});
+        const childKeys = Object.keys(childTree || {})
 
-        const belongsToInfo = descriptor.belongsTo?.[relName];
+        const belongsToInfo = descriptor.belongsTo?.[relName]
         if (belongsToInfo) {
           const ids = [...new Set(resources
             .map((resource) => resource.relationships?.[relName]?.data?.id)
-            .filter((id) => id !== undefined && id !== null))];
+            .filter((id) => id !== undefined && id !== null))]
 
-          if (ids.length === 0) continue;
+          if (ids.length === 0) continue
 
-          const targetDescriptor = await registry.getDescriptor(tenantId, belongsToInfo.target);
-          if (!targetDescriptor) continue;
+          const targetDescriptor = await registry.getDescriptor(tenantId, belongsToInfo.target)
+          if (!targetDescriptor) continue
 
           const rows = await db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-            .whereIn('id', ids);
+            .whereIn('id', ids)
 
-          const newResources = [];
+          const newResources = []
           for (const row of rows) {
-            const includeKey = `${targetDescriptor.resource}:${row.id}`;
-            if (seen.has(includeKey)) continue;
-            seen.add(includeKey);
-            const translated = translateRecordFromStorage(row, targetDescriptor);
+            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            if (seen.has(includeKey)) continue
+            seen.add(includeKey)
+            const translated = translateRecordFromStorage(row, targetDescriptor)
             const includeResource = {
               type: targetDescriptor.resource,
               id: String(row.id),
               attributes: translated.attributes,
-            };
+            }
             if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-              includeResource.relationships = translated.relationships;
+              includeResource.relationships = translated.relationships
             }
-            addSelfLink(includeResource, targetDescriptor.resource);
-            includes.push(includeResource);
-            newResources.push(includeResource);
+            addSelfLink(includeResource, targetDescriptor.resource)
+            includes.push(includeResource)
+            newResources.push(includeResource)
           }
 
           if (childKeys.length > 0 && newResources.length > 0) {
-            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
-            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
+            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
+            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
             await collectIncludes({
               descriptor: targetDescriptor,
               resources: newResources,
@@ -1176,79 +1176,79 @@ export const RestApiAnyapiKnexPlugin = {
               context,
               includes,
               seen,
-            });
+            })
           }
-          continue;
+          continue
         }
 
-        const polymorphicInfo = descriptor.polymorphicBelongsTo?.[relName];
+        const polymorphicInfo = descriptor.polymorphicBelongsTo?.[relName]
         if (polymorphicInfo) {
-          const typeToIds = new Map();
+          const typeToIds = new Map()
           for (const resource of resources) {
-            const relData = resource.relationships?.[relName]?.data;
-            if (!relData?.type || relData?.id == null) continue;
-            const targetType = String(relData.type);
-            const targetId = normalizeId(relData.id);
-            if (targetId == null) continue;
+            const relData = resource.relationships?.[relName]?.data
+            if (!relData?.type || relData?.id == null) continue
+            const targetType = String(relData.type)
+            const targetId = normalizeId(relData.id)
+            if (targetId == null) continue
             if (!typeToIds.has(targetType)) {
-              typeToIds.set(targetType, new Set());
+              typeToIds.set(targetType, new Set())
             }
-            typeToIds.get(targetType).add(targetId);
+            typeToIds.get(targetType).add(targetId)
           }
 
-          const newResources = [];
+          const newResources = []
           for (const [targetType, idSet] of typeToIds.entries()) {
-            if (idSet.size === 0) continue;
-            let targetDescriptor;
+            if (idSet.size === 0) continue
+            let targetDescriptor
             try {
-              targetDescriptor = await getDescriptor(targetType);
+              targetDescriptor = await getDescriptor(targetType)
             } catch (error) {
-              continue;
+              continue
             }
 
             const rows = await db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-              .whereIn('id', [...idSet]);
+              .whereIn('id', [...idSet])
 
             for (const row of rows) {
-              const includeKey = `${targetDescriptor.resource}:${row.id}`;
-              if (seen.has(includeKey)) continue;
-              seen.add(includeKey);
-              const translated = translateRecordFromStorage(row, targetDescriptor);
+              const includeKey = `${targetDescriptor.resource}:${row.id}`
+              if (seen.has(includeKey)) continue
+              seen.add(includeKey)
+              const translated = translateRecordFromStorage(row, targetDescriptor)
               const includeResource = {
                 type: targetDescriptor.resource,
                 id: String(row.id),
                 attributes: translated.attributes,
-              };
+              }
               if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-                includeResource.relationships = translated.relationships;
+                includeResource.relationships = translated.relationships
               }
-              addSelfLink(includeResource, targetDescriptor.resource);
-              includes.push(includeResource);
-              newResources.push(includeResource);
+              addSelfLink(includeResource, targetDescriptor.resource)
+              includes.push(includeResource)
+              newResources.push(includeResource)
             }
           }
 
           if (childKeys.length > 0 && newResources.length > 0) {
-            const resourcesByType = new Map();
+            const resourcesByType = new Map()
             for (const includeResource of newResources) {
               if (!resourcesByType.has(includeResource.type)) {
-                resourcesByType.set(includeResource.type, []);
+                resourcesByType.set(includeResource.type, [])
               }
-              resourcesByType.get(includeResource.type).push(includeResource);
+              resourcesByType.get(includeResource.type).push(includeResource)
             }
 
             for (const [targetType, groupedResources] of resourcesByType.entries()) {
-              let targetDescriptor;
+              let targetDescriptor
               try {
-                targetDescriptor = await getDescriptor(targetType);
+                targetDescriptor = await getDescriptor(targetType)
               } catch (error) {
-                continue;
+                continue
               }
 
-              await attachHasManyRelationships({ resources: groupedResources, descriptor: targetDescriptor, context });
-              await attachManyToManyRelationships({ resources: groupedResources, descriptor: targetDescriptor, context });
+              await attachHasManyRelationships({ resources: groupedResources, descriptor: targetDescriptor, context })
+              await attachManyToManyRelationships({ resources: groupedResources, descriptor: targetDescriptor, context })
               await collectIncludes({
                 descriptor: targetDescriptor,
                 resources: groupedResources,
@@ -1256,90 +1256,90 @@ export const RestApiAnyapiKnexPlugin = {
                 context,
                 includes,
                 seen,
-              });
+              })
             }
           }
 
-          continue;
+          continue
         }
 
-        const hasManyInfo = descriptor.relationships?.[relName];
+        const hasManyInfo = descriptor.relationships?.[relName]
         if (hasManyInfo?.type === 'hasMany' && hasManyInfo.target && (hasManyInfo.foreignKey || hasManyInfo.via)) {
-          let targetDescriptor;
+          let targetDescriptor
           try {
-            targetDescriptor = await getDescriptor(hasManyInfo.target);
+            targetDescriptor = await getDescriptor(hasManyInfo.target)
           } catch (error) {
-            continue;
+            continue
           }
 
           const parentIds = resources
             .map((resource) => normalizeId(resource.id))
-            .filter((id) => id !== null);
+            .filter((id) => id !== null)
 
-          if (parentIds.length === 0) continue;
+          if (parentIds.length === 0) continue
 
           const queryIds = Array.from(new Set([
             ...parentIds,
             ...parentIds
               .map((id) => {
-                const numeric = Number(id);
-                return Number.isFinite(numeric) ? numeric : null;
+                const numeric = Number(id)
+                return Number.isFinite(numeric) ? numeric : null
               })
               .filter((value) => value !== null),
-          ]));
+          ]))
 
-          let rows = [];
-          let groupingColumn = null;
+          let rows = []
+          let groupingColumn = null
 
           if (hasManyInfo.foreignKey) {
-            const foreignField = targetDescriptor.fields?.[hasManyInfo.foreignKey];
+            const foreignField = targetDescriptor.fields?.[hasManyInfo.foreignKey]
             if (!foreignField?.slot) {
-              continue;
+              continue
             }
-            groupingColumn = foreignField.slot;
+            groupingColumn = foreignField.slot
             rows = await db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-              .whereIn(groupingColumn, parentIds);
+              .whereIn(groupingColumn, parentIds)
           } else if (hasManyInfo.via) {
-            const polyInfo = targetDescriptor.polymorphicBelongsTo?.[hasManyInfo.via];
+            const polyInfo = targetDescriptor.polymorphicBelongsTo?.[hasManyInfo.via]
             if (!polyInfo?.idColumn || !polyInfo?.typeColumn) {
-              continue;
+              continue
             }
-            groupingColumn = polyInfo.idColumn;
+            groupingColumn = polyInfo.idColumn
             rows = await db(targetDescriptor.canonical.tableName)
               .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
               .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
               .where(polyInfo.typeColumn, descriptor.resource)
-              .whereIn(groupingColumn, queryIds);
+              .whereIn(groupingColumn, queryIds)
           }
 
           if (!groupingColumn || rows.length === 0) {
-            continue;
+            continue
           }
 
-          const newResources = [];
-            for (const row of rows) {
-              const includeKey = `${targetDescriptor.resource}:${row.id}`;
-              if (seen.has(includeKey)) continue;
-              seen.add(includeKey);
-              const translated = translateRecordFromStorage(row, targetDescriptor);
-              const includeResource = {
-                type: targetDescriptor.resource,
-                id: String(row.id),
-                attributes: translated.attributes,
-              };
-              if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-                includeResource.relationships = translated.relationships;
-              }
-              addSelfLink(includeResource, targetDescriptor.resource);
-              includes.push(includeResource);
-              newResources.push(includeResource);
+          const newResources = []
+          for (const row of rows) {
+            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            if (seen.has(includeKey)) continue
+            seen.add(includeKey)
+            const translated = translateRecordFromStorage(row, targetDescriptor)
+            const includeResource = {
+              type: targetDescriptor.resource,
+              id: String(row.id),
+              attributes: translated.attributes,
+            }
+            if (translated.relationships && Object.keys(translated.relationships).length > 0) {
+              includeResource.relationships = translated.relationships
             }
+            addSelfLink(includeResource, targetDescriptor.resource)
+            includes.push(includeResource)
+            newResources.push(includeResource)
+          }
 
           if (childKeys.length > 0 && newResources.length > 0) {
-            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
-            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
+            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
+            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
             await collectIncludes({
               descriptor: targetDescriptor,
               resources: newResources,
@@ -1347,56 +1347,56 @@ export const RestApiAnyapiKnexPlugin = {
               context,
               includes,
               seen,
-            });
+            })
           }
 
-          continue;
+          continue
         }
 
-        const manyInfo = descriptor.manyToMany?.[relName];
+        const manyInfo = descriptor.manyToMany?.[relName]
         if (manyInfo) {
-          const info = await getManyToManyInfo(descriptor.resource, relName);
-          if (!info) continue;
+          const info = await getManyToManyInfo(descriptor.resource, relName)
+          if (!info) continue
           const linkRows = await fetchLinksForParents({
             descriptor: info.descriptor,
             relationshipKey: info.relationshipKey,
             parentIds: resources.map((resource) => resource.id),
             db,
-          });
+          })
 
-          const childIds = [...new Set(linkRows.map((row) => row.childId))];
-          if (childIds.length === 0) continue;
+          const childIds = [...new Set(linkRows.map((row) => row.childId))]
+          if (childIds.length === 0) continue
 
-          const targetDescriptor = await registry.getDescriptor(tenantId, info.relInfo.target);
-          if (!targetDescriptor) continue;
+          const targetDescriptor = await registry.getDescriptor(tenantId, info.relInfo.target)
+          if (!targetDescriptor) continue
 
           const rows = await db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-            .whereIn('id', childIds);
-
-         const newResources = [];
-         for (const row of rows) {
-           const includeKey = `${targetDescriptor.resource}:${row.id}`;
-           if (seen.has(includeKey)) continue;
-           seen.add(includeKey);
-           const translated = translateRecordFromStorage(row, targetDescriptor);
-           const includeResource = {
-             type: targetDescriptor.resource,
-             id: String(row.id),
-             attributes: translated.attributes,
-           };
-           if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-             includeResource.relationships = translated.relationships;
-           }
-          addSelfLink(includeResource, targetDescriptor.resource);
-          includes.push(includeResource);
-          newResources.push(includeResource);
-        }
+            .whereIn('id', childIds)
+
+          const newResources = []
+          for (const row of rows) {
+            const includeKey = `${targetDescriptor.resource}:${row.id}`
+            if (seen.has(includeKey)) continue
+            seen.add(includeKey)
+            const translated = translateRecordFromStorage(row, targetDescriptor)
+            const includeResource = {
+              type: targetDescriptor.resource,
+              id: String(row.id),
+              attributes: translated.attributes,
+            }
+            if (translated.relationships && Object.keys(translated.relationships).length > 0) {
+              includeResource.relationships = translated.relationships
+            }
+            addSelfLink(includeResource, targetDescriptor.resource)
+            includes.push(includeResource)
+            newResources.push(includeResource)
+          }
 
           if (childKeys.length > 0 && newResources.length > 0) {
-            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
-            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context });
+            await attachHasManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
+            await attachManyToManyRelationships({ resources: newResources, descriptor: targetDescriptor, context })
             await collectIncludes({
               descriptor: targetDescriptor,
               resources: newResources,
@@ -1404,18 +1404,18 @@ export const RestApiAnyapiKnexPlugin = {
               context,
               includes,
               seen,
-            });
+            })
           }
         }
       }
-    };
+    }
 
     const buildIncludes = async ({ parentResources, descriptor, context }) => {
-      const includeTree = parseIncludeTree(context.queryParams?.include);
-      if (Object.keys(includeTree).length === 0) return [];
+      const includeTree = parseIncludeTree(context.queryParams?.include)
+      if (Object.keys(includeTree).length === 0) return []
 
-      const includes = [];
-      const seen = new Set();
+      const includes = []
+      const seen = new Set()
 
       await collectIncludes({
         descriptor,
@@ -1424,221 +1424,221 @@ export const RestApiAnyapiKnexPlugin = {
         context,
         includes,
         seen,
-      });
+      })
 
-      return includes;
-    };
+      return includes
+    }
 
     const attachHasManyRelationships = async ({ resources, descriptor, context }) => {
-      if (!resources || resources.length === 0) return;
+      if (!resources || resources.length === 0) return
       const hasManyEntries = Object.entries(descriptor.relationships || {})
-        .filter(([, relDef]) => relDef?.type === 'hasMany' && relDef.target && (relDef.foreignKey || relDef.via));
+        .filter(([, relDef]) => relDef?.type === 'hasMany' && relDef.target && (relDef.foreignKey || relDef.via))
 
-      if (hasManyEntries.length === 0) return;
+      if (hasManyEntries.length === 0) return
 
-      const db = context.db || context.transaction || api.knex.instance;
-      const parentIds = resources.map((resource) => resource.id);
+      const db = context.db || context.transaction || api.knex.instance
+      const parentIds = resources.map((resource) => resource.id)
       const normalizedParentIds = parentIds
         .map((id) => normalizeId(id))
-        .filter((id) => id !== null);
+        .filter((id) => id !== null)
 
-      if (normalizedParentIds.length === 0) return;
+      if (normalizedParentIds.length === 0) return
 
       for (const [relName, relDef] of hasManyEntries) {
-        let targetDescriptor;
+        let targetDescriptor
         try {
-          targetDescriptor = await getDescriptor(relDef.target);
+          targetDescriptor = await getDescriptor(relDef.target)
         } catch (error) {
-          continue;
+          continue
         }
 
         if (relDef.foreignKey) {
-          const foreignField = targetDescriptor.fields?.[relDef.foreignKey];
-          if (!foreignField?.slot) continue;
-          const column = foreignField.slot;
+          const foreignField = targetDescriptor.fields?.[relDef.foreignKey]
+          if (!foreignField?.slot) continue
+          const column = foreignField.slot
 
           const rows = await db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
-            .whereIn(column, normalizedParentIds);
+            .whereIn(column, normalizedParentIds)
 
           const grouped = rows.reduce((acc, row) => {
-            const parentId = row[column];
-            if (parentId == null) return acc;
-            const key = String(parentId);
-            acc[key] = acc[key] || [];
-            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) });
-            return acc;
-          }, {});
+            const parentId = row[column]
+            if (parentId == null) return acc
+            const key = String(parentId)
+            acc[key] = acc[key] || []
+            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) })
+            return acc
+          }, {})
 
           for (const resource of resources) {
-            resource.relationships = resource.relationships || {};
-            const related = grouped[String(resource.id)] || [];
-            resource.relationships[relName] = { data: related };
+            resource.relationships = resource.relationships || {}
+            const related = grouped[String(resource.id)] || []
+            resource.relationships[relName] = { data: related }
           }
 
-          continue;
+          continue
         }
 
         if (relDef.via) {
-          const polyInfo = targetDescriptor.polymorphicBelongsTo?.[relDef.via];
-          if (!polyInfo?.idColumn || !polyInfo?.typeColumn) continue;
+          const polyInfo = targetDescriptor.polymorphicBelongsTo?.[relDef.via]
+          if (!polyInfo?.idColumn || !polyInfo?.typeColumn) continue
 
           const queryIds = Array.from(new Set([
             ...normalizedParentIds,
             ...normalizedParentIds
               .map((id) => {
-                const numeric = Number(id);
-                return Number.isFinite(numeric) ? numeric : null;
+                const numeric = Number(id)
+                return Number.isFinite(numeric) ? numeric : null
               })
               .filter((value) => value !== null),
-          ]));
+          ]))
 
           const rows = await db(targetDescriptor.canonical.tableName)
             .where(targetDescriptor.canonical.tenantColumn, targetDescriptor.tenant)
             .where(targetDescriptor.canonical.resourceColumn, targetDescriptor.resource)
             .where(polyInfo.typeColumn, descriptor.resource)
-            .whereIn(polyInfo.idColumn, queryIds);
+            .whereIn(polyInfo.idColumn, queryIds)
 
           const grouped = rows.reduce((acc, row) => {
-            const parentId = row[polyInfo.idColumn];
-            if (parentId == null) return acc;
-            const key = String(parentId);
-            acc[key] = acc[key] || [];
-            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) });
-            return acc;
-          }, {});
+            const parentId = row[polyInfo.idColumn]
+            if (parentId == null) return acc
+            const key = String(parentId)
+            acc[key] = acc[key] || []
+            acc[key].push({ type: targetDescriptor.resource, id: String(row.id) })
+            return acc
+          }, {})
 
           for (const resource of resources) {
-            resource.relationships = resource.relationships || {};
-            const related = grouped[String(resource.id)] || [];
-            resource.relationships[relName] = { data: related };
+            resource.relationships = resource.relationships || {}
+            const related = grouped[String(resource.id)] || []
+            resource.relationships[relName] = { data: related }
           }
         }
       }
-    };
+    }
 
     const attachManyToManyRelationships = async ({ resources, descriptor, context }) => {
-      if (!resources || resources.length === 0) return;
-      const manyEntries = Object.entries(descriptor.manyToMany || {});
-      if (manyEntries.length === 0) return;
+      if (!resources || resources.length === 0) return
+      const manyEntries = Object.entries(descriptor.manyToMany || {})
+      if (manyEntries.length === 0) return
 
-      const db = context.db || context.transaction || api.knex.instance;
-      const parentIds = resources.map((resource) => resource.id);
+      const db = context.db || context.transaction || api.knex.instance
+      const parentIds = resources.map((resource) => resource.id)
 
       for (const [relName, relInfo] of manyEntries) {
-        const info = await getManyToManyInfo(descriptor.resource, relName);
-        if (!info) continue;
+        const info = await getManyToManyInfo(descriptor.resource, relName)
+        if (!info) continue
         const rows = await fetchLinksForParents({
           descriptor: info.descriptor,
           relationshipKey: info.relationshipKey,
           parentIds,
           db,
-        });
+        })
 
         const grouped = rows.reduce((acc, row) => {
-          const key = String(row.parentId);
-          acc[key] = acc[key] || [];
-          acc[key].push({ type: row.childType, id: String(row.childId) });
-          return acc;
-        }, {});
+          const key = String(row.parentId)
+          acc[key] = acc[key] || []
+          acc[key].push({ type: row.childType, id: String(row.childId) })
+          return acc
+        }, {})
 
         for (const resource of resources) {
-          const related = grouped[resource.id] || [];
-          resource.relationships = resource.relationships || {};
-          resource.relationships[relName] = { data: related };
+          const related = grouped[resource.id] || []
+          resource.relationships = resource.relationships || {}
+          resource.relationships[relName] = { data: related }
         }
       }
-    };
+    }
 
     helpers.dataGet = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const { canonical } = descriptor;
-      const id = context.id;
-      const scope = api.resources?.[scopeName];
+      const descriptor = await getDescriptor(scopeName)
+      const { canonical } = descriptor
+      const id = context.id
+      const scope = api.resources?.[scopeName]
 
-      let fieldSelectionInfo = null;
+      let fieldSelectionInfo = null
       if (scope) {
-        fieldSelectionInfo = await buildFieldSelection(scope, { context });
-        context.computedDependencies = fieldSelectionInfo.computedDependencies;
+        fieldSelectionInfo = await buildFieldSelection(scope, { context })
+        context.computedDependencies = fieldSelectionInfo.computedDependencies
       } else {
-        context.computedDependencies = [];
+        context.computedDependencies = []
       }
 
       const row = await context.db(canonical.tableName)
         .where('id', id)
         .where(canonical.resourceColumn, descriptor.resource)
         .where(canonical.tenantColumn, descriptor.tenant)
-        .first();
+        .first()
 
-      if (!row) return null;
+      if (!row) return null
 
-      const record = translateRecordFromStorage(row, descriptor);
+      const record = translateRecordFromStorage(row, descriptor)
       const data = {
         type: descriptor.resource,
         id: String(row.id),
         attributes: record.attributes,
-      };
+      }
 
       if (record.relationships && Object.keys(record.relationships).length > 0) {
-        data.relationships = record.relationships;
+        data.relationships = record.relationships
       }
 
       await attachHasManyRelationships({
         resources: [data],
         descriptor,
         context,
-      });
+      })
 
       await attachManyToManyRelationships({
         resources: [data],
         descriptor,
         context,
-      });
+      })
 
       const included = await buildIncludes({
         parentResources: [data],
         descriptor,
         context,
-      });
+      })
 
-      const response = { data };
+      const response = { data }
       if (included.length > 0) {
-        response.included = included;
+        response.included = included
       }
 
       if (scope) {
-        data.links = data.links || {};
-        data.links.self = buildResourceUrl(context, scope, scopeName, data.id);
+        data.links = data.links || {}
+        data.links.self = buildResourceUrl(context, scope, scopeName, data.id)
         response.links = {
           self: data.links.self,
-        };
+        }
       }
 
       if (included.length > 0) {
         for (const includeResource of included) {
-          const targetScope = api.resources?.[includeResource.type];
-          if (!targetScope) continue;
-          includeResource.links = includeResource.links || {};
+          const targetScope = api.resources?.[includeResource.type]
+          if (!targetScope) continue
+          includeResource.links = includeResource.links || {}
           includeResource.links.self = buildResourceUrl(
             context,
             targetScope,
             includeResource.type,
-            includeResource.id,
-          );
+            includeResource.id
+          )
         }
       }
 
-      return response;
-    };
+      return response
+    }
 
     const rehydrateSchemaInfo = async (scopeName) => {
-      const scope = api.resources?.[scopeName] || scopes?.[scopeName] || {};
-      const storedOptions = scopeOptionsRegistry.get(scopeName) || {};
+      const scope = api.resources?.[scopeName] || scopes?.[scopeName] || {}
+      const storedOptions = scopeOptionsRegistry.get(scopeName) || {}
 
       if (!scope.scopeOptions) {
         scope.scopeOptions = {
@@ -1648,56 +1648,56 @@ export const RestApiAnyapiKnexPlugin = {
           tableName: storedOptions.tableName || scopeName,
           idProperty: storedOptions.idProperty || scope?.vars?.idProperty || vars.idProperty || 'id',
           canonicalFieldsMap: storedOptions.canonicalFieldsMap || {},
-        };
+        }
       }
 
-      const descriptor = await registry.getDescriptor(tenantId, scopeName);
-      if (!descriptor) return;
+      const descriptor = await registry.getDescriptor(tenantId, scopeName)
+      if (!descriptor) return
 
-      const existingInfo = scope.vars?.schemaInfo || {};
+      const existingInfo = scope.vars?.schemaInfo || {}
 
-      const mergedSchema = { ...(existingInfo.schemaInstance?.structure || {}) };
-      const computed = { ...(existingInfo.computed || {}) };
+      const mergedSchema = { ...(existingInfo.schemaInstance?.structure || {}) }
+      const computed = { ...(existingInfo.computed || {}) }
 
       for (const [fieldName, definition] of Object.entries(descriptor.schema || {})) {
         if (definition?.computed) {
           if (!computed[fieldName]) {
-            computed[fieldName] = { ...definition };
+            computed[fieldName] = { ...definition }
           }
-          continue;
+          continue
         }
         mergedSchema[fieldName] = {
           ...(mergedSchema[fieldName] || {}),
           ...definition,
-        };
+        }
       }
 
       if (!mergedSchema.id) {
-        mergedSchema.id = { type: 'id' };
+        mergedSchema.id = { type: 'id' }
       }
 
-      const schemaInstance = createSchema(mergedSchema);
+      const schemaInstance = createSchema(mergedSchema)
 
       const rawSearchFields = generateSearchSchemaFromSchema(
         mergedSchema,
-        scope.scopeOptions?.searchSchema || storedOptions.searchSchema || null,
-      );
+        scope.scopeOptions?.searchSchema || storedOptions.searchSchema || null
+      )
       if (rawSearchFields) {
-        ensureSearchFieldsAreIndexed(rawSearchFields);
+        ensureSearchFieldsAreIndexed(rawSearchFields)
       }
-      const searchSchemaInstance = createSchema(rawSearchFields || {});
+      const searchSchemaInstance = createSchema(rawSearchFields || {})
 
-      const tableName = storedOptions.tableName
-        || existingInfo.tableName
-        || scope.scopeOptions?.tableName
-        || scopeName;
+      const tableName = storedOptions.tableName ||
+        existingInfo.tableName ||
+        scope.scopeOptions?.tableName ||
+        scopeName
 
-      const idProperty = storedOptions.idProperty
-        || existingInfo.idProperty
-        || scope.scopeOptions?.idProperty
-        || scope.vars?.idProperty
-        || vars.idProperty
-        || 'id';
+      const idProperty = storedOptions.idProperty ||
+        existingInfo.idProperty ||
+        scope.scopeOptions?.idProperty ||
+        scope.vars?.idProperty ||
+        vars.idProperty ||
+        'id'
 
       scope.vars.schemaInfo = {
         ...existingInfo,
@@ -1705,24 +1705,24 @@ export const RestApiAnyapiKnexPlugin = {
         schemaStructure: schemaInstance.structure,
         searchSchemaInstance,
         searchSchemaStructure: searchSchemaInstance.structure,
-        schemaRelationships: descriptor.relationships
-          || scope.scopeOptions?.relationships
-          || storedOptions.relationships
-          || existingInfo.schemaRelationships
-          || {},
+        schemaRelationships: descriptor.relationships ||
+          scope.scopeOptions?.relationships ||
+          storedOptions.relationships ||
+          existingInfo.schemaRelationships ||
+          {},
         computed,
         tableName,
         idProperty,
         descriptor,
         canonicalFieldMap: descriptor.canonicalFieldMap || {},
-      };
+      }
 
-      getScopeStorageAdapter(scopeName);
+      getScopeStorageAdapter(scopeName)
 
       scope.scopeOptions = {
         ...(scope.scopeOptions || {}),
         canonicalFieldsMap: descriptor.canonicalFieldMap || scope.scopeOptions?.canonicalFieldsMap || {},
-      };
+      }
 
       scopeOptionsRegistry.set(scopeName, {
         schema: storedOptions.schema || scope.scopeOptions?.schema || {},
@@ -1731,89 +1731,89 @@ export const RestApiAnyapiKnexPlugin = {
         tableName,
         idProperty,
         canonicalFieldsMap: descriptor.canonicalFieldMap || {},
-      });
-    };
+      })
+    }
 
     const buildTableNameMaps = () => {
-      const resourceToTableName = new Map();
-      const tableNameToResource = new Map();
+      const resourceToTableName = new Map()
+      const tableNameToResource = new Map()
       for (const [resourceName, resourceScope] of Object.entries(api.resources || {})) {
-        const tableName = resourceScope?.vars?.schemaInfo?.tableName;
-        if (!tableName) continue;
-        resourceToTableName.set(resourceName, tableName);
-        tableNameToResource.set(tableName, resourceName);
+        const tableName = resourceScope?.vars?.schemaInfo?.tableName
+        if (!tableName) continue
+        resourceToTableName.set(resourceName, tableName)
+        tableNameToResource.set(tableName, resourceName)
       }
-      return { resourceToTableName, tableNameToResource };
-    };
+      return { resourceToTableName, tableNameToResource }
+    }
 
     const translateSelectFieldsForAdapter = (fields, adapter) => {
-      if (!adapter || !fields) return fields;
+      if (!adapter || !fields) return fields
 
       return fields.map((field) => {
-        if (typeof field !== 'string') return field;
+        if (typeof field !== 'string') return field
 
-        if (field === '*') return '*';
+        if (field === '*') return '*'
 
-        const aliasMatch = field.match(/\s+as\s+/i);
+        const aliasMatch = field.match(/\s+as\s+/i)
         if (aliasMatch) {
-          const [source, alias] = field.split(/\s+as\s+/i);
-          const translatedSource = adapter.translateColumn(source.trim()) || source.trim();
-          return `${translatedSource} as ${alias.trim()}`;
+          const [source, alias] = field.split(/\s+as\s+/i)
+          const translatedSource = adapter.translateColumn(source.trim()) || source.trim()
+          return `${translatedSource} as ${alias.trim()}`
         }
 
-        const translated = adapter.translateColumn(field);
-        return translated || field;
-      });
-    };
+        const translated = adapter.translateColumn(field)
+        return translated || field
+      })
+    }
 
     const scopesProxy = new Proxy({}, {
-      get(_target, prop) {
+      get (_target, prop) {
         if (typeof prop !== 'string') {
-          return undefined;
+          return undefined
         }
-        const resource = api.resources?.[prop];
+        const resource = api.resources?.[prop]
         if (resource?.vars?.schemaInfo) {
-          return resource;
+          return resource
         }
-        return scopes?.[prop];
+        return scopes?.[prop]
       },
-    });
+    })
 
-    const queryHookDependencies = { log, scopes: scopesProxy, knex, getStorageAdapter: getScopeStorageAdapter };
+    const queryHookDependencies = { log, scopes: scopesProxy, knex, getStorageAdapter: getScopeStorageAdapter }
 
     addHook('knexQueryFiltering', 'polymorphicFiltersHook', {}, async (hookParams) =>
       polymorphicFiltersHook(hookParams, queryHookDependencies)
-    );
+    )
 
     addHook('knexQueryFiltering', 'crossTableFiltersHook', {}, async (hookParams) =>
       crossTableFiltersHook(hookParams, queryHookDependencies)
-    );
+    )
 
     addHook('knexQueryFiltering', 'basicFiltersHook', {}, async (hookParams) =>
       basicFiltersHook(hookParams, queryHookDependencies)
-    );
+    )
 
     helpers.dataQuery = async ({ scopeName, context, runHooks }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const db = context.db || context.transaction || api.knex.instance;
-      const scope = api.resources?.[scopeName];
-      const queryParams = context.queryParams || {};
+      const descriptor = await getDescriptor(scopeName)
+      const db = context.db || context.transaction || api.knex.instance
+      const scope = api.resources?.[scopeName]
+      const queryParams = context.queryParams || {}
 
-      let fieldSelectionInfo = null;
+      let fieldSelectionInfo = null
       if (scope) {
-        fieldSelectionInfo = await buildFieldSelection(scope, { context });
-        context.computedDependencies = fieldSelectionInfo.computedDependencies;
+        fieldSelectionInfo = await buildFieldSelection(scope, { context })
+        context.computedDependencies = fieldSelectionInfo.computedDependencies
       } else {
-        context.computedDependencies = [];
+        context.computedDependencies = []
       }
 
-      const { resourceToTableName, tableNameToResource } = buildTableNameMaps();
-      context.resourceToTableName = resourceToTableName;
-      const descriptorsMap = await preloadRelatedDescriptors({ registry, descriptor });
+      const { resourceToTableName, tableNameToResource } = buildTableNameMaps()
+      context.resourceToTableName = resourceToTableName
+      const descriptorsMap = await preloadRelatedDescriptors({ registry, descriptor })
       const adapter = new AnyapiQueryAdapter({
         descriptor,
         db,
@@ -1822,11 +1822,11 @@ export const RestApiAnyapiKnexPlugin = {
         resourceToTableName,
         tableNameToResource,
         log,
-      });
-      const queryBuilder = adapter.query;
+      })
+      const queryBuilder = adapter.query
 
-      const schemaInfo = scope?.vars?.schemaInfo;
-      const tableNameForHooks = schemaInfo?.tableName || adapter.tableAlias;
+      const schemaInfo = scope?.vars?.schemaInfo
+      const tableNameForHooks = schemaInfo?.tableName || adapter.tableAlias
 
       applyFiltersToQuery({
         query: queryBuilder,
@@ -1834,7 +1834,7 @@ export const RestApiAnyapiKnexPlugin = {
         descriptor,
         searchSchema: schemaInfo?.searchSchemaStructure,
         adapter,
-      });
+      })
 
       context.knexQuery = {
         query: queryBuilder,
@@ -1846,25 +1846,25 @@ export const RestApiAnyapiKnexPlugin = {
         isAnyApi: true,
         adapter,
         storageAdapter,
-      };
+      }
 
       if (runHooks) {
-        await runHooks('knexQueryFiltering');
+        await runHooks('knexQueryFiltering')
       }
 
-      delete context.knexQuery;
+      delete context.knexQuery
 
-      const countQuery = queryBuilder.clone();
+      const countQuery = queryBuilder.clone()
 
       const sortDescriptors = applySortingToQuery({
         query: queryBuilder,
         sort: queryParams.sort,
         descriptor,
         scope,
-      });
+      })
 
       if (queryParams?.page?.after) {
-              }
+      }
 
       const paginationInfo = applyPaginationToQuery({
         query: queryBuilder,
@@ -1872,120 +1872,120 @@ export const RestApiAnyapiKnexPlugin = {
         queryParams,
         sortDescriptors,
         adapter,
-      });
+      })
 
       if (queryParams?.page?.after) {
-              }
+      }
 
       if (fieldSelectionInfo && fieldSelectionInfo.fieldsToSelect && fieldSelectionInfo.fieldsToSelect.length > 0) {
-        const translatedSelect = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, adapter);
-        queryBuilder.select(translatedSelect);
+        const translatedSelect = translateSelectFieldsForAdapter(fieldSelectionInfo.fieldsToSelect, adapter)
+        queryBuilder.select(translatedSelect)
       }
 
-      let rows = await queryBuilder;
-      let cursorRecords = null;
-      let hasMore = false;
+      let rows = await queryBuilder
+      let cursorRecords = null
+      let hasMore = false
 
       if (paginationInfo.mode === 'cursor') {
-        const { pageSize, sortDescriptors: cursorDescriptors } = paginationInfo;
+        const { pageSize, sortDescriptors: cursorDescriptors } = paginationInfo
         cursorRecords = rows.map((row) => {
-          const record = {};
+          const record = {}
           for (const descriptorEntry of cursorDescriptors) {
             if (descriptorEntry.field === 'id') {
-              record.id = row.id;
+              record.id = row.id
             } else if (descriptorEntry.column) {
-              record[descriptorEntry.field] = row[descriptorEntry.column];
+              record[descriptorEntry.field] = row[descriptorEntry.column]
             }
           }
-          return record;
-        });
+          return record
+        })
 
         if (rows.length > pageSize) {
-          hasMore = true;
-          rows = rows.slice(0, pageSize);
-          cursorRecords = cursorRecords.slice(0, pageSize);
+          hasMore = true
+          rows = rows.slice(0, pageSize)
+          cursorRecords = cursorRecords.slice(0, pageSize)
         }
       }
 
       const data = rows.map((row) => {
-        const translated = translateRecordFromStorage(row, descriptor);
+        const translated = translateRecordFromStorage(row, descriptor)
         const resource = {
           type: descriptor.resource,
           id: String(row.id),
           attributes: translated.attributes,
-        };
+        }
         if (translated.relationships && Object.keys(translated.relationships).length > 0) {
-          resource.relationships = translated.relationships;
+          resource.relationships = translated.relationships
         }
-        const resourceScope = scope;
+        const resourceScope = scope
         if (resourceScope) {
-          resource.links = resource.links || {};
-          resource.links.self = buildResourceUrl(context, resourceScope, scopeName, resource.id);
+          resource.links = resource.links || {}
+          resource.links.self = buildResourceUrl(context, resourceScope, scopeName, resource.id)
         }
         if (fieldSelectionInfo?.computedDependencies?.length) {
-          resource.__$jsonrestapi_computed_deps$__ = fieldSelectionInfo.computedDependencies;
+          resource.__$jsonrestapi_computed_deps$__ = fieldSelectionInfo.computedDependencies
         }
-        return resource;
-      });
+        return resource
+      })
 
       await attachHasManyRelationships({
         resources: data,
         descriptor,
         context,
-      });
+      })
 
       await attachManyToManyRelationships({
         resources: data,
         descriptor,
         context,
-      });
+      })
 
       const included = await buildIncludes({
         parentResources: data,
         descriptor,
         context,
-      });
+      })
 
-      const response = { data };
+      const response = { data }
       if (included.length > 0) {
-        response.included = included;
+        response.included = included
       }
 
-      context.returnMeta = context.returnMeta || {};
-      context.returnMeta.queryString = buildQueryString(queryParams);
-      delete context.returnMeta.paginationMeta;
-      delete context.returnMeta.paginationLinks;
+      context.returnMeta = context.returnMeta || {}
+      context.returnMeta.queryString = buildQueryString(queryParams)
+      delete context.returnMeta.paginationMeta
+      delete context.returnMeta.paginationLinks
 
       if (paginationInfo.mode === 'offset') {
-        const { page, pageSize } = paginationInfo;
-        let paginationMeta;
+        const { page, pageSize } = paginationInfo
+        let paginationMeta
 
         if (scope?.vars?.enablePaginationCounts) {
-          const countResult = await countQuery.count({ count: '*' }).first();
-          const total = Number(countResult?.count ?? countResult?.total ?? 0);
-          paginationMeta = calculatePaginationMeta(total, page, pageSize);
+          const countResult = await countQuery.count({ count: '*' }).first()
+          const total = Number(countResult?.count ?? countResult?.total ?? 0)
+          paginationMeta = calculatePaginationMeta(total, page, pageSize)
         } else {
-          paginationMeta = { page, pageSize };
+          paginationMeta = { page, pageSize }
         }
 
-        context.returnMeta.paginationMeta = paginationMeta;
-        const urlPrefix = getUrlPrefix(context, scope);
+        context.returnMeta.paginationMeta = paginationMeta
+        const urlPrefix = getUrlPrefix(context, scope)
         context.returnMeta.paginationLinks = generatePaginationLinks(
           urlPrefix,
           scopeName,
           queryParams,
-          paginationMeta,
-        );
+          paginationMeta
+        )
       } else if (paginationInfo.mode === 'cursor' && cursorRecords) {
-        const cursorFields = paginationInfo.sortDescriptors.map((descriptorEntry) => descriptorEntry.field);
+        const cursorFields = paginationInfo.sortDescriptors.map((descriptorEntry) => descriptorEntry.field)
         const paginationMeta = buildCursorMeta(
           cursorRecords,
           paginationInfo.pageSize,
           hasMore,
-          cursorFields,
-        );
-        context.returnMeta.paginationMeta = paginationMeta;
-        const urlPrefix = getUrlPrefix(context, scope);
+          cursorFields
+        )
+        context.returnMeta.paginationMeta = paginationMeta
+        const urlPrefix = getUrlPrefix(context, scope)
         context.returnMeta.paginationLinks = generateCursorPaginationLinks(
           urlPrefix,
           scopeName,
@@ -1993,37 +1993,37 @@ export const RestApiAnyapiKnexPlugin = {
           cursorRecords,
           paginationInfo.pageSize,
           hasMore,
-          cursorFields,
-        );
+          cursorFields
+        )
       }
 
       if (context.returnMeta.paginationMeta) {
         response.meta = {
           pagination: context.returnMeta.paginationMeta,
-        };
+        }
       }
 
       if (context.returnMeta.paginationLinks) {
-        response.links = context.returnMeta.paginationLinks;
+        response.links = context.returnMeta.paginationLinks
       } else if (scope) {
-        const urlPrefix = getUrlPrefix(context, scope);
+        const urlPrefix = getUrlPrefix(context, scope)
         response.links = {
           self: `${urlPrefix}/${scopeName}${context.returnMeta.queryString || ''}`,
-        };
+        }
       }
 
-      return response;
-    };
+      return response
+    }
 
     helpers.dataQueryCount = async ({ scopeName, context }) => {
-      const storageAdapter = getScopeStorageAdapter(scopeName);
+      const storageAdapter = getScopeStorageAdapter(scopeName)
       if (storageAdapter) {
-        context.storageAdapter = storageAdapter;
+        context.storageAdapter = storageAdapter
       }
-      const descriptor = await getDescriptor(scopeName);
-      const db = context.db || context.transaction || api.knex.instance;
-      const { resourceToTableName, tableNameToResource } = buildTableNameMaps();
-      const descriptorsMap = await preloadRelatedDescriptors({ registry, descriptor });
+      const descriptor = await getDescriptor(scopeName)
+      const db = context.db || context.transaction || api.knex.instance
+      const { resourceToTableName, tableNameToResource } = buildTableNameMaps()
+      const descriptorsMap = await preloadRelatedDescriptors({ registry, descriptor })
       const adapter = new AnyapiQueryAdapter({
         descriptor,
         db,
@@ -2032,33 +2032,33 @@ export const RestApiAnyapiKnexPlugin = {
         resourceToTableName,
         tableNameToResource,
         log,
-      });
+      })
 
       applyFiltersToQuery({
         query: adapter.query,
         filters: context.queryParams?.filters,
         descriptor,
-      });
+      })
 
-      const [{ count }] = await adapter.query.count({ count: '*' });
-      return Number(count);
-    };
+      const [{ count }] = await adapter.query.count({ count: '*' })
+      return Number(count)
+    }
 
     addHook('scope:added', 'anyapi-register-resource', { sequence: 50 }, async ({ context }) => {
-      const { scopeName, scopeOptions = {} } = context;
-      const scope = api.scopes?.[scopeName] || scopes?.[scopeName];
-      const stored = scopeOptionsRegistry.get(scopeName) || {};
-
-      const baseSchema = scopeOptions.schema || scope?.scopeOptions?.schema || stored.schema || {};
-      const relationships = scopeOptions.relationships || scope?.scopeOptions?.relationships || stored.relationships || {};
-      const searchSchemaDef = scopeOptions.searchSchema || scope?.scopeOptions?.searchSchema || stored.searchSchema || null;
-      const tableName = scopeOptions.tableName || scope?.scopeOptions?.tableName || stored.tableName || scopeName;
-      const idProperty = scopeOptions.idProperty || scope?.scopeOptions?.idProperty || stored.idProperty || scope?.vars?.idProperty || vars.idProperty || 'id';
-      const canonicalFieldsMap = scope?.scopeOptions?.canonicalFieldsMap || stored.canonicalFieldsMap || null;
-
-      const schema = { ...baseSchema };
+      const { scopeName, scopeOptions = {} } = context
+      const scope = api.scopes?.[scopeName] || scopes?.[scopeName]
+      const stored = scopeOptionsRegistry.get(scopeName) || {}
+
+      const baseSchema = scopeOptions.schema || scope?.scopeOptions?.schema || stored.schema || {}
+      const relationships = scopeOptions.relationships || scope?.scopeOptions?.relationships || stored.relationships || {}
+      const searchSchemaDef = scopeOptions.searchSchema || scope?.scopeOptions?.searchSchema || stored.searchSchema || null
+      const tableName = scopeOptions.tableName || scope?.scopeOptions?.tableName || stored.tableName || scopeName
+      const idProperty = scopeOptions.idProperty || scope?.scopeOptions?.idProperty || stored.idProperty || scope?.vars?.idProperty || vars.idProperty || 'id'
+      const canonicalFieldsMap = scope?.scopeOptions?.canonicalFieldsMap || stored.canonicalFieldsMap || null
+
+      const schema = { ...baseSchema }
       if (idProperty && idProperty !== 'id' && !schema[idProperty]) {
-        schema[idProperty] = { type: 'number' };
+        schema[idProperty] = { type: 'number' }
       }
 
       scopeOptionsRegistry.set(scopeName, {
@@ -2068,7 +2068,7 @@ export const RestApiAnyapiKnexPlugin = {
         tableName,
         idProperty,
         canonicalFieldsMap,
-      });
+      })
 
       const descriptor = await registry.registerResource({
         tenant: tenantId,
@@ -2076,11 +2076,11 @@ export const RestApiAnyapiKnexPlugin = {
         schema,
         relationships,
         canonicalFieldMap: canonicalFieldsMap,
-      });
+      })
 
-      const updatedStored = scopeOptionsRegistry.get(scopeName) || {};
-      updatedStored.canonicalFieldsMap = descriptor.canonicalFieldMap || updatedStored.canonicalFieldsMap || null;
-      scopeOptionsRegistry.set(scopeName, updatedStored);
+      const updatedStored = scopeOptionsRegistry.get(scopeName) || {}
+      updatedStored.canonicalFieldsMap = descriptor.canonicalFieldMap || updatedStored.canonicalFieldsMap || null
+      scopeOptionsRegistry.set(scopeName, updatedStored)
 
       if (scope) {
         scope.scopeOptions = {
@@ -2091,31 +2091,31 @@ export const RestApiAnyapiKnexPlugin = {
           tableName,
           idProperty,
           canonicalFieldsMap: descriptor.canonicalFieldMap || scope.scopeOptions?.canonicalFieldsMap || {},
-        };
+        }
       }
 
-      await rehydrateSchemaInfo(scopeName);
-    });
+      await rehydrateSchemaInfo(scopeName)
+    })
 
     addScopeMethod('createKnexTable', async ({ scopeName, scopeOptions }) => {
-      const scope = api.resources?.[scopeName] || scopes?.[scopeName];
-      const schemaInput = scopeOptions?.schema || scope?.scopeOptions?.schema || {};
-      const relationshipInput = scopeOptions?.relationships || scope?.scopeOptions?.relationships || {};
-      const storedBefore = scopeOptionsRegistry.get(scopeName) || {};
-      const idProperty = scopeOptions?.idProperty
-        || scope?.scopeOptions?.idProperty
-        || storedBefore.idProperty
-        || scope?.vars?.schemaInfo?.idProperty
-        || vars.idProperty
-        || 'id';
-
-      const effectiveSchema = { ...schemaInput };
+      const scope = api.resources?.[scopeName] || scopes?.[scopeName]
+      const schemaInput = scopeOptions?.schema || scope?.scopeOptions?.schema || {}
+      const relationshipInput = scopeOptions?.relationships || scope?.scopeOptions?.relationships || {}
+      const storedBefore = scopeOptionsRegistry.get(scopeName) || {}
+      const idProperty = scopeOptions?.idProperty ||
+        scope?.scopeOptions?.idProperty ||
+        storedBefore.idProperty ||
+        scope?.vars?.schemaInfo?.idProperty ||
+        vars.idProperty ||
+        'id'
+
+      const effectiveSchema = { ...schemaInput }
       if (idProperty && idProperty !== 'id' && !effectiveSchema[idProperty]) {
-        effectiveSchema[idProperty] = { type: 'number' };
+        effectiveSchema[idProperty] = { type: 'number' }
       }
 
       if (scope) {
-        const existingOptions = scope.scopeOptions || {};
+        const existingOptions = scope.scopeOptions || {}
         scope.scopeOptions = {
           ...existingOptions,
           schema: {
@@ -2128,7 +2128,7 @@ export const RestApiAnyapiKnexPlugin = {
             ...relationshipInput,
           },
           searchSchema: existingOptions.searchSchema || scopeOptions?.searchSchema,
-        };
+        }
       }
       scopeOptionsRegistry.set(scopeName, {
         schema: scope?.scopeOptions?.schema || effectiveSchema || storedBefore.schema || {},
@@ -2137,33 +2137,33 @@ export const RestApiAnyapiKnexPlugin = {
         tableName: scope?.scopeOptions?.tableName || scopeOptions?.tableName || storedBefore.tableName || scopeName,
         idProperty: scope?.scopeOptions?.idProperty || scopeOptions?.idProperty || storedBefore.idProperty || scope?.vars?.idProperty || vars.idProperty || 'id',
         canonicalFieldsMap: storedBefore.canonicalFieldsMap || null,
-      });
+      })
       const descriptor = await registry.registerResource({
         tenant: tenantId,
         resource: scopeName,
         schema: effectiveSchema,
         relationships: relationshipInput,
-        canonicalFieldMap: scopeOptions?.canonicalFieldsMap
-          || scope?.scopeOptions?.canonicalFieldsMap
-          || null,
-      });
+        canonicalFieldMap: scopeOptions?.canonicalFieldsMap ||
+          scope?.scopeOptions?.canonicalFieldsMap ||
+          null,
+      })
       if (scope) {
         scope.scopeOptions = {
           ...(scope.scopeOptions || {}),
           canonicalFieldsMap: descriptor.canonicalFieldMap || scope.scopeOptions?.canonicalFieldsMap || {},
-        };
+        }
       }
-      const storedAfter = scopeOptionsRegistry.get(scopeName) || {};
-      storedAfter.canonicalFieldsMap = descriptor.canonicalFieldMap || storedAfter.canonicalFieldsMap || null;
-      scopeOptionsRegistry.set(scopeName, storedAfter);
-      await rehydrateSchemaInfo(scopeName);
-    });
+      const storedAfter = scopeOptionsRegistry.get(scopeName) || {}
+      storedAfter.canonicalFieldsMap = descriptor.canonicalFieldMap || storedAfter.canonicalFieldsMap || null
+      scopeOptionsRegistry.set(scopeName, storedAfter)
+      await rehydrateSchemaInfo(scopeName)
+    })
 
     addScopeMethod('addKnexFields', async ({ scopeName, params }) => {
-      if (!params?.fields) return;
-      const scope = api.resources?.[scopeName] || scopes?.[scopeName];
+      if (!params?.fields) return
+      const scope = api.resources?.[scopeName] || scopes?.[scopeName]
       if (scope) {
-        const existingOptions = scope.scopeOptions || {};
+        const existingOptions = scope.scopeOptions || {}
         scope.scopeOptions = {
           ...existingOptions,
           schema: {
@@ -2171,18 +2171,18 @@ export const RestApiAnyapiKnexPlugin = {
           },
           relationships: existingOptions.relationships || {},
           searchSchema: existingOptions.searchSchema,
-        };
+        }
       }
-      const storedBefore = scopeOptionsRegistry.get(scopeName) || {};
-      const canonicalEntries = params.canonicalFieldsMap ? { ...params.canonicalFieldsMap } : null;
-      let latestDescriptor = null;
+      const storedBefore = scopeOptionsRegistry.get(scopeName) || {}
+      const canonicalEntries = params.canonicalFieldsMap ? { ...params.canonicalFieldsMap } : null
+      let latestDescriptor = null
       for (const [fieldName, definition] of Object.entries(params.fields)) {
         if (scope) {
-          scope.scopeOptions.schema[fieldName] = definition;
+          scope.scopeOptions.schema[fieldName] = definition
         }
-        const canonicalEntry = canonicalEntries ? canonicalEntries[fieldName] : null;
+        const canonicalEntry = canonicalEntries ? canonicalEntries[fieldName] : null
         if (canonicalEntries) {
-          delete canonicalEntries[fieldName];
+          delete canonicalEntries[fieldName]
         }
         latestDescriptor = await registry.allocateField({
           tenant: tenantId,
@@ -2190,20 +2190,20 @@ export const RestApiAnyapiKnexPlugin = {
           fieldName,
           definition,
           canonicalField: canonicalEntry,
-        });
+        })
       }
       if (canonicalEntries && Object.keys(canonicalEntries).length > 0) {
-        const unknown = Object.keys(canonicalEntries).join(', ');
-        throw new Error(`canonicalFieldsMap contains unknown fields for addKnexFields: ${unknown}`);
+        const unknown = Object.keys(canonicalEntries).join(', ')
+        throw new Error(`canonicalFieldsMap contains unknown fields for addKnexFields: ${unknown}`)
       }
       if (scope && latestDescriptor?.canonicalFieldMap) {
-        scope.scopeOptions.canonicalFieldsMap = latestDescriptor.canonicalFieldMap;
+        scope.scopeOptions.canonicalFieldsMap = latestDescriptor.canonicalFieldMap
       }
       if (scope && params.searchSchema) {
         scope.scopeOptions.searchSchema = {
           ...(scope.scopeOptions.searchSchema || {}),
           ...params.searchSchema,
-        };
+        }
       }
       const updatedStored = {
         schema: scope?.scopeOptions?.schema || storedBefore.schema || {},
@@ -2212,74 +2212,74 @@ export const RestApiAnyapiKnexPlugin = {
         tableName: scope?.scopeOptions?.tableName || storedBefore.tableName || scopeName,
         idProperty: scope?.scopeOptions?.idProperty || storedBefore.idProperty || scope?.vars?.idProperty || vars.idProperty || 'id',
         canonicalFieldsMap: scope?.scopeOptions?.canonicalFieldsMap || storedBefore.canonicalFieldsMap || null,
-      };
-      scopeOptionsRegistry.set(scopeName, updatedStored);
-      await rehydrateSchemaInfo(scopeName);
-    });
+      }
+      scopeOptionsRegistry.set(scopeName, updatedStored)
+      await rehydrateSchemaInfo(scopeName)
+    })
 
     addScopeMethod('alterKnexFields', async () => {
-      throw new Error('alterKnexFields is not supported by AnyAPI Knex plugin yet');
-    });
+      throw new Error('alterKnexFields is not supported by AnyAPI Knex plugin yet')
+    })
   },
-};
+}
 
 const translateAttributesForStorage = (attributes, descriptor) => {
-  const row = {};
+  const row = {}
   for (const [fieldName, value] of Object.entries(attributes)) {
-    const slot = descriptor.fields[fieldName];
-    if (!slot) continue;
+    const slot = descriptor.fields[fieldName]
+    if (!slot) continue
 
     if (slot.slotType === 'belongsTo') {
-      row[slot.slot] = value == null ? null : String(value);
+      row[slot.slot] = value == null ? null : String(value)
     } else {
-      row[slot.slot] = value;
+      row[slot.slot] = value
     }
 
     if (slot.slotType === 'belongsTo') {
-      const alias = slot.alias || descriptor.fields[fieldName]?.alias;
-      const belongsToInfo = alias ? descriptor.belongsTo?.[alias] : null;
+      const alias = slot.alias || descriptor.fields[fieldName]?.alias
+      const belongsToInfo = alias ? descriptor.belongsTo?.[alias] : null
       if (belongsToInfo) {
-        row[belongsToInfo.typeColumn] = value == null ? null : belongsToInfo.target;
+        row[belongsToInfo.typeColumn] = value == null ? null : belongsToInfo.target
       }
     }
   }
-  return row;
-};
+  return row
+}
 
 const translateRecordFromStorage = (row, descriptor) => {
-  const attributes = {};
+  const attributes = {}
   for (const [slot, logical] of Object.entries(descriptor.reverseAttributes)) {
     if (slot in row) {
-      attributes[logical] = row[slot];
+      attributes[logical] = row[slot]
     }
   }
 
-  const relationships = {};
+  const relationships = {}
   for (const [alias, info] of Object.entries(descriptor.belongsTo || {})) {
-    const idValue = row[info.idColumn];
+    const idValue = row[info.idColumn]
     const relationshipData = idValue == null
       ? null
-      : { type: info.target, id: String(idValue) };
+      : { type: info.target, id: String(idValue) }
 
-    relationships[alias] = { data: relationshipData };
+    relationships[alias] = { data: relationshipData }
   }
 
   for (const [alias, info] of Object.entries(descriptor.polymorphicBelongsTo || {})) {
-    const typeValue = info.typeColumn ? row[info.typeColumn] : null;
-    const idValue = info.idColumn ? row[info.idColumn] : null;
+    const typeValue = info.typeColumn ? row[info.typeColumn] : null
+    const idValue = info.idColumn ? row[info.idColumn] : null
 
-    let relationshipData = null;
+    let relationshipData = null
     if (typeValue != null && idValue != null) {
       relationshipData = {
         type: String(typeValue),
         id: String(idValue),
-      };
+      }
     } else if (typeValue == null && idValue == null) {
-      relationshipData = null;
+      relationshipData = null
     }
 
-    relationships[alias] = { data: relationshipData };
+    relationships[alias] = { data: relationshipData }
   }
 
-  return { attributes, relationships };
-};
+  return { attributes, relationships }
+}