json-rest-api 1.0.13 → 1.0.15

package/tests/fixtures/api-configs.js

@@ -1,75 +1,75 @@
-import { Api } from 'hooked-api';
-import { RestApiPlugin, RestApiKnexPlugin, RestApiAnyapiKnexPlugin } from '../../index.js';
-import { AccessPlugin } from '../../plugins/core/rest-api-access.js';
-import { ExpressPlugin } from '../../plugins/core/connectors/express-plugin.js';
-import express from 'express';
-import { createServer } from 'http';
-import { ensureAnyApiSchema } from '../../plugins/core/lib/anyapi/schema-utils.js';
-import { storageMode } from '../helpers/storage-mode.js';
-
-async function resetAnyApiTables(knex) {
-  if (!storageMode.isAnyApi()) return;
-  await knex('any_links').delete().catch(() => {});
-  await knex('any_records').delete().catch(() => {});
-  await knex('any_relationship_configs').delete().catch(() => {});
-  await knex('any_field_configs').delete().catch(() => {});
-  await knex('any_resource_configs').delete().catch(() => {});
+import { Api } from 'hooked-api'
+import { RestApiPlugin, RestApiKnexPlugin, RestApiAnyapiKnexPlugin } from '../../index.js'
+import { AccessPlugin } from '../../plugins/core/rest-api-access.js'
+import { ExpressPlugin } from '../../plugins/core/connectors/express-plugin.js'
+import express from 'express'
+import { createServer } from 'http'
+import { ensureAnyApiSchema } from '../../plugins/core/lib/anyapi/schema-utils.js'
+import { storageMode } from '../helpers/storage-mode.js'
+
+async function resetAnyApiTables (knex) {
+  if (!storageMode.isAnyApi()) return
+  await knex('any_links').delete().catch(() => {})
+  await knex('any_records').delete().catch(() => {})
+  await knex('any_relationship_configs').delete().catch(() => {})
+  await knex('any_field_configs').delete().catch(() => {})
+  await knex('any_resource_configs').delete().catch(() => {})
 }
 
-async function useStoragePlugin(api, knex, { tenantId } = {}) {
+async function useStoragePlugin (api, knex, { tenantId } = {}) {
   if (storageMode.isAnyApi()) {
-    await ensureAnyApiSchema(knex);
-    const sanitizedName = api?.name ? api.name.replace(/[^A-Za-z0-9]+/g, '_').toLowerCase() : 'tenant';
-    const effectiveTenantId = tenantId || api?.anyapi?.tenantId || `${sanitizedName}_tenant`;
-    api.anyapi = api.anyapi || {};
-    api.anyapi.tenantId = effectiveTenantId;
-    await api.use(RestApiAnyapiKnexPlugin, { knex, tenantId: effectiveTenantId });
-    storageMode.setCurrentTenant(effectiveTenantId);
+    await ensureAnyApiSchema(knex)
+    const sanitizedName = api?.name ? api.name.replace(/[^A-Za-z0-9]+/g, '_').toLowerCase() : 'tenant'
+    const effectiveTenantId = tenantId || api?.anyapi?.tenantId || `${sanitizedName}_tenant`
+    api.anyapi = api.anyapi || {}
+    api.anyapi.tenantId = effectiveTenantId
+    await api.use(RestApiAnyapiKnexPlugin, { knex, tenantId: effectiveTenantId })
+    storageMode.setCurrentTenant(effectiveTenantId)
   } else {
-    await api.use(RestApiKnexPlugin, { knex });
+    await api.use(RestApiKnexPlugin, { knex })
   }
 }
 
-function mapTable(tableName, resourceName) {
+function mapTable (tableName, resourceName) {
   if (storageMode.isAnyApi()) {
-    storageMode.registerTable(tableName, resourceName);
+    storageMode.registerTable(tableName, resourceName)
   }
 }
 
-async function withTenantContext(tenantId, fn) {
+async function withTenantContext (tenantId, fn) {
   if (!storageMode.isAnyApi()) {
-    return await fn();
+    return await fn()
   }
 
-  const previousTenant = storageMode.currentTenant;
-  storageMode.setCurrentTenant(tenantId || storageMode.defaultTenant);
+  const previousTenant = storageMode.currentTenant
+  storageMode.setCurrentTenant(tenantId || storageMode.defaultTenant)
   try {
-    return await fn();
+    return await fn()
   } finally {
-    storageMode.setCurrentTenant(previousTenant);
+    storageMode.setCurrentTenant(previousTenant)
   }
 }
 
 /**
  * Creates a basic API configuration with Countries, Publishers, Authors, Books
  */
-export async function createBasicApi(knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || `basic-test-api`;
-  const tablePrefix = pluginOptions.tablePrefix || 'basic';
+export async function createBasicApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'basic-test-api'
+  const tablePrefix = pluginOptions.tablePrefix || 'basic'
   if (storageMode.isAnyApi()) {
-    storageMode.clearRegistry();
+    storageMode.clearRegistry()
   }
   const api = new Api({
     name: apiName,
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
-  const previousTenant = storageMode.currentTenant;
+  const previousTenant = storageMode.currentTenant
   const tenantId = storageMode.isAnyApi()
     ? (pluginOptions.tenantId || `${tablePrefix}_tenant`)
-    : storageMode.defaultTenant;
+    : storageMode.defaultTenant
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(tenantId);
+    storageMode.setCurrentTenant(tenantId)
   }
 
   const restApiOptions = {
@@ -87,134 +87,134 @@ export async function createBasicApi(knex, pluginOptions = {}) {
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'name', 'code'],
     ...pluginOptions['rest-api']  // Merge any custom options for rest-api plugin
-  };
+  }
 
-  await api.use(RestApiPlugin, restApiOptions);
-  await useStoragePlugin(api, knex, { tenantId });
-  await resetAnyApiTables(knex);
+  await api.use(RestApiPlugin, restApiOptions)
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
 
   // Add Express plugin if requested
   if (pluginOptions.includeExpress) {
     await api.use(ExpressPlugin, {
       mountPath: '/api',  // Default mount path for tests
       ...(pluginOptions.express || {})
-    });
+    })
   }
 
   try {
   // Countries table
-  await api.addResource('countries', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 100, search: true },
-      code: { type: 'string', max: 2, unique: true }
-    },
-    relationships: {
-      publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
-      books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
-    },
-    tableName: `${tablePrefix}_countries`
-  });
-  await api.resources.countries.createKnexTable();
-  mapTable(`${tablePrefix}_countries`, 'countries');
+    await api.addResource('countries', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 100, search: true },
+        code: { type: 'string', max: 2, unique: true }
+      },
+      relationships: {
+        publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
+        books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
+      },
+      tableName: `${tablePrefix}_countries`
+    })
+    await api.resources.countries.createKnexTable()
+    mapTable(`${tablePrefix}_countries`, 'countries')
 
-  // Publishers table
-  await api.addResource('publishers', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
-    },
-    relationships: {
-      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' }
-    },
-    tableName: `${tablePrefix}_publishers`
-  });
-  await api.resources.publishers.createKnexTable();
-  mapTable(`${tablePrefix}_publishers`, 'publishers');
+    // Publishers table
+    await api.addResource('publishers', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
+      },
+      relationships: {
+        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' }
+      },
+      tableName: `${tablePrefix}_publishers`
+    })
+    await api.resources.publishers.createKnexTable()
+    mapTable(`${tablePrefix}_publishers`, 'publishers')
 
-  // Authors table
-  await api.addResource('authors', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 }
-    },
-    relationships: {
-      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
-    },
-    tableName: `${tablePrefix}_authors`
-  });
-  await api.resources.authors.createKnexTable();
-  mapTable(`${tablePrefix}_authors`, 'authors');
+    // Authors table
+    await api.addResource('authors', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 }
+      },
+      relationships: {
+        books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
+      },
+      tableName: `${tablePrefix}_authors`
+    })
+    await api.resources.authors.createKnexTable()
+    mapTable(`${tablePrefix}_authors`, 'authors')
 
