json-rest-api 1.0.10 → 1.0.13

package/tests/fixtures/api-configs.js

@@ -1,8 +1,54 @@
 import { Api } from 'hooked-api';
-import { RestApiPlugin, RestApiKnexPlugin } from '../../index.js';
+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 } = {}) {
+  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);
+  } else {
+    await api.use(RestApiKnexPlugin, { knex });
+  }
+}
+
+function mapTable(tableName, resourceName) {
+  if (storageMode.isAnyApi()) {
+    storageMode.registerTable(tableName, resourceName);
+  }
+}
+
+async function withTenantContext(tenantId, fn) {
+  if (!storageMode.isAnyApi()) {
+    return await fn();
+  }
+
+  const previousTenant = storageMode.currentTenant;
+  storageMode.setCurrentTenant(tenantId || storageMode.defaultTenant);
+  try {
+    return await fn();
+  } finally {
+    storageMode.setCurrentTenant(previousTenant);
+  }
+}
 
 /**
  * Creates a basic API configuration with Countries, Publishers, Authors, Books
@@ -10,12 +56,22 @@ import { createServer } from 'http';
 export async function createBasicApi(knex, pluginOptions = {}) {
   const apiName = pluginOptions.apiName || `basic-test-api`;
   const tablePrefix = pluginOptions.tablePrefix || 'basic';
+  if (storageMode.isAnyApi()) {
+    storageMode.clearRegistry();
+  }
   const api = new Api({
     name: apiName,
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
+  const previousTenant = storageMode.currentTenant;
+  const tenantId = storageMode.isAnyApi()
+    ? (pluginOptions.tenantId || `${tablePrefix}_tenant`)
+    : storageMode.defaultTenant;
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(tenantId);
+  }
+
   const restApiOptions = {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -34,9 +90,9 @@ export async function createBasicApi(knex, pluginOptions = {}) {
   };
 
   await api.use(RestApiPlugin, restApiOptions);
-  
-  await api.use(RestApiKnexPlugin, { knex });
-  
+  await useStoragePlugin(api, knex, { tenantId });
+  await resetAnyApiTables(knex);
+
   // Add Express plugin if requested
   if (pluginOptions.includeExpress) {
     await api.use(ExpressPlugin, {
@@ -45,6 +101,7 @@ export async function createBasicApi(knex, pluginOptions = {}) {
     });
   }
 
+  try {
   // Countries table
   await api.addResource('countries', {
     schema: {
@@ -53,12 +110,13 @@ export async function createBasicApi(knex, pluginOptions = {}) {
       code: { type: 'string', max: 2, unique: true }
     },
     relationships: {
-      publishers: { hasMany: 'publishers', foreignKey: 'country_id' },
-      books: { hasMany: 'books', foreignKey: 'country_id' }
+      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', {
@@ -68,11 +126,12 @@ export async function createBasicApi(knex, pluginOptions = {}) {
       country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
     },
     relationships: {
-      books: { hasMany: 'books', foreignKey: 'publisher_id' }
+      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', {
@@ -81,11 +140,12 @@ export async function createBasicApi(knex, pluginOptions = {}) {
       name: { type: 'string', required: true, max: 200 }
     },
     relationships: {
-      books: { hasMany: 'books', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
+      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', {
@@ -96,11 +156,12 @@ export async function createBasicApi(knex, pluginOptions = {}) {
       publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
     },
     relationships: {
-      authors: { hasMany: 'authors', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
+      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', {
@@ -112,8 +173,135 @@ export async function createBasicApi(knex, pluginOptions = {}) {
     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,
+    );
+  }
 
-  return api;
+    return api;
+  } finally {
+    if (storageMode.isAnyApi()) {
+      storageMode.setCurrentTenant(previousTenant);
+    }
+  }
+}
+
+export async function createAccessControlApi(knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'access-test-api';
+  const tablePrefix = pluginOptions.tablePrefix || 'access';
+  if (storageMode.isAnyApi()) {
+    storageMode.clearRegistry();
+  }
+
+  const api = new Api({
+    name: apiName,
+    log: { level: process.env.LOG_LEVEL || 'info' }
+  });
+
+  const previousTenant = storageMode.currentTenant;
+  const tenantId = storageMode.isAnyApi()
+    ? (pluginOptions.tenantId || `${tablePrefix}_tenant`)
+    : storageMode.defaultTenant;
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(tenantId);
+  }
+
+  await api.use(RestApiPlugin, {
+    simplifiedApi: false,
+    simplifiedTransport: false,
+    returnRecordApi: {
+      post: true,
+      put: false,
+      patch: false
+    },
+    returnRecordTransport: {
+      post: 'full',
+      put: 'no',
+      patch: 'minimal'
+    },
+    sortableFields: ['id', 'name', 'user_id']
+  });
+  await useStoragePlugin(api, knex, { tenantId });
+  await resetAnyApiTables(knex);
+
+  try {
+    await api.use(AccessPlugin, pluginOptions.access || {});
+
+    await api.addResource('users', {
+      schema: {
+        id: { type: 'id' },
+        email: { type: 'string', required: true },
+        display_name: { type: 'string', nullable: true }
+      },
+      tableName: `${tablePrefix}_users`
+    });
+    await api.resources.users.createKnexTable();
+    mapTable(`${tablePrefix}_users`, 'users');
+
+    await api.addResource('projects', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true },
+        status: { type: 'string', nullable: true },
+        user_id: { type: 'number', belongsTo: 'users', as: 'user', nullable: true }
+      },
+      relationships: {
+        user: { type: 'belongsTo', target: 'users', foreignKey: 'user_id' }
+      },
+      auth: {
+        query: ['authenticated'],
+        get: ['owns'],
+        post: ['authenticated'],
+        patch: ['owns'],
+        delete: ['owns']
+      },
+      ownership: true,
+      tableName: `${tablePrefix}_projects`
+    });
+    await api.resources.projects.createKnexTable();
+    mapTable(`${tablePrefix}_projects`, 'projects');
+
+    await api.addResource('notes', {
+      schema: {
+        id: { type: 'id' },
+        project_id: { type: 'number', belongsTo: 'projects', as: 'project', nullable: true },
+        body: { type: 'string', required: true },
+        user_id: { type: 'number', belongsTo: 'users', as: 'user', nullable: true }
+      },
+      relationships: {
+        project: { type: 'belongsTo', target: 'projects', foreignKey: 'project_id' },
+        user: { type: 'belongsTo', target: 'users', foreignKey: 'user_id' }
+      },
+      auth: {
+        query: ['authenticated'],
+        get: ['owns'],
+        post: ['authenticated'],
+        patch: ['owns'],
+        delete: ['owns']
+      },
+      ownership: true,
+      tableName: `${tablePrefix}_notes`
+    });
+    await api.resources.notes.createKnexTable();
+    mapTable(`${tablePrefix}_notes`, 'notes');
+
+    return api;
+  } finally {
+    if (storageMode.isAnyApi()) {
+      storageMode.setCurrentTenant(previousTenant);
+    }
+  }
 }
 
 /**
@@ -122,8 +310,11 @@ export async function createBasicApi(knex, pluginOptions = {}) {
 export async function createBulkOperationsApi(knex, pluginOptions = {}) {
   const { BulkOperationsPlugin } = await import('../../plugins/core/bulk-operations-plugin.js');
   
-  const api = await createBasicApi(knex, pluginOptions);
-  
+  const api = await createBasicApi(knex, {
+    ...pluginOptions,
+    tenantId: pluginOptions.tenantId || 'bulk_ops_tenant'
+  });
+
   // Add bulk operations plugin
   await api.use(BulkOperationsPlugin, {
     'bulk-operations': {
@@ -144,9 +335,10 @@ export async function createBulkOperationsApi(knex, pluginOptions = {}) {
 export async function createExtendedApi(knex) {
   const api = new Api({
     name: 'extended-test-api',
-    version: '1.0.0'
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'extended_tenant' : storageMode.defaultTenant;
+
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -162,11 +354,12 @@ export async function createExtendedApi(knex) {
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'price', 'language', 'population', 'name', 'code']
   });
-  
-  await api.use(RestApiKnexPlugin, { knex });
+  await withTenantContext(tenantId, async () => {
+    await useStoragePlugin(api, knex, { tenantId });
+    await resetAnyApiTables(knex);
 
-  // Countries with extended fields
-  await api.addResource('countries', {
+    // Countries with extended fields
+    await api.addResource('countries', {
     schema: {
       id: { type: 'id' },
       name: { type: 'string', required: true, max: 100 },
@@ -176,13 +369,14 @@ export async function createExtendedApi(knex) {
       currency: { type: 'string', max: 3 }
     },
     relationships: {
-      publishers: { hasMany: 'publishers', foreignKey: 'country_id' },
-      books: { hasMany: 'books', foreignKey: 'country_id' },
-      authors: { hasMany: 'authors', foreignKey: 'nationality_id' }
+      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', {
@@ -195,15 +389,17 @@ export async function createExtendedApi(knex) {
       active: { type: 'boolean', default: true }
     },
     relationships: {
-      books: { hasMany: 'books', foreignKey: 'publisher_id' },
+      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
       reviews: { 
-        hasMany: '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', {
@@ -215,15 +411,17 @@ export async function createExtendedApi(knex) {
       nationality_id: { type: 'number', belongsTo: 'countries', as: 'nationality' }
     },
     relationships: {
-      books: { hasMany: 'books', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
+      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
       reviews: { 
-        hasMany: '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', {
@@ -239,15 +437,17 @@ export async function createExtendedApi(knex) {
       publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
     },
     relationships: {
-      authors: { hasMany: 'authors', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
+      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
       reviews: { 
-        hasMany: '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', {
@@ -261,6 +461,14 @@ export async function createExtendedApi(knex) {
     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', {
@@ -287,7 +495,8 @@ export async function createExtendedApi(knex) {
     tableName: 'ext_reviews'
   });
   await api.resources.reviews.createKnexTable();
-
+  mapTable('ext_reviews', 'reviews');
+  });
 
   return api;
 }
@@ -299,9 +508,10 @@ export async function createExtendedApi(knex) {
 export async function createLimitedDepthApi(knex) {
   const api = new Api({
     name: 'limited-depth-api',
-    version: '1.0.0'
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'limited_depth_tenant' : storageMode.defaultTenant;
+
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -318,23 +528,24 @@ 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 api.use(RestApiKnexPlugin, { knex });
+  await withTenantContext(tenantId, async () => {
+    await useStoragePlugin(api, knex, { tenantId });
 
-  // Use different table names with 'limited_' prefix to avoid conflicts
-  await api.addResource('countries', {
+    // 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: { hasMany: 'publishers', foreignKey: 'country_id' },
-      books: { hasMany: 'books', foreignKey: 'country_id' }
+      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: {
@@ -343,12 +554,13 @@ export async function createLimitedDepthApi(knex) {
       country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
     },
     relationships: {
-      books: { hasMany: 'books', foreignKey: 'publisher_id' },
-      authors: { hasMany: 'authors', foreignKey: 'publisher_id' }
+      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: {
@@ -357,7 +569,7 @@ export async function createLimitedDepthApi(knex) {
       publisher_id: { type: 'number', nullable: true, belongsTo: 'publishers', as: 'publisher' }
     },
     relationships: {
-      books: { hasMany: 'books', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
+      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' }
     },
     tableName: 'limited_authors'
   });
@@ -371,7 +583,7 @@ export async function createLimitedDepthApi(knex) {
       publisher_id: { type: 'number', belongsTo: 'publishers', as: 'publisher', search: true }
     },
     relationships: {
-      authors: { hasMany: 'authors', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
+      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' }
     },
     tableName: 'limited_books'
   });
@@ -386,6 +598,15 @@ export async function createLimitedDepthApi(knex) {
     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;
 }
@@ -396,9 +617,10 @@ export async function createLimitedDepthApi(knex) {
 export async function createPaginationApi(knex, options = {}) {
   const api = new Api({
     name: 'pagination-test-api',
-    version: '1.0.0'
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'pagination_tenant' : storageMode.defaultTenant;
+
   const restApiOptions = {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -413,27 +635,28 @@ export async function createPaginationApi(knex, options = {}) {
       patch: 'minimal'
     },
     sortableFields: ['id', 'title', 'country_id', 'publisher_id', 'name', 'code'],
-    ...options  // Allow overriding options like publicBaseUrl, enablePaginationCounts
+    ...options  // Allow overriding options likereturnBasePath, enablePaginationCounts
   };
 
   await api.use(RestApiPlugin, restApiOptions);
-  
-  await api.use(RestApiKnexPlugin, { knex });
+  await withTenantContext(tenantId, async () => {
+    await useStoragePlugin(api, knex, { tenantId });
 
-  // Countries table
-  await api.addResource('countries', {
+    // 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: { hasMany: 'publishers', foreignKey: 'country_id' },
-      books: { hasMany: 'books', foreignKey: 'country_id' }
+      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', {
@@ -443,11 +666,12 @@ export async function createPaginationApi(knex, options = {}) {
       country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
     },
     relationships: {
-      books: { hasMany: 'books', foreignKey: 'publisher_id' }
+      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', {
@@ -460,6 +684,8 @@ export async function createPaginationApi(knex, options = {}) {
     tableName: 'pagination_books'
   });
   await api.resources.books.createKnexTable();
+  mapTable('pagination_books', 'books');
+  });
 
   return api;
 }
@@ -469,24 +695,57 @@ export async function createPaginationApi(knex, options = {}) {
  */
 export async function createWebSocketApi(knex, pluginOptions = {}) {
   const { SocketIOPlugin } = await import('../../plugins/core/socketio-plugin.js');
-  const { JwtAuthPlugin } = await import('../../plugins/core/jwt-auth-plugin.js');
-  
+  const { jwtVerify } = await import('jose');
+
   const api = await createBasicApi(knex, {
     ...pluginOptions,
+    tenantId: pluginOptions.tenantId || 'socketio_tenant',
     includeExpress: true,
     express: {
       port: 0 // Let OS assign a port
     }
   });
-  
-  // Add JWT auth plugin (required by SocketIO plugin)
-  await api.use(JwtAuthPlugin, {
-    secret: 'test-secret-key',
-    expiresIn: '1h'
-  });
-  
-  // Add SocketIO plugin
-  await api.use(SocketIOPlugin, pluginOptions['socketio'] || {});
+
+  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;
+      if (!token) {
+        throw new Error('Authentication required');
+      }
+
+      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] : [];
+
+      const authContext = {
+        userId: payload.userId || payload.sub,
+        roles,
+        token: payload
+      };
+
+      if (!authContext.userId) {
+        throw new Error('Token is missing required user identifier');
+      }
+
+      return authContext;
+    };
+  }
+
+  if (authOptions.requireAuth === undefined) {
+    authOptions.requireAuth = true;
+  }
+
+  socketioOptions.auth = authOptions;
+
+  await api.use(SocketIOPlugin, socketioOptions);
   
   // Create and start Express server
   const app = express();