-  // Books table
-  await api.addResource('books', {
-    schema: {
-      id: { type: 'id' },
-      title: { type: 'string', required: true, max: 300, search: true },
-      country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
-      publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
-    },
-    relationships: {
-      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
-    },
-    tableName: `${tablePrefix}_books`
-  });
-  await api.resources.books.createKnexTable();
-  mapTable(`${tablePrefix}_books`, 'books');
+    // Books table
+    await api.addResource('books', {
+      schema: {
+        id: { type: 'id' },
+        title: { type: 'string', required: true, max: 300, search: true },
+        country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
+        publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
+      },
+      relationships: {
+        authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
+      },
+      tableName: `${tablePrefix}_books`
+    })
+    await api.resources.books.createKnexTable()
+    mapTable(`${tablePrefix}_books`, 'books')
 
-  // Book-Authors pivot table
-  await api.addResource('book_authors', {
-    schema: {
-      id: { type: 'id' },
-      book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
-      author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' }
-    },
-    tableName: `${tablePrefix}_book_authors`
-  });
-  await api.resources.book_authors.createKnexTable();
-  mapTable(`${tablePrefix}_book_authors`, 'book_authors');
-  if (storageMode.isAnyApi()) {
-    const descriptorTenant = api.anyapi?.tenantId || tenantId;
-    const booksDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'books');
-    const authorsDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'authors');
-    const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship;
-    const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship;
-    storageMode.registerLink(
+    // Book-Authors pivot table
+    await api.addResource('book_authors', {
+      schema: {
+        id: { type: 'id' },
+        book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
+        author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' }
+      },
+      tableName: `${tablePrefix}_book_authors`
+    })
+    await api.resources.book_authors.createKnexTable()
+    mapTable(`${tablePrefix}_book_authors`, 'book_authors')
+    if (storageMode.isAnyApi()) {
+      const descriptorTenant = api.anyapi?.tenantId || tenantId
+      const booksDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'books')
+      const authorsDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'authors')
+      const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship
+      const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship
+      storageMode.registerLink(
       `${tablePrefix}_book_authors`,
       'books',
       'authors',
       relationshipKey,
-      inverseRelationshipKey,
-    );
-  }
+      inverseRelationshipKey
+      )
+    }
 
-    return api;
+    return api
   } finally {
     if (storageMode.isAnyApi()) {
-      storageMode.setCurrentTenant(previousTenant);
+      storageMode.setCurrentTenant(previousTenant)
     }
   }
 }
 
-export async function createAccessControlApi(knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || 'access-test-api';
-  const tablePrefix = pluginOptions.tablePrefix || 'access';
+export async function createAccessControlApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'access-test-api'
+  const tablePrefix = pluginOptions.tablePrefix || 'access'
   if (storageMode.isAnyApi()) {
-    storageMode.clearRegistry();
+    storageMode.clearRegistry()
   }
 
   const api = new Api({
     name: apiName,
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
-  const previousTenant = storageMode.currentTenant;
+  const previousTenant = storageMode.currentTenant
   const tenantId = storageMode.isAnyApi()
     ? (pluginOptions.tenantId || `${tablePrefix}_tenant`)
-    : storageMode.defaultTenant;
+    : storageMode.defaultTenant
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(tenantId);
+    storageMode.setCurrentTenant(tenantId)
   }
 
   await api.use(RestApiPlugin, {
@@ -231,12 +231,12 @@ export async function createAccessControlApi(knex, pluginOptions = {}) {
       patch: 'minimal'
     },
     sortableFields: ['id', 'name', 'user_id']
-  });
-  await useStoragePlugin(api, knex, { tenantId });
-  await resetAnyApiTables(knex);
+  })
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
 
   try {
-    await api.use(AccessPlugin, pluginOptions.access || {});
+    await api.use(AccessPlugin, pluginOptions.access || {})
 
     await api.addResource('users', {
       schema: {
@@ -245,9 +245,9 @@ export async function createAccessControlApi(knex, pluginOptions = {}) {
         display_name: { type: 'string', nullable: true }
       },
       tableName: `${tablePrefix}_users`
-    });
-    await api.resources.users.createKnexTable();
-    mapTable(`${tablePrefix}_users`, 'users');
+    })
+    await api.resources.users.createKnexTable()
+    mapTable(`${tablePrefix}_users`, 'users')
 
     await api.addResource('projects', {
       schema: {
@@ -268,9 +268,9 @@ export async function createAccessControlApi(knex, pluginOptions = {}) {
       },
       ownership: true,
       tableName: `${tablePrefix}_projects`
-    });
-    await api.resources.projects.createKnexTable();
-    mapTable(`${tablePrefix}_projects`, 'projects');
+    })
+    await api.resources.projects.createKnexTable()
+    mapTable(`${tablePrefix}_projects`, 'projects')
 
     await api.addResource('notes', {
       schema: {
@@ -292,14 +292,14 @@ export async function createAccessControlApi(knex, pluginOptions = {}) {
       },
       ownership: true,
       tableName: `${tablePrefix}_notes`
-    });
-    await api.resources.notes.createKnexTable();
-    mapTable(`${tablePrefix}_notes`, 'notes');
+    })
+    await api.resources.notes.createKnexTable()
+    mapTable(`${tablePrefix}_notes`, 'notes')
 
-    return api;
+    return api
   } finally {
     if (storageMode.isAnyApi()) {
-      storageMode.setCurrentTenant(previousTenant);
+      storageMode.setCurrentTenant(previousTenant)
     }
   }
 }
@@ -307,13 +307,13 @@ export async function createAccessControlApi(knex, pluginOptions = {}) {
 /**
  * Creates a basic API with bulk operations enabled
  */
-export async function createBulkOperationsApi(knex, pluginOptions = {}) {
-  const { BulkOperationsPlugin } = await import('../../plugins/core/bulk-operations-plugin.js');
-  
+export async function createBulkOperationsApi (knex, pluginOptions = {}) {
+  const { BulkOperationsPlugin } = await import('../../plugins/core/bulk-operations-plugin.js')
+
   const api = await createBasicApi(knex, {
     ...pluginOptions,
     tenantId: pluginOptions.tenantId || 'bulk_ops_tenant'
-  });
+  })
 
   // Add bulk operations plugin
   await api.use(BulkOperationsPlugin, {
@@ -324,20 +324,20 @@ export async function createBulkOperationsApi(knex, pluginOptions = {}) {
       enableOptimizations: true,
       ...pluginOptions['bulk-operations']
     }
-  });
-  
-  return api;
+  })
+
+  return api
 }
 
 /**
  * Creates an extended API with additional fields for more complex testing
  */
-export async function createExtendedApi(knex) {
+export async function createExtendedApi (knex) {
   const api = new Api({
     name: 'extended-test-api',
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'extended_tenant' : storageMode.defaultTenant;
+  const tenantId = storageMode.isAnyApi() ? 'extended_tenant' : storageMode.defaultTenant
 
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
@@ -353,164 +353,164 @@ export async function createExtendedApi(knex) {
       patch: 'minimal'  // Tests expect minimal response with ID
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'price', 'language', 'population', 'name', 'code']
-  });
+  })
   await withTenantContext(tenantId, async () => {
-    await useStoragePlugin(api, knex, { tenantId });
-    await resetAnyApiTables(knex);
+    await useStoragePlugin(api, knex, { tenantId })
+    await resetAnyApiTables(knex)
 
     // Countries with extended fields
     await api.addResource('countries', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 100 },
-      code: { type: 'string', max: 2, unique: true },
-      capital: { type: 'string', max: 100 },
-      population: { type: 'number' },
-      currency: { type: 'string', max: 3 }
-    },
-    relationships: {
-      publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
-      books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' },
-      authors: { type: 'hasMany', target: 'authors', foreignKey: 'nationality_id' }
-    },
-    tableName: 'ext_countries'
-  });
-  await api.resources.countries.createKnexTable();
-  mapTable('ext_countries', 'countries');
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 100 },
+        code: { type: 'string', max: 2, unique: true },
+        capital: { type: 'string', max: 100 },
+        population: { type: 'number' },
+        currency: { type: 'string', max: 3 }
+      },
+      relationships: {
+        publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
+        books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' },
+        authors: { type: 'hasMany', target: 'authors', foreignKey: 'nationality_id' }
+      },
+      tableName: 'ext_countries'
+    })
+    await api.resources.countries.createKnexTable()
+    mapTable('ext_countries', 'countries')
 
-  // Publishers with extended fields
-  await api.addResource('publishers', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' },
-      founded_year: { type: 'number' },
-      website: { type: 'string', max: 255 },
-      active: { type: 'boolean', default: true }
-    },
-    relationships: {
-      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
-        via: 'reviewable'
-      }
-    },
-    tableName: 'ext_publishers'
-  });
-  await api.resources.publishers.createKnexTable();
-  mapTable('ext_publishers', 'publishers');
+    // Publishers with extended fields
+    await api.addResource('publishers', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' },
+        founded_year: { type: 'number' },
+        website: { type: 'string', max: 255 },
+        active: { type: 'boolean', default: true }
+      },
+      relationships: {
+        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
+        reviews: {
+          type: 'hasMany',
+          target: 'reviews',
+          via: 'reviewable'
+        }
+      },
+      tableName: 'ext_publishers'
+    })
+    await api.resources.publishers.createKnexTable()
+    mapTable('ext_publishers', 'publishers')
 
-  // Authors with extended fields
-  await api.addResource('authors', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      birth_date: { type: 'date' },
-      biography: { type: 'string', max: 5000 },
-      nationality_id: { type: 'number', belongsTo: 'countries', as: 'nationality' }
-    },
-    relationships: {
-      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
-        via: 'reviewable'
-      }
-    },
-    tableName: 'ext_authors'
-  });
-  await api.resources.authors.createKnexTable();
-  mapTable('ext_authors', 'authors');
+    // Authors with extended fields
+    await api.addResource('authors', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        birth_date: { type: 'date' },
+        biography: { type: 'string', max: 5000 },
+        nationality_id: { type: 'number', belongsTo: 'countries', as: 'nationality' }
+      },
+      relationships: {
+        books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
+        reviews: {
+          type: 'hasMany',
+          target: 'reviews',
+          via: 'reviewable'
+        }
+      },
+      tableName: 'ext_authors'
+    })
+    await api.resources.authors.createKnexTable()
+    mapTable('ext_authors', 'authors')
 
-  // Books with extended fields
-  await api.addResource('books', {
-    schema: {
-      id: { type: 'id' },
-      title: { type: 'string', required: true, max: 300, search: true },
-      isbn: { type: 'string', max: 13 },
-      pages: { type: 'number' },
-      price: { type: 'number', search: true }, // Store price as string for decimal precision
-      published_date: { type: 'date' },
-      language: { type: 'string', max: 2, default: 'en', search: true },
-      country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
-      publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
-    },
-    relationships: {
-      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
-        via: 'reviewable'
-      }
-    },
-    tableName: 'ext_books'
-  });
-  await api.resources.books.createKnexTable();
-  mapTable('ext_books', 'books');
+    // Books with extended fields
+    await api.addResource('books', {
+      schema: {
+        id: { type: 'id' },
+        title: { type: 'string', required: true, max: 300, search: true },
+        isbn: { type: 'string', max: 13 },
+        pages: { type: 'number' },
+        price: { type: 'number', search: true }, // Store price as string for decimal precision
+        published_date: { type: 'date' },
+        language: { type: 'string', max: 2, default: 'en', search: true },
+        country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
+        publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
+      },
+      relationships: {
+        authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
+        reviews: {
+          type: 'hasMany',
+          target: 'reviews',
+          via: 'reviewable'
+        }
+      },
+      tableName: 'ext_books'
+    })
+    await api.resources.books.createKnexTable()
+    mapTable('ext_books', 'books')
 
-  // Book-Authors pivot with extended fields
-  await api.addResource('book_authors', {
-    schema: {
-      id: { type: 'id' },
-      book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
-      author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' },
-      contribution_type: { type: 'string', max: 50 },
-      order: { type: 'number' }
-    },
-    tableName: 'ext_book_authors'
-  });
-  await api.resources.book_authors.createKnexTable();
-  mapTable('ext_book_authors', 'book_authors');
-  if (storageMode.isAnyApi()) {
-    const booksDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'books');
-    const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'authors');
-    const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship;
-    const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship;
-    storageMode.registerLink('ext_book_authors', 'books', 'authors', relationshipKey, inverseRelationshipKey);
-  }
+    // Book-Authors pivot with extended fields
+    await api.addResource('book_authors', {
+      schema: {
+        id: { type: 'id' },
+        book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
+        author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' },
+        contribution_type: { type: 'string', max: 50 },
+        order: { type: 'number' }
+      },
+      tableName: 'ext_book_authors'
+    })
+    await api.resources.book_authors.createKnexTable()
+    mapTable('ext_book_authors', 'book_authors')
+    if (storageMode.isAnyApi()) {
+      const booksDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'books')
+      const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'authors')
+      const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship
+      const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship
+      storageMode.registerLink('ext_book_authors', 'books', 'authors', relationshipKey, inverseRelationshipKey)
+    }
 
-  // Polymorphic reviews (can go on authors, books and publishers)
-  await api.addResource('reviews', {
-    schema: {
-      id: { type: 'id' },
-      rating: { type: 'number', required: true, min: 1, max: 5 },
-      title: { type: 'string', max: 200 },
-      content: { type: 'string', required: true, max: 5000 },
-      reviewer_name: { type: 'string', required: true, max: 100 },
-      review_date: { type: 'dateTime', default: 'now()' },
-      helpful_count: { type: 'number', default: 0 },
-      reviewable_type: { type: 'string', required: true },
-      reviewable_id: { type: 'number', required: true }
-    },
-    relationships: {
-      reviewable: {
-        belongsToPolymorphic: {
-          types: ['books', 'authors', 'publishers'],
-          typeField: 'reviewable_type',
-          idField: 'reviewable_id'
+    // Polymorphic reviews (can go on authors, books and publishers)
+    await api.addResource('reviews', {
+      schema: {
+        id: { type: 'id' },
+        rating: { type: 'number', required: true, min: 1, max: 5 },
+        title: { type: 'string', max: 200 },
+        content: { type: 'string', required: true, max: 5000 },
+        reviewer_name: { type: 'string', required: true, max: 100 },
+        review_date: { type: 'dateTime', default: 'now()' },
+        helpful_count: { type: 'number', default: 0 },
+        reviewable_type: { type: 'string', required: true },
+        reviewable_id: { type: 'number', required: true }
+      },
+      relationships: {
+        reviewable: {
+          belongsToPolymorphic: {
+            types: ['books', 'authors', 'publishers'],
+            typeField: 'reviewable_type',
+            idField: 'reviewable_id'
+          }
         }
-      }
-    },
-    tableName: 'ext_reviews'
-  });
-  await api.resources.reviews.createKnexTable();
-  mapTable('ext_reviews', 'reviews');
-  });
+      },
+      tableName: 'ext_reviews'
+    })
+    await api.resources.reviews.createKnexTable()
+    mapTable('ext_reviews', 'reviews')
+  })
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with limited include depth for testing depth validation
  * Uses 'limited_' prefix for all tables to avoid conflicts
  */
-export async function createLimitedDepthApi(knex) {
+export async function createLimitedDepthApi (knex) {
   const api = new Api({
     name: 'limited-depth-api',
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'limited_depth_tenant' : storageMode.defaultTenant;
+  const tenantId = storageMode.isAnyApi() ? 'limited_depth_tenant' : storageMode.defaultTenant
 
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
@@ -527,99 +527,99 @@ export async function createLimitedDepthApi(knex) {
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'name', 'code'],
     includeDepthLimit: 2  // Key difference: limit is 2 instead of default 3
-  });
+  })
   await withTenantContext(tenantId, async () => {
-    await useStoragePlugin(api, knex, { tenantId });
+    await useStoragePlugin(api, knex, { tenantId })
 
     // Use different table names with 'limited_' prefix to avoid conflicts
     await api.addResource('countries', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 100 },
-      code: { type: 'string', max: 2, unique: true }
-    },
-    relationships: {
-      publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
-      books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
-    },
-    tableName: 'limited_countries',
-  });
-  await api.resources.countries.createKnexTable();
-  mapTable('limited_countries', 'countries');
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 100 },
+        code: { type: 'string', max: 2, unique: true }
+      },
+      relationships: {
+        publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
+        books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
+      },
+      tableName: 'limited_countries',
+    })
+    await api.resources.countries.createKnexTable()
+    mapTable('limited_countries', 'countries')
 
-  await api.addResource('publishers', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
-    },
-    relationships: {
-      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
-      authors: { type: 'hasMany', target: 'authors', foreignKey: 'publisher_id' }
-    },
-    tableName: 'limited_publishers'
-  });
-  await api.resources.publishers.createKnexTable();
-  mapTable('limited_publishers', 'publishers');
+    await api.addResource('publishers', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
+      },
+      relationships: {
+        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
+        authors: { type: 'hasMany', target: 'authors', foreignKey: 'publisher_id' }
+      },
+      tableName: 'limited_publishers'
+    })
+    await api.resources.publishers.createKnexTable()
+    mapTable('limited_publishers', 'publishers')
 