@@ -517,84 +776,91 @@ export async function createWebSocketApi(knex, pluginOptions = {}) {
 export async function createComputedFieldsApi(knex, pluginOptions = {}) {
   const api = new Api({
     name: 'computed-fields-test-api',
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'computed_fields_tenant' : storageMode.defaultTenant;
+
   await api.use(RestApiPlugin, {
     simplifiedApi: true,
     simplifiedTransport: true
   });
-  
-  await api.use(RestApiKnexPlugin, { knex });
 
-  // Products resource with computed fields
-  await api.addResource('products', {
-    schema: {
-      id: { type: 'id' },
-      name: { type: 'string', required: true, max: 255 },
-      price: { type: 'number', required: true, min: 0 },
-      cost: { type: 'number', required: true, min: 0, normallyHidden: true },
-      internal_notes: { type: 'string', normallyHidden: true },
-      profit_margin: {
-        type: 'number',
-        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));
+  await withTenantContext(tenantId, async () => {
+    await useStoragePlugin(api, knex, { tenantId });
+    await resetAnyApiTables(knex);
+
+    // Products resource with computed fields
+    await api.addResource('products', {
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true, max: 255 },
+        price: { type: 'number', required: true, min: 0 },
+        cost: { type: 'number', required: true, min: 0, normallyHidden: true },
+        internal_notes: { type: 'string', normallyHidden: true },
+        profit_margin: {
+          type: 'number',
+          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));
+          }
+        },
+        profit_amount: {
+          type: 'number',
+          computed: true,
+          dependencies: ['price', 'cost'],
+          compute: ({ attributes }) => {
+            return Number((attributes.price - attributes.cost).toFixed(2));
+          }
         }
       },
-      profit_amount: {
-        type: 'number',
-        computed: true,
-        dependencies: ['price', 'cost'],
-        compute: ({ attributes }) => {
-          return Number((attributes.price - attributes.cost).toFixed(2));
-        }
-      }
-    },
-    relationships: {
-      reviews: { hasMany: 'reviews', foreignKey: 'product_id' }
-    },
-    tableName: 'test_products'
-  });
-  await api.resources.products.createKnexTable();
-
-  // Reviews resource with computed fields
-  await api.addResource('reviews', {
-    schema: {
-      id: { type: 'id' },
-      product_id: { type: 'number', required: true, belongsTo: 'products', as: 'product' },
-      reviewer_name: { type: 'string', required: true },
-      rating: { type: 'number', required: true, min: 1, max: 5 },
-      comment: { type: 'string', max: 1000 },
-      helpful_votes: { type: 'number', default: 0 },
-      total_votes: { type: 'number', default: 0 },
-      spam_score: { type: 'number', default: 0, normallyHidden: true },
-      helpfulness_score: {
-        type: 'number',
-        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));
-        }
+      relationships: {
+        reviews: { type: 'hasMany', target: 'reviews', foreignKey: 'product_id' }
       },
-      is_helpful: {
-        type: 'boolean',
-        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;
+      tableName: 'test_products'
+    });
+    await api.resources.products.createKnexTable();
+    mapTable('searchmerge_products', 'products');
+    mapTable('test_products', 'products');
+
+    // Reviews resource with computed fields
+    await api.addResource('reviews', {
+      schema: {
+        id: { type: 'id' },
+        product_id: { type: 'number', required: true, belongsTo: 'products', as: 'product' },
+        reviewer_name: { type: 'string', required: true },
+        rating: { type: 'number', required: true, min: 1, max: 5 },
+        comment: { type: 'string', max: 1000 },
+        helpful_votes: { type: 'number', default: 0 },
+        total_votes: { type: 'number', default: 0 },
+        spam_score: { type: 'number', default: 0, normallyHidden: true },
+        helpfulness_score: {
+          type: 'number',
+          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));
+          }
+        },
+        is_helpful: {
+          type: 'boolean',
+          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;
+          }
         }
-      }
-    },
-    tableName: 'test_reviews'
+      },
+      tableName: 'test_reviews'
+    });
+    await api.resources.reviews.createKnexTable();
+    mapTable('test_reviews', 'reviews');
   });