-  await api.addResource('authors', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      publisher_id: { type: 'number', nullable: true, belongsTo: 'publishers', as: 'publisher' }
-    },
-    relationships: {
-      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
-    },
-    tableName: 'limited_authors'
-  });
-  await api.resources.authors.createKnexTable();
+    await api.addResource('authors', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        publisher_id: { type: 'number', nullable: true, belongsTo: 'publishers', as: 'publisher' }
+      },
+      relationships: {
+        books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
+      },
+      tableName: 'limited_authors'
+    })
+    await api.resources.authors.createKnexTable()
 
-  await api.addResource('books', {
-    schema: {
-      id: { type: 'id' },
-      title: { type: 'string', required: true, max: 300, search: true },
-      country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
-      publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
-    },
-    relationships: {
-      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
-    },
-    tableName: 'limited_books'
-  });
-  await api.resources.books.createKnexTable();
+    await api.addResource('books', {
+      schema: {
+        id: { type: 'id' },
+        title: { type: 'string', required: true, max: 300, search: true },
+        country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
+        publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
+      },
+      relationships: {
+        authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
+      },
+      tableName: 'limited_books'
+    })
+    await api.resources.books.createKnexTable()
 
-  await api.addResource('book_authors', {
-    schema: {
-      id: { type: 'id' },
-      book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
-      author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' }
-    },
-    tableName: 'limited_book_authors'
-  });
-  await api.resources.book_authors.createKnexTable();
-  mapTable('limited_book_authors', 'book_authors');
-  if (storageMode.isAnyApi()) {
-    const booksDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'books');
-    const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'authors');
-    const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship;
-    const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship;
-    storageMode.registerLink('limited_book_authors', 'books', 'authors', relationshipKey, inverseRelationshipKey);
-  }
-  });
+    await api.addResource('book_authors', {
+      schema: {
+        id: { type: 'id' },
+        book_id: { type: 'number', required: true, belongsTo: 'books', as: 'book' },
+        author_id: { type: 'number', required: true, belongsTo: 'authors', as: 'author' }
+      },
+      tableName: 'limited_book_authors'
+    })
+    await api.resources.book_authors.createKnexTable()
+    mapTable('limited_book_authors', 'book_authors')
+    if (storageMode.isAnyApi()) {
+      const booksDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'books')
+      const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenantId, 'authors')
+      const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship
+      const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship
+      storageMode.registerLink('limited_book_authors', 'books', 'authors', relationshipKey, inverseRelationshipKey)
+    }
+  })
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API configuration for pagination testing
  */
-export async function createPaginationApi(knex, options = {}) {
+export async function createPaginationApi (knex, options = {}) {
   const api = new Api({
     name: 'pagination-test-api',
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'pagination_tenant' : storageMode.defaultTenant;
+  const tenantId = storageMode.isAnyApi() ? 'pagination_tenant' : storageMode.defaultTenant
 
   const restApiOptions = {
     simplifiedApi: false,
@@ -636,66 +636,66 @@ export async function createPaginationApi(knex, options = {}) {
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'name', 'code'],
     ...options  // Allow overriding options likereturnBasePath, enablePaginationCounts
-  };
+  }
 
-  await api.use(RestApiPlugin, restApiOptions);
+  await api.use(RestApiPlugin, restApiOptions)
   await withTenantContext(tenantId, async () => {
-    await useStoragePlugin(api, knex, { tenantId });
+    await useStoragePlugin(api, knex, { tenantId })
 
     // Countries table
     await api.addResource('countries', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 100 },
-      code: { type: 'string', max: 2, unique: true }
-    },
-    relationships: {
-      publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
-      books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
-    },
-    tableName: 'pagination_countries'
-  });
-  await api.resources.countries.createKnexTable();
-  mapTable('pagination_countries', 'countries');
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 100 },
+        code: { type: 'string', max: 2, unique: true }
+      },
+      relationships: {
+        publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
+        books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
+      },
+      tableName: 'pagination_countries'
+    })
+    await api.resources.countries.createKnexTable()
+    mapTable('pagination_countries', 'countries')
 
-  // Publishers table
-  await api.addResource('publishers', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 200 },
-      country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
-    },
-    relationships: {
-      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' }
-    },
-    tableName: 'pagination_publishers'
-  });
-  await api.resources.publishers.createKnexTable();
-  mapTable('pagination_publishers', 'publishers');
+    // Publishers table
+    await api.addResource('publishers', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 200 },
+        country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
+      },
+      relationships: {
+        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' }
+      },
+      tableName: 'pagination_publishers'
+    })
+    await api.resources.publishers.createKnexTable()
+    mapTable('pagination_publishers', 'publishers')
 
-  // Books table
-  await api.addResource('books', {
-    schema: {
-      id: { type: 'id' },
-      title: { type: 'string', required: true, max: 300, search: true },
-      country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
-      publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
-    },
-    tableName: 'pagination_books'
-  });
-  await api.resources.books.createKnexTable();
-  mapTable('pagination_books', 'books');
-  });
+    // Books table
+    await api.addResource('books', {
+      schema: {
+        id: { type: 'id' },
+        title: { type: 'string', required: true, max: 300, search: true },
+        country_id: { type: 'number', required: true, belongsTo: 'countries', as: 'country', search: true },
+        publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
+      },
+      tableName: 'pagination_books'
+    })
+    await api.resources.books.createKnexTable()
+    mapTable('pagination_books', 'books')
+  })
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with WebSocket/Socket.IO support for testing
  */
-export async function createWebSocketApi(knex, pluginOptions = {}) {
-  const { SocketIOPlugin } = await import('../../plugins/core/socketio-plugin.js');
-  const { jwtVerify } = await import('jose');
+export async function createWebSocketApi (knex, pluginOptions = {}) {
+  const { SocketIOPlugin } = await import('../../plugins/core/socketio-plugin.js')
+  const { jwtVerify } = await import('jose')
 
   const api = await createBasicApi(knex, {
     ...pluginOptions,
@@ -704,91 +704,91 @@ export async function createWebSocketApi(knex, pluginOptions = {}) {
     express: {
       port: 0 // Let OS assign a port
     }
-  });
+  })
 
-  const socketioOptions = { ...(pluginOptions['socketio'] || {}) };
-  const authOptions = { ...(socketioOptions.auth || {}) };
-  const sharedSecret = authOptions.sharedSecret || socketioOptions.sharedSecret || 'test-secret-key';
+  const socketioOptions = { ...(pluginOptions['socketio'] || {}) }
+  const authOptions = { ...(socketioOptions.auth || {}) }
+  const sharedSecret = authOptions.sharedSecret || socketioOptions.sharedSecret || 'test-secret-key'
 
   if (!authOptions.authenticate) {
     authOptions.authenticate = async ({ socket }) => {
-      const token = socket.handshake.auth?.token;
+      const token = socket.handshake.auth?.token
       if (!token) {
-        throw new Error('Authentication required');
+        throw new Error('Authentication required')
       }
 
-      const encoder = new TextEncoder();
-      const key = encoder.encode(sharedSecret);
-      const { payload } = await jwtVerify(token, key);
+      const encoder = new TextEncoder()
+      const key = encoder.encode(sharedSecret)
+      const { payload } = await jwtVerify(token, key)
 
       const roles = Array.isArray(payload.roles)
         ? payload.roles
-        : payload.role ? [payload.role] : [];
+        : payload.role ? [payload.role] : []
 
       const authContext = {
         userId: payload.userId || payload.sub,
         roles,
         token: payload
-      };
+      }
 
       if (!authContext.userId) {
-        throw new Error('Token is missing required user identifier');
+        throw new Error('Token is missing required user identifier')
       }
 
-      return authContext;
-    };
+      return authContext
+    }
   }
 
   if (authOptions.requireAuth === undefined) {
-    authOptions.requireAuth = true;
+    authOptions.requireAuth = true
   }
 
-  socketioOptions.auth = authOptions;
+  socketioOptions.auth = authOptions
+
+  await api.use(SocketIOPlugin, socketioOptions)
 