-  await api.resources.reviews.createKnexTable();
 
   return api;
 }
@@ -605,16 +871,22 @@ export async function createComputedFieldsApi(knex, pluginOptions = {}) {
 export async function createFieldGettersApi(knex, pluginOptions = {}) {
   const api = new Api({
     name: 'field-getters-test-api',
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'field_getters_tenant' : storageMode.defaultTenant;
+  const previousTenant = storageMode.currentTenant;
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(tenantId);
+  }
+
   await api.use(RestApiPlugin, {
     simplifiedApi: true,
     simplifiedTransport: true
   });
   
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex, { tenantId });
+  await resetAnyApiTables(knex);
 
   // Users resource with basic getters
   await api.addResource('users', {
@@ -667,6 +939,8 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
     tableName: 'getter_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', {
@@ -703,11 +977,12 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
       }
     },
     relationships: {
-      reviews: { hasMany: 'reviews', foreignKey: 'product_id' }
+      reviews: { type: 'hasMany', target: 'reviews', foreignKey: 'product_id' }
     },
     tableName: 'getter_products'
   });
   await api.resources.products.createKnexTable();
+  mapTable('getter_products', 'products');
 
   // Reviews resource with getters
   await api.addResource('reviews', {
@@ -723,6 +998,7 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
     tableName: 'getter_reviews'
   });
   await api.resources.reviews.createKnexTable();
+  mapTable('getter_reviews', 'reviews');
 
   // Resource with getter dependencies
   await api.addResource('formatted_data', {
@@ -756,6 +1032,7 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
     tableName: 'getter_formatted'
   });
   await api.resources.formatted_data.createKnexTable();
+  mapTable('getter_formatted', 'formatted_data');
 
   // Async getters example
   await api.addResource('encrypted_data', {
@@ -785,6 +1062,11 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
     tableName: 'getter_encrypted'
   });
   await api.resources.encrypted_data.createKnexTable();
+  mapTable('getter_encrypted', 'encrypted_data');
+
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(previousTenant);
+  }
 
   return api;
 }
@@ -795,10 +1077,15 @@ export async function createFieldGettersApi(knex, pluginOptions = {}) {
 export async function createFieldSettersApi(knex, pluginOptions = {}) {
   const api = new Api({
     name: 'field-setters-test-api',
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'field_setters_tenant' : storageMode.defaultTenant;
+  const previousTenant = storageMode.currentTenant;
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(tenantId);
+  }
+
   await api.use(RestApiPlugin, {
     simplifiedApi: true,
     simplifiedTransport: true,
@@ -809,7 +1096,8 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
     }
   });
   
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex, { tenantId });
+  await resetAnyApiTables(knex);
 
   // Users resource with basic setters
   await api.addResource('users', {
@@ -993,6 +1281,10 @@ export async function createFieldSettersApi(knex, pluginOptions = {}) {
   });
   await api.resources.validated_data.createKnexTable();
 
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(previousTenant);
+  }
+
   return api;
 }
 
@@ -1001,9 +1293,14 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
   
   const api = new Api({
     name: 'multihome-test-api',
-    version: '1.0.0'
   });
 
+  const tenantId = storageMode.isAnyApi() ? 'multihome_tenant' : storageMode.defaultTenant;
+  const previousTenant = storageMode.currentTenant;
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(tenantId);
+  }
+
   await api.use(RestApiPlugin, {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -1020,7 +1317,8 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
     sortableFields: ['id', 'title', 'name', 'tenant_id']
   });
   
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex, { tenantId });
+  await resetAnyApiTables(knex);
   
   // Add Express plugin if requested for transport testing
   if (pluginOptions.includeExpress) {
@@ -1049,11 +1347,12 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
       tenant_id: { type: 'string', required: true }
     },
     relationships: {
-      tasks: { hasMany: 'tasks', foreignKey: 'project_id' }
+      tasks: { type: 'hasMany', target: 'tasks', foreignKey: 'project_id' }
     },
     tableName: 'multihome_projects'
   });
   await api.resources.projects.createKnexTable();