-  await api.use(SocketIOPlugin, socketioOptions);
-  
   // Create and start Express server
-  const app = express();
-  api.http.express.app = app;
-  
+  const app = express()
+  api.http.express.app = app
+
   // Mount the API routes
-  app.use('/api', api.http.express.router);
-  
+  app.use('/api', api.http.express.router)
+
   // Create HTTP server
-  const server = createServer(app);
-  
+  const server = createServer(app)
+
   // Start Socket.IO server
-  await api.startSocketServer(server);
-  
+  await api.startSocketServer(server)
+
   // Start listening
   await new Promise((resolve) => {
     server.listen(0, () => {
-      resolve();
-    });
-  });
-  
-  return { api, server };
+      resolve()
+    })
+  })
+
+  return { api, server }
 }
 
 /**
  * Creates an API with computed fields for testing
  */
-export async function createComputedFieldsApi(knex, pluginOptions = {}) {
+export async function createComputedFieldsApi (knex, pluginOptions = {}) {
   const api = new Api({
     name: 'computed-fields-test-api',
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'computed_fields_tenant' : storageMode.defaultTenant;
+  const tenantId = storageMode.isAnyApi() ? 'computed_fields_tenant' : storageMode.defaultTenant
 
   await api.use(RestApiPlugin, {
     simplifiedApi: true,
     simplifiedTransport: true
-  });
+  })
 
   await withTenantContext(tenantId, async () => {
-    await useStoragePlugin(api, knex, { tenantId });
-    await resetAnyApiTables(knex);
+    await useStoragePlugin(api, knex, { tenantId })
+    await resetAnyApiTables(knex)
 
     // Products resource with computed fields
     await api.addResource('products', {
@@ -803,8 +803,8 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
           computed: true,
           dependencies: ['price', 'cost'],
           compute: ({ attributes }) => {
-            if (!attributes.price || attributes.price === 0) return 0;
-            return Number(((attributes.price - attributes.cost) / attributes.price * 100).toFixed(2));
+            if (!attributes.price || attributes.price === 0) return 0
+            return Number(((attributes.price - attributes.cost) / attributes.price * 100).toFixed(2))
           }
         },
         profit_amount: {
@@ -812,7 +812,7 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
           computed: true,
           dependencies: ['price', 'cost'],
           compute: ({ attributes }) => {
-            return Number((attributes.price - attributes.cost).toFixed(2));
+            return Number((attributes.price - attributes.cost).toFixed(2))
           }
         }
       },
@@ -820,10 +820,10 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
         reviews: { type: 'hasMany', target: 'reviews', foreignKey: 'product_id' }
       },
       tableName: 'test_products'
-    });
-    await api.resources.products.createKnexTable();
-    mapTable('searchmerge_products', 'products');
-    mapTable('test_products', 'products');
+    })
+    await api.resources.products.createKnexTable()
+    mapTable('searchmerge_products', 'products')
+    mapTable('test_products', 'products')
 
     // Reviews resource with computed fields
     await api.addResource('reviews', {
@@ -841,8 +841,8 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
           computed: true,
           dependencies: ['helpful_votes', 'total_votes'],
           compute: ({ attributes }) => {
-            if (attributes.total_votes === 0) return null;
-            return Number(((attributes.helpful_votes / attributes.total_votes) * 100).toFixed(0));
+            if (attributes.total_votes === 0) return null
+            return Number(((attributes.helpful_votes / attributes.total_votes) * 100).toFixed(0))
           }
         },
         is_helpful: {
@@ -850,49 +850,49 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
           computed: true,
           dependencies: ['helpful_votes', 'total_votes', 'spam_score'],
           compute: ({ attributes }) => {
-            if (attributes.total_votes < 10) return null;
-            const helpfulnessScore = (attributes.helpful_votes / attributes.total_votes) * 100;
-            return helpfulnessScore > 70 && attributes.spam_score < 0.5;
+            if (attributes.total_votes < 10) return null
+            const helpfulnessScore = (attributes.helpful_votes / attributes.total_votes) * 100
+            return helpfulnessScore > 70 && attributes.spam_score < 0.5
           }
         }
       },
       tableName: 'test_reviews'
-    });
-    await api.resources.reviews.createKnexTable();
-    mapTable('test_reviews', 'reviews');
-  });
+    })
+    await api.resources.reviews.createKnexTable()
+    mapTable('test_reviews', 'reviews')
+  })
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with field getters for testing
  */