+  mapTable('multihome_projects', 'projects');
 
   await api.addResource('tasks', {
     schema: {
@@ -1066,6 +1365,7 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
     tableName: 'multihome_tasks'
   });
   await api.resources.tasks.createKnexTable();
+  mapTable('multihome_tasks', 'tasks');
 
   await api.addResource('users', {
     schema: {
@@ -1078,6 +1378,7 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
     tableName: 'multihome_users'
   });
   await api.resources.users.createKnexTable();
+  mapTable('multihome_users', 'users');
 
   // Global resource (excluded from multihome)
   await api.addResource('system_settings', {
@@ -1089,6 +1390,11 @@ export async function createMultiHomeApi(knex, pluginOptions = {}) {
     tableName: 'multihome_system_settings'
   });
   await api.resources.system_settings.createKnexTable();
+  mapTable('multihome_system_settings', 'system_settings');
+
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(previousTenant);
+  }
 
   return api;
 }
@@ -1101,7 +1407,6 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
   const tablePrefix = pluginOptions.tablePrefix || 'positioning';
   const api = new Api({
     name: apiName,
-    version: '1.0.0'
   });
 
   const restApiOptions = {
@@ -1122,7 +1427,8 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
   };
 
   await api.use(RestApiPlugin, restApiOptions);
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex);
+  await resetAnyApiTables(knex);
 
   // Categories (for grouping tasks)
   await api.addResource('categories', {
@@ -1133,6 +1439,7 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
     tableName: `${tablePrefix}_categories`
   });
   await api.resources.categories.createKnexTable();
+  mapTable(`${tablePrefix}_categories`, 'categories');
 
   // Tasks (main positioning test resource)
   await api.addResource('tasks', {
@@ -1151,6 +1458,7 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
     tableName: `${tablePrefix}_tasks`
   });
   await api.resources.tasks.createKnexTable();
+  mapTable(`${tablePrefix}_tasks`, 'tasks');
 
   // Projects (for multi-filter testing)
   await api.addResource('projects', {
@@ -1161,6 +1469,7 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
     tableName: `${tablePrefix}_projects`
   });
   await api.resources.projects.createKnexTable();
+  mapTable(`${tablePrefix}_projects`, 'projects');
 
   // Items (flexible resource for various positioning tests)
   await api.addResource('items', {
@@ -1180,6 +1489,7 @@ export async function createPositioningApi(knex, pluginOptions = {}) {
     tableName: `${tablePrefix}_items`
   });
   await api.resources.items.createKnexTable();
+  mapTable(`${tablePrefix}_items`, 'items');
 
   return api;
 }
@@ -1193,10 +1503,13 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
   const tablePrefix = pluginOptions.tablePrefix || 'custom_id';
   const api = new Api({
     name: apiName,
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
+  if (storageMode.isAnyApi()) {
+    storageMode.clearRegistry();
+  }
+
   const restApiOptions = {
     simplifiedApi: false,
     simplifiedTransport: false,
@@ -1215,7 +1528,8 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
   };
 
   await api.use(RestApiPlugin, restApiOptions);
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex);
+  await resetAnyApiTables(knex);
 
   // Countries table with custom idProperty
   await api.addResource('countries', {
@@ -1225,13 +1539,14 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
       code: { type: 'string', max: 2, unique: true }
     },
     relationships: {
-      publishers: { hasMany: 'publishers', foreignKey: 'country_id' },
-      books: { hasMany: 'books', foreignKey: 'country_id' }
+      publishers: { type: 'hasMany', target: 'publishers', foreignKey: 'country_id' },
+      books: { type: 'hasMany', target: 'books', foreignKey: 'country_id' }
     },
     tableName: `${tablePrefix}_countries`,
     idProperty: 'country_id'  // Custom ID property
   });
   await api.resources.countries.createKnexTable();