-export async function createFieldGettersApi(knex, pluginOptions = {}) {
+export async function createFieldGettersApi (knex, pluginOptions = {}) {
   const api = new Api({
     name: 'field-getters-test-api',
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'field_getters_tenant' : storageMode.defaultTenant;
-  const previousTenant = storageMode.currentTenant;
+  const tenantId = storageMode.isAnyApi() ? 'field_getters_tenant' : storageMode.defaultTenant
+  const previousTenant = storageMode.currentTenant
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(tenantId);
+    storageMode.setCurrentTenant(tenantId)
   }
 
   await api.use(RestApiPlugin, {
     simplifiedApi: true,
     simplifiedTransport: true
-  });
-  
-  await useStoragePlugin(api, knex, { tenantId });
-  await resetAnyApiTables(knex);
+  })
+
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
 
   // Users resource with basic getters
   await api.addResource('users', {
     schema: {
       id: { type: 'id' },
-      email: { 
+      email: {
         type: 'string',
         nullable: true,
         getter: (value) => value?.toLowerCase().trim()
@@ -906,24 +906,24 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
         type: 'string',
         nullable: true,
         getter: (value) => {
-          if (!value) return null;
+          if (!value) return null
           // Remove all non-digits and format
-          const digits = value.replace(/\D/g, '');
+          const digits = value.replace(/\D/g, '')
           if (digits.length === 10) {
-            return `(${digits.slice(0,3)}) ${digits.slice(3,6)}-${digits.slice(6)}`;
+            return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`
           }
-          return value;
+          return value
         }
       },
       metadata_json: {
         type: 'string',
         nullable: true,
         getter: (value) => {
-          if (!value) return {};
+          if (!value) return {}
           try {
-            return JSON.parse(value);
+            return JSON.parse(value)
           } catch {
-            return {};
+            return {}
           }
         }
       },
@@ -931,16 +931,16 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
         type: 'string',
         nullable: true,
         getter: (value) => {
-          if (!value) return [];
-          return value.split(',').map(t => t.trim()).filter(t => t);
+          if (!value) return []
+          return value.split(',').map(t => t.trim()).filter(t => t)
         }
       }
     },
     tableName: 'getter_users'
-  });
-  await api.resources.users.createKnexTable();
-  mapTable('searchmerge_users', 'users');
-  mapTable('getter_users', 'users');
+  })
+  await api.resources.users.createKnexTable()
+  mapTable('searchmerge_users', 'users')
+  mapTable('getter_users', 'users')
 
   // Products resource with getters and computed fields
   await api.addResource('products', {
@@ -954,8 +954,8 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
         type: 'string',
         getter: (value) => {
           // Truncate long descriptions
-          if (!value) return '';
-          return value.length > 50 ? value.substring(0, 47) + '...' : value;
+          if (!value) return ''
+          return value.length > 50 ? value.substring(0, 47) + '...' : value
         }
       },
       price_str: {
@@ -972,7 +972,7 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
         dependencies: ['price_str', 'tax_rate_str'],
         compute: ({ attributes }) => {
           // Should see numbers from getters, not strings
-          return attributes.price_str * (1 + attributes.tax_rate_str);
+          return attributes.price_str * (1 + attributes.tax_rate_str)
         }
       }
     },
@@ -980,9 +980,9 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
       reviews: { type: 'hasMany', target: 'reviews', foreignKey: 'product_id' }
     },
     tableName: 'getter_products'
-  });
-  await api.resources.products.createKnexTable();
-  mapTable('getter_products', 'products');
+  })
+  await api.resources.products.createKnexTable()
+  mapTable('getter_products', 'products')
 
   // Reviews resource with getters
   await api.addResource('reviews', {
@@ -996,9 +996,9 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
       rating: { type: 'number' }
     },
     tableName: 'getter_reviews'
-  });
-  await api.resources.reviews.createKnexTable();
-  mapTable('getter_reviews', 'reviews');
+  })
+  await api.resources.reviews.createKnexTable()
+  mapTable('getter_reviews', 'reviews')
 
   // Resource with getter dependencies
   await api.addResource('formatted_data', {
@@ -1011,28 +1011,28 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
       },
       step2: {
         type: 'string',
-        nullable: true, 
+        nullable: true,
         getter: (value, { attributes }) => {
-          if (!value) return value; // Return null/undefined as-is
+          if (!value) return value // Return null/undefined as-is
           // Depends on step1 being trimmed first
-          return `${value} [step1: ${attributes.step1}]`;
+          return `${value} [step1: ${attributes.step1}]`
         },
         runGetterAfter: ['step1']
       },
       step3: {
         type: 'string',
         getter: (value, { attributes }) => {
-          if (!value) return value; // Return null/undefined as-is
+          if (!value) return value // Return null/undefined as-is
           // Depends on step2
-          return `${value} [step2: ${attributes.step2}]`;
+          return `${value} [step2: ${attributes.step2}]`
         },
         runGetterAfter: ['step2']
       }
     },
     tableName: 'getter_formatted'
-  });
-  await api.resources.formatted_data.createKnexTable();
-  mapTable('getter_formatted', 'formatted_data');
+  })
+  await api.resources.formatted_data.createKnexTable()
+  mapTable('getter_formatted', 'formatted_data')
 
   // Async getters example
   await api.addResource('encrypted_data', {
@@ -1042,48 +1042,48 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
         type: 'string',
         nullable: true,
         getter: async (value) => {
-          if (!value) return null;
+          if (!value) return null
           // Simulate async decryption
-          await new Promise(resolve => setTimeout(resolve, 5));
-          return Buffer.from(value, 'base64').toString();
+          await new Promise(resolve => setTimeout(resolve, 5))
+          return Buffer.from(value, 'base64').toString()
         }
       },
       data: {
         type: 'string',
         nullable: true,
         getter: async (value, context) => {
-          if (!value) return null;
-          await new Promise(resolve => setTimeout(resolve, 5));
-          const decrypted = Buffer.from(value, 'base64').toString();
-          return `[${context.scopeName}] ${decrypted}`;
+          if (!value) return null
+          await new Promise(resolve => setTimeout(resolve, 5))
+          const decrypted = Buffer.from(value, 'base64').toString()
+          return `[${context.scopeName}] ${decrypted}`
         }
       }
     },
     tableName: 'getter_encrypted'
-  });
-  await api.resources.encrypted_data.createKnexTable();
-  mapTable('getter_encrypted', 'encrypted_data');
+  })
+  await api.resources.encrypted_data.createKnexTable()
+  mapTable('getter_encrypted', 'encrypted_data')
 
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(previousTenant);
+    storageMode.setCurrentTenant(previousTenant)
   }
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with field setters for testing
  */
-export async function createFieldSettersApi(knex, pluginOptions = {}) {
+export async function createFieldSettersApi (knex, pluginOptions = {}) {
   const api = new Api({
     name: 'field-setters-test-api',
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'field_setters_tenant' : storageMode.defaultTenant;
-  const previousTenant = storageMode.currentTenant;
+  const tenantId = storageMode.isAnyApi() ? 'field_setters_tenant' : storageMode.defaultTenant
+  const previousTenant = storageMode.currentTenant
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(tenantId);
+    storageMode.setCurrentTenant(tenantId)
   }
 
   await api.use(RestApiPlugin, {
@@ -1094,16 +1094,16 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
       put: true,
       patch: true
     }
-  });
-  
-  await useStoragePlugin(api, knex, { tenantId });
-  await resetAnyApiTables(knex);
+  })
+
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
 
   // Users resource with basic setters
   await api.addResource('users', {
     schema: {
       id: { type: 'id' },
-      email: { 
+      email: {
         type: 'string',
         required: true,
         setter: (value) => value?.toLowerCase().trim()
@@ -1118,13 +1118,13 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
         setter: (value) => value  // Pass through
       },
       preferences: {
-        type: 'string',  // Accepts string, stored as string  
+        type: 'string',  // Accepts string, stored as string
         setter: (value) => value  // Pass through
       }
     },
     tableName: 'setter_users'
-  });
-  await api.resources.users.createKnexTable();
+  })
+  await api.resources.users.createKnexTable()
 
   // Products with type conversion setters
   await api.addResource('products', {
@@ -1137,7 +1137,7 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
         min: 0,
         setter: (value) => {
           // Convert to cents and round
-          return Math.round(value * 100);
+          return Math.round(value * 100)
         }
       },
       discount_percent: {
@@ -1152,8 +1152,8 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
       }
     },
     tableName: 'setter_products'
-  });
-  await api.resources.products.createKnexTable();
+  })
+  await api.resources.products.createKnexTable()
 
   // Secure data with async setters
   await api.addResource('secure_data', {
@@ -1165,44 +1165,44 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
         min: 8,
         setter: async (value) => {
           // Simulate async password hashing
-          await new Promise(resolve => setTimeout(resolve, 5));
-          return `hashed:${value}`;
+          await new Promise(resolve => setTimeout(resolve, 5))
+          return `hashed:${value}`
         }
       },
       api_key: {
         type: 'string',
         setter: async (value) => {
-          if (!value) return null;
+          if (!value) return null
           // Simulate encryption
-          await new Promise(resolve => setTimeout(resolve, 5));
-          return Buffer.from(value).toString('base64');
+          await new Promise(resolve => setTimeout(resolve, 5))
+          return Buffer.from(value).toString('base64')
         }
       },
       data: {
         type: 'string',
         setter: async (value) => {
-          if (!value) return null;
-          return Buffer.from(value).toString('base64');
+          if (!value) return null
+          return Buffer.from(value).toString('base64')
         }
       }
     },
     tableName: 'setter_secure'
-  });
-  await api.resources.secure_data.createKnexTable();
+  })
+  await api.resources.secure_data.createKnexTable()
 
   // Resource with setter dependencies
   await api.addResource('computed_data', {
     schema: {
       id: { type: 'id' },
-      base_value: { 
+      base_value: {
         type: 'number',
         setter: (value) => value || 0
       },
-      multiplier: { 
+      multiplier: {
         type: 'number',
         setter: (value) => value || 1
       },
-      adjustment: { 
+      adjustment: {
         type: 'number',
         setter: (value) => value || 0
       },
@@ -1210,7 +1210,7 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
         type: 'number',
         setter: (value, { attributes }) => {
           // Calculate based on other fields
-          return (attributes.base_value || 0) * (attributes.multiplier || 1);
+          return (attributes.base_value || 0) * (attributes.multiplier || 1)
         },
         runSetterAfter: ['base_value', 'multiplier']
       },
@@ -1218,14 +1218,14 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
         type: 'number',
         setter: (value, { attributes }) => {
           // Depends on calculated_value
-          return (attributes.calculated_value || 0) + (attributes.adjustment || 0);
+          return (attributes.calculated_value || 0) + (attributes.adjustment || 0)
         },
         runSetterAfter: ['calculated_value', 'adjustment']
       }
     },
     tableName: 'setter_computed'
-  });
-  await api.resources.computed_data.createKnexTable();
+  })
+  await api.resources.computed_data.createKnexTable()
 
   // Nullable fields handling
   await api.addResource('nullable_data', {
@@ -1251,8 +1251,8 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
       }
     },
     tableName: 'setter_nullable'
-  });
-  await api.resources.nullable_data.createKnexTable();
+  })
+  await api.resources.nullable_data.createKnexTable()
 
   // Validated data
   await api.addResource('validated_data', {
@@ -1278,27 +1278,27 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
       }
     },
     tableName: 'setter_validated'
-  });
-  await api.resources.validated_data.createKnexTable();
+  })
+  await api.resources.validated_data.createKnexTable()
 
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(previousTenant);
+    storageMode.setCurrentTenant(previousTenant)
   }
 
-  return api;
+  return api
 }
 
-export async function createMultiHomeApi(knex, pluginOptions = {}) {
-  const { MultiHomePlugin } = await import('../../plugins/core/rest-api-multihome-plugin.js');
-  
+export async function createMultiHomeApi (knex, pluginOptions = {}) {
+  const { MultiHomePlugin } = await import('../../plugins/core/rest-api-multihome-plugin.js')
+
   const api = new Api({
     name: 'multihome-test-api',
-  });
+  })
 
-  const tenantId = storageMode.isAnyApi() ? 'multihome_tenant' : storageMode.defaultTenant;
-  const previousTenant = storageMode.currentTenant;
+  const tenantId = storageMode.isAnyApi() ? 'multihome_tenant' : storageMode.defaultTenant
+  const previousTenant = storageMode.currentTenant
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(tenantId);
+    storageMode.setCurrentTenant(tenantId)
   }
 
   await api.use(RestApiPlugin, {
@@ -1315,16 +1315,16 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       patch: 'minimal'
     },
     sortableFields: ['id', 'title', 'name', 'tenant_id']
-  });
-  
-  await useStoragePlugin(api, knex, { tenantId });
-  await resetAnyApiTables(knex);
-  
+  })
+
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
+
   // Add Express plugin if requested for transport testing
   if (pluginOptions.includeExpress) {
-    await api.use(ExpressPlugin, pluginOptions.express || {});
+    await api.use(ExpressPlugin, pluginOptions.express || {})
   }
-  
+
   // Add MultiHome plugin with configuration
   await api.use(MultiHomePlugin, {
     field: pluginOptions.field || 'tenant_id',
@@ -1333,9 +1333,9 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
     allowMissing: pluginOptions.allowMissing || false,
     extractor: pluginOptions.extractor || ((request) => {
       // Default to header extraction for tests
-      return request.headers?.['x-tenant-id'] || null;
+      return request.headers?.['x-tenant-id'] || null
     })
-  });
+  })
 
   // Tenant-specific resources
   await api.addResource('projects', {
@@ -1350,9 +1350,9 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       tasks: { type: 'hasMany', target: 'tasks', foreignKey: 'project_id' }
     },
     tableName: 'multihome_projects'
-  });
-  await api.resources.projects.createKnexTable();
-  mapTable('multihome_projects', 'projects');
+  })
+  await api.resources.projects.createKnexTable()
+  mapTable('multihome_projects', 'projects')
 
   await api.addResource('tasks', {
     schema: {
@@ -1363,9 +1363,9 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       tenant_id: { type: 'string', required: true }
     },
     tableName: 'multihome_tasks'
-  });
-  await api.resources.tasks.createKnexTable();
-  mapTable('multihome_tasks', 'tasks');
+  })
+  await api.resources.tasks.createKnexTable()
+  mapTable('multihome_tasks', 'tasks')
 
   await api.addResource('users', {
     schema: {
@@ -1376,9 +1376,9 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       tenant_id: { type: 'string', required: true }
     },
     tableName: 'multihome_users'
-  });
-  await api.resources.users.createKnexTable();
-  mapTable('multihome_users', 'users');
+  })
+  await api.resources.users.createKnexTable()
+  mapTable('multihome_users', 'users')
 
   // Global resource (excluded from multihome)
   await api.addResource('system_settings', {
@@ -1388,26 +1388,26 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       value: { type: 'string', required: true }
     },
     tableName: 'multihome_system_settings'
-  });
-  await api.resources.system_settings.createKnexTable();
-  mapTable('multihome_system_settings', 'system_settings');
+  })
+  await api.resources.system_settings.createKnexTable()
+  mapTable('multihome_system_settings', 'system_settings')
 
   if (storageMode.isAnyApi()) {
-    storageMode.setCurrentTenant(previousTenant);
+    storageMode.setCurrentTenant(previousTenant)
   }
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with positioning support for testing
  */
-export async function createPositioningApi(knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || 'positioning-test-api';
-  const tablePrefix = pluginOptions.tablePrefix || 'positioning';
+export async function createPositioningApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'positioning-test-api'
+  const tablePrefix = pluginOptions.tablePrefix || 'positioning'
   const api = new Api({
     name: apiName,
-  });
+  })
 
   const restApiOptions = {
     simplifiedApi: true,  // Changed to true to allow simplified API calls in tests
@@ -1424,11 +1424,11 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
     },
     sortableFields: ['id', 'title', 'name', 'position', 'sort_order', 'category_id', 'project_id', 'status'],
     ...pluginOptions['rest-api']
-  };
+  }
 
-  await api.use(RestApiPlugin, restApiOptions);
-  await useStoragePlugin(api, knex);
-  await resetAnyApiTables(knex);
+  await api.use(RestApiPlugin, restApiOptions)
+  await useStoragePlugin(api, knex)
+  await resetAnyApiTables(knex)
 
   // Categories (for grouping tasks)
   await api.addResource('categories', {
@@ -1437,9 +1437,9 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
       name: { type: 'string', required: true, max: 100 }
     },
     tableName: `${tablePrefix}_categories`
-  });
-  await api.resources.categories.createKnexTable();
-  mapTable(`${tablePrefix}_categories`, 'categories');
+  })
+  await api.resources.categories.createKnexTable()
+  mapTable(`${tablePrefix}_categories`, 'categories')
 
   // Tasks (main positioning test resource)
   await api.addResource('tasks', {
@@ -1456,9 +1456,9 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
       category: { belongsTo: 'categories' }
     },
     tableName: `${tablePrefix}_tasks`
-  });
-  await api.resources.tasks.createKnexTable();
-  mapTable(`${tablePrefix}_tasks`, 'tasks');
+  })
+  await api.resources.tasks.createKnexTable()
+  mapTable(`${tablePrefix}_tasks`, 'tasks')
 
   // Projects (for multi-filter testing)
   await api.addResource('projects', {
@@ -1467,9 +1467,9 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
       name: { type: 'string', required: true, max: 100 }
     },
     tableName: `${tablePrefix}_projects`
-  });
-  await api.resources.projects.createKnexTable();
-  mapTable(`${tablePrefix}_projects`, 'projects');
+  })
+  await api.resources.projects.createKnexTable()
+  mapTable(`${tablePrefix}_projects`, 'projects')
 
   // Items (flexible resource for various positioning tests)
   await api.addResource('items', {
@@ -1487,27 +1487,27 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
       project: { belongsTo: 'projects' }
     },
     tableName: `${tablePrefix}_items`
-  });
-  await api.resources.items.createKnexTable();
-  mapTable(`${tablePrefix}_items`, 'items');
+  })
+  await api.resources.items.createKnexTable()
+  mapTable(`${tablePrefix}_items`, 'items')
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API with custom idProperty for all resources to test idProperty functionality
  * Uses 'custom_id_' prefix for all tables to avoid conflicts
  */
-export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || `custom-id-test-api`;
-  const tablePrefix = pluginOptions.tablePrefix || 'custom_id';
+export async function createCustomIdPropertyApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'custom-id-test-api'
+  const tablePrefix = pluginOptions.tablePrefix || 'custom_id'
   const api = new Api({
     name: apiName,
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
   if (storageMode.isAnyApi()) {
-    storageMode.clearRegistry();
+    storageMode.clearRegistry()
   }
 
   const restApiOptions = {
@@ -1525,11 +1525,11 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     sortableFields: ['country_id', 'publisher_id', 'author_id', 'book_id', 'title', 'name', 'code'],
     ...pluginOptions['rest-api']  // Merge any custom options for rest-api plugin
-  };
+  }
 
-  await api.use(RestApiPlugin, restApiOptions);
-  await useStoragePlugin(api, knex);
-  await resetAnyApiTables(knex);
+  await api.use(RestApiPlugin, restApiOptions)
+  await useStoragePlugin(api, knex)
+  await resetAnyApiTables(knex)
 
   // Countries table with custom idProperty
   await api.addResource('countries', {
@@ -1544,9 +1544,9 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     tableName: `${tablePrefix}_countries`,
     idProperty: 'country_id'  // Custom ID property
-  });
-  await api.resources.countries.createKnexTable();
-  mapTable(`${tablePrefix}_countries`, 'countries');
+  })
+  await api.resources.countries.createKnexTable()
+  mapTable(`${tablePrefix}_countries`, 'countries')
 
   // Publishers table with custom idProperty
   await api.addResource('publishers', {
@@ -1556,17 +1556,17 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     relationships: {
       books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
+      reviews: {
+        type: 'hasMany',
+        target: 'reviews',
         via: 'reviewable'
       }
     },
     tableName: `${tablePrefix}_publishers`,
     idProperty: 'publisher_id'
-  });
-  await api.resources.publishers.createKnexTable();
-  mapTable(`${tablePrefix}_publishers`, 'publishers');
+  })
+  await api.resources.publishers.createKnexTable()
+  mapTable(`${tablePrefix}_publishers`, 'publishers')
 
   // Authors table with custom idProperty
   await api.addResource('authors', {
@@ -1577,17 +1577,17 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     relationships: {
       books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
+      reviews: {
+        type: 'hasMany',
+        target: 'reviews',
         via: 'reviewable'
       }
     },
     tableName: `${tablePrefix}_authors`,
     idProperty: 'author_id'
-  });
-  await api.resources.authors.createKnexTable();
-  mapTable(`${tablePrefix}_authors`, 'authors');
+  })
+  await api.resources.authors.createKnexTable()
+  mapTable(`${tablePrefix}_authors`, 'authors')
 
   // Books table with custom idProperty
   await api.addResource('books', {
@@ -1601,17 +1601,17 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     relationships: {
       authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
-      reviews: { 
-        type: 'hasMany', 
-        target: 'reviews', 
+      reviews: {
+        type: 'hasMany',
+        target: 'reviews',
         via: 'reviewable'
       }
     },
     tableName: `${tablePrefix}_books`,
     idProperty: 'book_id'
-  });
-  await api.resources.books.createKnexTable();
-  mapTable(`${tablePrefix}_books`, 'books');
+  })
+  await api.resources.books.createKnexTable()
+  mapTable(`${tablePrefix}_books`, 'books')
 
   // Book-Authors pivot table with custom idProperty
   await api.addResource('book_authors', {
@@ -1623,9 +1623,9 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     },
     tableName: `${tablePrefix}_book_authors`,
     idProperty: 'book_author_id'
-  });
-  await api.resources.book_authors.createKnexTable();
-  mapTable(`${tablePrefix}_book_authors`, 'book_authors');
+  })
+  await api.resources.book_authors.createKnexTable()
+  mapTable(`${tablePrefix}_book_authors`, 'book_authors')
 
   // Polymorphic reviews with custom idProperty
   await api.addResource('reviews', {
@@ -1650,36 +1650,36 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     relationships: {},
     tableName: `${tablePrefix}_reviews`,
     idProperty: 'review_id'
-  });
-  await api.resources.reviews.createKnexTable();
-  mapTable(`${tablePrefix}_reviews`, 'reviews');
+  })
+  await api.resources.reviews.createKnexTable()
+  mapTable(`${tablePrefix}_reviews`, 'reviews')
 
   if (storageMode.isAnyApi()) {
-    const tenant = storageMode.defaultTenant || 'default';
-    const booksDescriptor = await api.anyapi.registry.getDescriptor(tenant, 'books');
-    const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenant, 'authors');
-    const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship;
-    const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship;
+    const tenant = storageMode.defaultTenant || 'default'
+    const booksDescriptor = await api.anyapi.registry.getDescriptor(tenant, 'books')
+    const authorsDescriptor = await api.anyapi.registry.getDescriptor(tenant, 'authors')
+    const relationshipKey = booksDescriptor?.manyToMany?.authors?.relationship
+    const inverseRelationshipKey = authorsDescriptor?.manyToMany?.books?.relationship
     storageMode.registerLink(
       `${tablePrefix}_book_authors`,
       'books',
       'authors',
       relationshipKey,
-      inverseRelationshipKey,
-    );
+      inverseRelationshipKey
+    )
   }
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API configuration for multi-field cursor pagination testing
  * Uses 'cursor_' prefix for all tables to avoid conflicts
  */
-export async function createCursorPaginationApi(knex) {
+export async function createCursorPaginationApi (knex) {
   const api = new Api({
     name: 'cursor-pagination-test-api',
-  });
+  })
 
   const restApiOptions = {
     simplified: false,
@@ -1691,12 +1691,12 @@ export async function createCursorPaginationApi(knex) {
     sortableFields: ['id', 'name', 'category', 'brand', 'price', 'sku', 'created_at', 'code', 'status', 'type'],
     queryDefaultLimit: 20,
     queryMaxLimit: 100,
-   returnBasePath: 'https://api.example.com'
-  };
-  
-  await api.use(RestApiPlugin, restApiOptions);
-  await useStoragePlugin(api, knex);
-  await resetAnyApiTables(knex);
+    returnBasePath: 'https://api.example.com'
+  }
+
+  await api.use(RestApiPlugin, restApiOptions)
+  await useStoragePlugin(api, knex)
+  await resetAnyApiTables(knex)
 
   // Create products table with fields suitable for multi-field sorting
   await api.addResource('products', {
@@ -1711,8 +1711,8 @@ export async function createCursorPaginationApi(knex) {
       created_at: { type: 'dateTime', default: 'now()' }
     },
     tableName: 'cursor_products'
-  });
-  await api.resources.products.createKnexTable();
+  })
+  await api.resources.products.createKnexTable()
 
   // Create items table with custom ID property
   await api.addResource('items', {
@@ -1725,21 +1725,21 @@ export async function createCursorPaginationApi(knex) {
     },
     idProperty: 'item_id',
     tableName: 'cursor_items'
-  });
-  await api.resources.items.createKnexTable();
+  })
+  await api.resources.items.createKnexTable()
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API configuration for testing virtual fields validation
  */
-export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || 'virtual-fields-test-api';
+export async function createVirtualFieldsApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'virtual-fields-test-api'
   const api = new Api({
     name: apiName,
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
   const restApiOptions = {
     simplifiedApi: false,
@@ -1755,11 +1755,11 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
       patch: 'minimal'
     },
     ...pluginOptions['rest-api']
-  };
+  }
 
-  await api.use(RestApiPlugin, restApiOptions);
-  await useStoragePlugin(api, knex);
-  await resetAnyApiTables(knex);
+  await api.use(RestApiPlugin, restApiOptions)
+  await useStoragePlugin(api, knex)
+  await resetAnyApiTables(knex)
 
   // Add a test resource with virtual fields
   await api.addResource('users', {
@@ -1768,7 +1768,7 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
       username: { type: 'string', required: true },
       email: { type: 'string', required: true },
       age: { type: 'number' },
-      
+
       // Virtual fields with validation rules
       password: { type: 'string', virtual: true, minLength: 8 },
       passwordConfirmation: { type: 'string', virtual: true, minLength: 8 },
@@ -1778,21 +1778,21 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
       metadata: { type: 'object', virtual: true }
     },
     tableName: 'virtual_users'
-  });
-  
-  await api.resources.users.createKnexTable();
+  })
+
+  await api.resources.users.createKnexTable()
 
-  return api;
+  return api
 }
 
 /**
  * Creates an API configuration for testing searchSchema merge behavior
  */
-export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
+export async function createSearchSchemaMergeApi (knex, pluginOptions = {}) {
   const api = new Api({
     name: 'searchschema-merge-test-api',
     log: { level: process.env.LOG_LEVEL || 'info' }
-  });
+  })
 
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
@@ -1803,10 +1803,10 @@ export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
       patch: false
     },
     ...pluginOptions['rest-api']
-  });
-  
-  await useStoragePlugin(api, knex);
-  await resetAnyApiTables(knex);
+  })
+
+  await useStoragePlugin(api, knex)
+  await resetAnyApiTables(knex)
 
   // Test resource with both search:true and searchSchema
   await api.addResource('products', {
@@ -1821,7 +1821,7 @@ export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
     searchSchema: {
       // This should override the price field from search:true
       // 'between' operator requires array type for validation [min, max]
-      price: { 
+      price: {
         type: 'array',
         filterOperator: 'between'
       },
@@ -1839,8 +1839,8 @@ export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
       }
     },
     tableName: 'searchmerge_products'
-  });
-  await api.resources.products.createKnexTable();
+  })
+  await api.resources.products.createKnexTable()
 
   // Test resource with only search:true fields
   await api.addResource('users', {
@@ -1851,8 +1851,8 @@ export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
       bio: { type: 'string', search: { filterOperator: 'like' } }
     },
     tableName: 'searchmerge_users'
-  });
-  await api.resources.users.createKnexTable();
+  })
+  await api.resources.users.createKnexTable()
 
   // Test resource with only explicit searchSchema
   await api.addResource('orders', {
@@ -1866,9 +1866,9 @@ export async function createSearchSchemaMergeApi(knex, pluginOptions = {}) {
       status: { type: 'array', filterOperator: 'in' }  // 'in' operator requires array type
     },
     tableName: 'searchmerge_orders'
-  });
-  await api.resources.orders.createKnexTable();
-  mapTable('searchmerge_orders', 'orders');
+  })
+  await api.resources.orders.createKnexTable()
+  mapTable('searchmerge_orders', 'orders')
 
-  return api;
+  return api
 }