+  mapTable(`${tablePrefix}_countries`, 'countries');
 
   // Publishers table with custom idProperty
   await api.addResource('publishers', {
@@ -1240,9 +1555,10 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
       country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
     },
     relationships: {
-      books: { hasMany: 'books', foreignKey: 'publisher_id' },
+      books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
       reviews: { 
-        hasMany: 'reviews', 
+        type: 'hasMany', 
+        target: 'reviews', 
         via: 'reviewable'
       }
     },
@@ -1250,6 +1566,7 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     idProperty: 'publisher_id'
   });
   await api.resources.publishers.createKnexTable();
+  mapTable(`${tablePrefix}_publishers`, 'publishers');
 
   // Authors table with custom idProperty
   await api.addResource('authors', {
@@ -1259,9 +1576,10 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
       country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
     },
     relationships: {
-      books: { hasMany: 'books', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
+      books: { type: 'manyToMany', through: 'book_authors', foreignKey: 'author_id', otherKey: 'book_id' },
       reviews: { 
-        hasMany: 'reviews', 
+        type: 'hasMany', 
+        target: 'reviews', 
         via: 'reviewable'
       }
     },
@@ -1269,6 +1587,7 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     idProperty: 'author_id'
   });
   await api.resources.authors.createKnexTable();
+  mapTable(`${tablePrefix}_authors`, 'authors');
 
   // Books table with custom idProperty
   await api.addResource('books', {
@@ -1281,9 +1600,10 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
       publisher_id: { type: 'number', nullable: true, belongsTo: 'publishers', as: 'publisher', search: true }
     },
     relationships: {
-      authors: { hasMany: 'authors', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
+      authors: { type: 'manyToMany', through: 'book_authors', foreignKey: 'book_id', otherKey: 'author_id' },
       reviews: { 
-        hasMany: 'reviews', 
+        type: 'hasMany', 
+        target: 'reviews', 
         via: 'reviewable'
       }
     },
@@ -1291,6 +1611,7 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     idProperty: 'book_id'
   });
   await api.resources.books.createKnexTable();
+  mapTable(`${tablePrefix}_books`, 'books');
 
   // Book-Authors pivot table with custom idProperty
   await api.addResource('book_authors', {
@@ -1304,6 +1625,7 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     idProperty: 'book_author_id'
   });
   await api.resources.book_authors.createKnexTable();
+  mapTable(`${tablePrefix}_book_authors`, 'book_authors');
 
   // Polymorphic reviews with custom idProperty
   await api.addResource('reviews', {
@@ -1330,6 +1652,22 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
     idProperty: 'review_id'
   });
   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;
+    storageMode.registerLink(
+      `${tablePrefix}_book_authors`,
+      'books',
+      'authors',
+      relationshipKey,
+      inverseRelationshipKey,
+    );
+  }
 
   return api;
 }
@@ -1341,7 +1679,6 @@ export async function createCustomIdPropertyApi(knex, pluginOptions = {}) {
 export async function createCursorPaginationApi(knex) {
   const api = new Api({
     name: 'cursor-pagination-test-api',
-    version: '1.0.0'
   });
 
   const restApiOptions = {
@@ -1354,11 +1691,12 @@ export async function createCursorPaginationApi(knex) {
     sortableFields: ['id', 'name', 'category', 'brand', 'price', 'sku', 'created_at', 'code', 'status', 'type'],
     queryDefaultLimit: 20,
     queryMaxLimit: 100,
-    publicBaseUrl: 'https://api.example.com/v1'
+   returnBasePath: 'https://api.example.com'
   };
   
   await api.use(RestApiPlugin, restApiOptions);
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex);
+  await resetAnyApiTables(knex);
 
   // Create products table with fields suitable for multi-field sorting
   await api.addResource('products', {
@@ -1400,7 +1738,6 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
   const apiName = pluginOptions.apiName || 'virtual-fields-test-api';
   const api = new Api({
     name: apiName,
-    version: '1.0.0',
     log: { level: process.env.LOG_LEVEL || 'info' }
   });
 
@@ -1421,7 +1758,8 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
   };
 
   await api.use(RestApiPlugin, restApiOptions);
-  await api.use(RestApiKnexPlugin, { knex });
+  await useStoragePlugin(api, knex);
+  await resetAnyApiTables(knex);
 
   // Add a test resource with virtual fields
   await api.addResource('users', {
@@ -1445,4 +1783,92 @@ export async function createVirtualFieldsApi(knex, pluginOptions = {}) {
   await api.resources.users.createKnexTable();
 
   return api;
-}
+}
+
+/**
+ * Creates an API configuration for testing searchSchema merge behavior
+ */
+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,
+    simplifiedTransport: false,
+    returnRecordApi: {
+      post: true,
+      put: false,
+      patch: false
+    },
+    ...pluginOptions['rest-api']
+  });
+  
+  await useStoragePlugin(api, knex);
+  await resetAnyApiTables(knex);
+
+  // Test resource with both search:true and searchSchema
+  await api.addResource('products', {
+    schema: {
+      name: { type: 'string', search: true },        // Should be added to searchSchema
+      description: { type: 'string', search: true }, // Should be added to searchSchema
+      price: { type: 'number', search: true },       // Should be overridden by searchSchema
+      category: { type: 'number' },               // Not searchable
+      sku: { type: 'string', search: true },         // Should be added to searchSchema
+      status: { type: 'string' }                     // Not searchable but added via searchSchema
+    },
+    searchSchema: {
+      // This should override the price field from search:true
+      // 'between' operator requires array type for validation [min, max]
+      price: { 
+        type: 'array',
+        filterOperator: 'between'
+      },
+      // This is a virtual field
+      category_name: {
+        type: 'string',
+        actualField: 'category.name',
+        filterOperator: 'like'
+      },
+      // This is an explicit field not marked with search:true
+      // 'in' operator requires array type for validation
+      status: {
+        type: 'array',
+        filterOperator: 'in'
+      }
+    },
+    tableName: 'searchmerge_products'
+  });
+  await api.resources.products.createKnexTable();
+
+  // Test resource with only search:true fields
+  await api.addResource('users', {
+    schema: {
+      username: { type: 'string', search: true },
+      email: { type: 'string', search: true },
+      age: { type: 'number' },
+      bio: { type: 'string', search: { filterOperator: 'like' } }
+    },
+    tableName: 'searchmerge_users'
+  });
+  await api.resources.users.createKnexTable();
+
+  // Test resource with only explicit searchSchema
+  await api.addResource('orders', {
+    schema: {
+      order_number: { type: 'string' },
+      total: { type: 'number' },
+      status: { type: 'string' }
+    },
+    searchSchema: {
+      order_number: { type: 'string', filterOperator: '=' },
+      status: { type: 'array', filterOperator: 'in' }  // 'in' operator requires array type
+    },
+    tableName: 'searchmerge_orders'
+  });
+  await api.resources.orders.createKnexTable();
+  mapTable('searchmerge_orders', 'orders');
+
+  return api;
+}