json-rest-api 1.0.22 → 1.0.24

package/tests/fixtures/api-configs.js

@@ -1,6 +1,5 @@
 import { Api } from 'hooked-api'
-import { RestApiPlugin, RestApiKnexPlugin, RestApiAnyapiKnexPlugin } from '../../index.js'
-import { AccessPlugin } from '../../plugins/core/rest-api-access.js'
+import { RestApiPlugin, RestApiKnexPlugin, RestApiAnyapiKnexPlugin, QueryProjectionsPlugin } from '../../index.js'
 import { ExpressPlugin } from '../../plugins/core/connectors/express-plugin.js'
 import express from 'express'
 import { createServer } from 'http'
@@ -126,7 +125,8 @@ export async function createBasicApi (knex, pluginOptions = {}) {
         country_id: { type: 'number', nullable: true, belongsTo: 'countries', as: 'country' }
       },
       relationships: {
-        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' }
+        books: { type: 'hasMany', target: 'books', foreignKey: 'publisher_id' },
+        authors: { type: 'hasMany', target: 'authors', foreignKey: 'publisher_id' }
       },
       tableName: `${tablePrefix}_publishers`
     })
@@ -137,7 +137,8 @@ export async function createBasicApi (knex, pluginOptions = {}) {
     await api.addResource('authors', {
       schema: {
         id: { type: 'id' },
-        name: { type: 'string', required: true, max: 200 }
+        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' }
@@ -197,9 +198,12 @@ export async function createBasicApi (knex, pluginOptions = {}) {
   }
 }
 
-export async function createAccessControlApi (knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || 'access-test-api'
-  const tablePrefix = pluginOptions.tablePrefix || 'access'
+/**
+ * Creates a small API focused on resource ID normalization behavior.
+ */
+export async function createIdNormalizationApi (knex, pluginOptions = {}) {
+  const apiName = pluginOptions.apiName || 'id-normalization-test-api'
+  const tablePrefix = pluginOptions.tablePrefix || 'id_norm'
   if (storageMode.isAnyApi()) {
     storageMode.clearRegistry()
   }
@@ -230,71 +234,94 @@ export async function createAccessControlApi (knex, pluginOptions = {}) {
       put: 'no',
       patch: 'minimal'
     },
-    sortableFields: ['id', 'name', 'user_id']
+    ...(pluginOptions['rest-api'] || {})
   })
-  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 withTenantContext(tenantId, async () => {
+      await useStoragePlugin(api, knex, { tenantId })
+      await resetAnyApiTables(knex)
+
+      await api.addResource('countries', {
+        schema: {
+          id: { type: 'string', required: true },
+          name: { type: 'string', required: true, max: 100 }
+        },
+        tableName: `${tablePrefix}_countries`,
+        ...(pluginOptions.countryResourceOptions || {})
+      })
+      await knex.schema.dropTableIfExists(`${tablePrefix}_countries`)
+      await knex.schema.createTable(`${tablePrefix}_countries`, (table) => {
+        table.string('id').primary()
+        table.string('name').notNullable()
+      })
+      mapTable(`${tablePrefix}_countries`, 'countries')
+
+      await api.addResource('publishers', {
+        schema: {
+          id: { type: 'string', required: true },
+          name: { type: 'string', required: true, max: 100 },
+          country_id: { type: 'string', nullable: true, belongsTo: 'countries', as: 'country' }
+        },
+        relationships: {
+          tags: { type: 'manyToMany', through: 'publisher_tags', foreignKey: 'publisher_id', otherKey: 'tag_id' }
+        },
+        tableName: `${tablePrefix}_publishers`,
+        ...(pluginOptions.publisherResourceOptions || {})
+      })
+      await knex.schema.dropTableIfExists(`${tablePrefix}_publishers`)
+      await knex.schema.createTable(`${tablePrefix}_publishers`, (table) => {
+        table.string('id').primary()
+        table.string('name').notNullable()
+        table.string('country_id').nullable()
+      })
+      mapTable(`${tablePrefix}_publishers`, 'publishers')
+
+      await api.addResource('tags', {
+        schema: {
+          id: { type: 'string', required: true },
+          name: { type: 'string', required: true, max: 100 }
+        },
+        tableName: `${tablePrefix}_tags`,
+        ...(pluginOptions.tagResourceOptions || {})
+      })
+      await knex.schema.dropTableIfExists(`${tablePrefix}_tags`)
+      await knex.schema.createTable(`${tablePrefix}_tags`, (table) => {
+        table.string('id').primary()
+        table.string('name').notNullable()
+      })
+      mapTable(`${tablePrefix}_tags`, 'tags')
+
+      await api.addResource('publisher_tags', {
+        schema: {
+          id: { type: 'id' },
+          publisher_id: { type: 'string', required: true, belongsTo: 'publishers', as: 'publisher' },
+          tag_id: { type: 'string', required: true, belongsTo: 'tags', as: 'tag' }
+        },
+        tableName: `${tablePrefix}_publisher_tags`
+      })
+      await knex.schema.dropTableIfExists(`${tablePrefix}_publisher_tags`)
+      await knex.schema.createTable(`${tablePrefix}_publisher_tags`, (table) => {
+        table.increments('id').primary()
+        table.string('publisher_id').notNullable()
+        table.string('tag_id').notNullable()
+      })
+      mapTable(`${tablePrefix}_publisher_tags`, 'publisher_tags')
+      if (storageMode.isAnyApi()) {
+        const descriptorTenant = api.anyapi?.tenantId || tenantId
+        const publishersDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'publishers')
+        const tagsDescriptor = await api.anyapi.registry.getDescriptor(descriptorTenant, 'tags')
+        const relationshipKey = publishersDescriptor?.manyToMany?.tags?.relationship
+        const inverseRelationshipKey = tagsDescriptor?.manyToMany?.publishers?.relationship
+        storageMode.registerLink(
+          `${tablePrefix}_publisher_tags`,
+          'publishers',
+          'tags',
+          relationshipKey,
+          inverseRelationshipKey
+        )
+      }
     })
-    await api.resources.notes.createKnexTable()
-    mapTable(`${tablePrefix}_notes`, 'notes')
 
     return api
   } finally {
@@ -1071,6 +1098,92 @@ export async function createFieldGettersApi (knex, pluginOptions = {}) {
   return api
 }
 
+export async function createProjectedFieldsApi (knex, pluginOptions = {}) {
+  const api = new Api({
+    name: 'projected-fields-test-api',
+    log: { level: process.env.LOG_LEVEL || 'info' }
+  })
+
+  const tenantId = storageMode.isAnyApi() ? 'projected_fields_tenant' : storageMode.defaultTenant
+  const previousTenant = storageMode.currentTenant
+  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', 'first_name', 'last_name'],
+    ...pluginOptions['rest-api']
+  })
+  await api.use(QueryProjectionsPlugin)
+
+  await useStoragePlugin(api, knex, { tenantId })
+  await resetAnyApiTables(knex)
+
+  await api.addResource('authors', {
+    schema: {
+      id: { type: 'id' },
+      first_name: { type: 'string', required: true, max: 100 },
+      last_name: { type: 'string', required: true, max: 100 }
+    },
+    queryFields: {
+      full_name: {
+        type: 'string',
+        sortable: true,
+        select: ({ knex, column }) => knex.raw(
+          "trim(coalesce(??, '') || ' ' || coalesce(??, ''))",
+          [column('first_name'), column('last_name')]
+        )
+      },
+      sort_name: {
+        type: 'string',
+        sortable: true,
+        normallyHidden: true,
+        select: ({ knex, column }) => knex.raw(
+          "trim(coalesce(??, '') || ' ' || coalesce(??, ''))",
+          [column('first_name'), column('last_name')]
+        )
+      }
+    },
+    relationships: {
+      books: { type: 'hasMany', target: 'books', foreignKey: 'author_id' }
+    },
+    sortableFields: ['id', 'first_name', 'last_name'],
+    defaultSort: ['full_name'],
+    tableName: 'projected_authors'
+  })
+  await api.resources.authors.createKnexTable()
+  mapTable('projected_authors', 'authors')
+
+  await api.addResource('books', {
+    schema: {
+      id: { type: 'id' },
+      title: { type: 'string', required: true, max: 200 },
+      author_id: { type: 'id', required: true, belongsTo: 'authors', as: 'author' }
+    },
+    tableName: 'projected_books'
+  })
+  await api.resources.books.createKnexTable()
+  mapTable('projected_books', 'books')
+
+  if (storageMode.isAnyApi()) {
+    storageMode.setCurrentTenant(previousTenant)
+  }
+
+  return api
+}
+
 /**
  * Creates an API with field setters for testing
  */
@@ -1288,14 +1401,14 @@ export async function createFieldSettersApi (knex, pluginOptions = {}) {
   return api
 }
 
-export async function createMultiHomeApi (knex, pluginOptions = {}) {
-  const { MultiHomePlugin } = await import('../../plugins/core/rest-api-multihome-plugin.js')
+export async function createAutoFilterApi (knex, pluginOptions = {}) {
+  const { AutoFilterPlugin } = await import('../../plugins/core/rest-api-autofilter-plugin.js')
 
   const api = new Api({
-    name: 'multihome-test-api',
+    name: 'autofilter-test-api',
   })
 
-  const tenantId = storageMode.isAnyApi() ? 'multihome_tenant' : storageMode.defaultTenant
+  const tenantId = storageMode.isAnyApi() ? 'autofilter_tenant' : storageMode.defaultTenant
   const previousTenant = storageMode.currentTenant
   if (storageMode.isAnyApi()) {
     storageMode.setCurrentTenant(tenantId)
@@ -1314,7 +1427,7 @@ export async function createMultiHomeApi (knex, pluginOptions = {}) {
       put: 'no',
       patch: 'minimal'
     },
-    sortableFields: ['id', 'title', 'name', 'tenant_id']
+    sortableFields: ['id', 'title', 'name', 'workspace_id', 'user_id']
   })
 
   await useStoragePlugin(api, knex, { tenantId })
@@ -1325,34 +1438,77 @@ export async function createMultiHomeApi (knex, pluginOptions = {}) {
     await api.use(ExpressPlugin, pluginOptions.express || {})
   }
 
-  // Add MultiHome plugin with configuration
-  await api.use(MultiHomePlugin, {
-    field: pluginOptions.field || 'tenant_id',
-    excludeResources: pluginOptions.excludeResources || ['system_settings'],
-    requireAuth: pluginOptions.requireAuth !== undefined ? pluginOptions.requireAuth : true,
-    allowMissing: pluginOptions.allowMissing || false,
-    extractor: pluginOptions.extractor || ((request) => {
-      // Default to header extraction for tests
-      return request.headers?.['x-tenant-id'] || null
-    })
+  const autofilterOptions = pluginOptions.autofilter || {}
+  const workspaceField = pluginOptions.workspaceField || 'workspace_id'
+  const userField = pluginOptions.userField || 'user_id'
+
+  await api.use(AutoFilterPlugin, {
+    ...autofilterOptions,
+    resolvers: {
+      workspace: ({ context }) => context.scopeValues?.workspaceId,
+      user: ({ context }) => context.scopeValues?.userId,
+      currentProject: ({ context }) => context.scopeValues?.projectId ?? null,
+      ...(autofilterOptions.resolvers || {})
+    },
+    presets: {
+      public: { filters: [] },
+      workspace: {
+        filters: [{ field: workspaceField, resolver: 'workspace' }]
+      },
+      user: {
+        filters: [{ field: userField, resolver: 'user' }]
+      },
+      workspace_user: {
+        filters: [
+          { field: workspaceField, resolver: 'workspace' },
+          { field: userField, resolver: 'user' }
+        ]
+      },
+      ...(autofilterOptions.presets || {})
+    }
+  })
+
+  await api.addResource('workspace_reports', {
+    schema: {
+      id: { type: 'id' },
+      title: { type: 'string', required: true, max: 200 },
+      workspace_id: { type: 'string', required: true }
+    },
+    autofilter: 'workspace',
+    tableName: 'autofilter_workspace_reports'
   })
+  await api.resources.workspace_reports.createKnexTable()
+  mapTable('autofilter_workspace_reports', 'workspace_reports')
+
+  await api.addResource('user_notes', {
+    schema: {
+      id: { type: 'id' },
+      body: { type: 'string', required: true, max: 500 },
+      user_id: { type: 'number', required: true }
+    },
+    autofilter: 'user',
+    tableName: 'autofilter_user_notes'
+  })
+  await api.resources.user_notes.createKnexTable()
+  mapTable('autofilter_user_notes', 'user_notes')
 
-  // Tenant-specific resources
   await api.addResource('projects', {
     schema: {
       id: { type: 'id' },
       name: { type: 'string', required: true, max: 200 },
       description: { type: 'string', max: 1000 },
       status: { type: 'string', defaultTo: 'active' },
-      tenant_id: { type: 'string', required: true }
+      workspace_id: { type: 'string', required: true },
+      user_id: { type: 'number', required: true }
     },
     relationships: {
       tasks: { type: 'hasMany', target: 'tasks', foreignKey: 'project_id' }
     },
-    tableName: 'multihome_projects'
+    autofilter: 'workspace_user',
+    tableName: 'autofilter_projects'
   })
   await api.resources.projects.createKnexTable()
-  mapTable('multihome_projects', 'projects')
+  mapTable('autofilter_projects', 'projects')
 
   await api.addResource('tasks', {
     schema: {
@@ -1360,37 +1516,40 @@ export async function createMultiHomeApi (knex, pluginOptions = {}) {
       title: { type: 'string', required: true, max: 200 },
       completed: { type: 'boolean', defaultTo: false },
       project_id: { type: 'number', belongsTo: 'projects', as: 'project' },
-      tenant_id: { type: 'string', required: true }
+      workspace_id: { type: 'string', required: true },
+      user_id: { type: 'number', required: true }
     },
-    tableName: 'multihome_tasks'
+    autofilter: 'workspace_user',
+    tableName: 'autofilter_tasks'
   })
   await api.resources.tasks.createKnexTable()
-  mapTable('multihome_tasks', 'tasks')
+  mapTable('autofilter_tasks', 'tasks')
 
-  await api.addResource('users', {
+  await api.addResource('optional_tasks', {
     schema: {
       id: { type: 'id' },
-      email: { type: 'string', required: true, unique: true },
-      name: { type: 'string', required: true },
-      role: { type: 'string', defaultTo: 'member', search: true },
-      tenant_id: { type: 'string', required: true }
+      title: { type: 'string', required: true, max: 200 },
+      project_id: { type: 'number', belongsTo: 'projects', as: 'project', nullable: true }
+    },
+    autofilter: {
+      filters: [{ field: 'project_id', resolver: 'currentProject' }]
     },
-    tableName: 'multihome_users'
+    tableName: 'autofilter_optional_tasks'
   })
-  await api.resources.users.createKnexTable()
-  mapTable('multihome_users', 'users')
+  await api.resources.optional_tasks.createKnexTable()
+  mapTable('autofilter_optional_tasks', 'optional_tasks')
 
-  // Global resource (excluded from multihome)
   await api.addResource('system_settings', {
     schema: {
       id: { type: 'id' },
       key: { type: 'string', required: true, unique: true },
       value: { type: 'string', required: true }
     },
-    tableName: 'multihome_system_settings'
+    autofilter: 'public',
+    tableName: 'autofilter_system_settings'
   })
   await api.resources.system_settings.createKnexTable()
-  mapTable('multihome_system_settings', 'system_settings')
+  mapTable('autofilter_system_settings', 'system_settings')
 
   if (storageMode.isAnyApi()) {
     storageMode.setCurrentTenant(previousTenant)
@@ -1786,7 +1945,9 @@ export async function createVirtualFieldsApi (knex, pluginOptions = {}) {
 }
 
 /**
- * Creates an API configuration for testing searchSchema merge behavior
+ * Creates an API configuration for testing searchSchema merge behavior.
+ * Shared suites assert merge/validation behavior across storage backends;
+ * backend-specific execution cases live in storage-specific tests.
  */
 export async function createSearchSchemaMergeApi (knex, pluginOptions = {}) {
   const api = new Api({
@@ -1825,12 +1986,27 @@ export async function createSearchSchemaMergeApi (knex, pluginOptions = {}) {
         type: 'array',
         filterOperator: 'between'
       },
+      // Arbitrary public filter name that searches across multiple fields.
+      // The key `term` is part of the API contract even though there is no `term` column.
+      term: {
+        type: 'string',
+        oneOf: ['name', 'description'],
+        filterOperator: 'like'
+      },
       // This is a virtual field
       category_name: {
         type: 'string',
         actualField: 'category.name',
         filterOperator: 'like'
       },
+      // Arbitrary public filter name with fully custom server-side meaning.
+      // The Knex query layer decides what `availability` means.
+      availability: {
+        type: 'boolean',
+        applyFilter: (query, value) => {
+          query.where('status', value ? 'active' : 'inactive')
+        }
+      },
       // This is an explicit field not marked with search:true
       // 'in' operator requires array type for validation
       status: {
@@ -1872,77 +2048,3 @@ export async function createSearchSchemaMergeApi (knex, pluginOptions = {}) {
 
   return api
 }
-
-
-/**
- * Creates an API with resources that OPT OUT of ownership
- * - public_items_ownerfield: uses ownerField: false
- * - public_items_ownership: uses ownership: false
- * Both tables intentionally DO NOT have a user_id column.
- */
-export async function createOwnershipOptOutApi (knex, pluginOptions = {}) {
-  const apiName = pluginOptions.apiName || 'ownership-optout-api'
-  const tablePrefix = pluginOptions.tablePrefix || 'ownopt'
-  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']
-  })
-  await useStoragePlugin(api, knex, { tenantId })
-  await resetAnyApiTables(knex)
-
-  try {
-    // Access plugin (defaults: ownership enabled, filterByOwner true)
-    await api.use(AccessPlugin, pluginOptions.access || {})
-
-    // Resource A: disable via ownerField:false
-    await api.addResource('public_items_ownerfield', {
-      schema: {
-        id: { type: 'id' },
-        name: { type: 'string', required: true }
-      },
-      // Important: no user_id column in schema; ownerField disables ownership logic
-      ownerField: false,
-      tableName: `${tablePrefix}_public_items_of`
-    })
-    await api.resources.public_items_ownerfield.createKnexTable()
-    mapTable(`${tablePrefix}_public_items_of`, 'public_items_ownerfield')
-
-    // Resource B: disable via ownership:false
-    await api.addResource('public_items_ownership', {
-      schema: {
-        id: { type: 'id' },
-        name: { type: 'string', required: true }
-      },
-      ownership: false,
-      tableName: `${tablePrefix}_public_items_own`
-    })
-    await api.resources.public_items_ownership.createKnexTable()
-    mapTable(`${tablePrefix}_public_items_own`, 'public_items_ownership')
-
-    return api
-  } finally {
-    if (storageMode.isAnyApi()) {
-      storageMode.setCurrentTenant(previousTenant)
-    }
-  }
-}

package/tests/helpers/fake-fastify.js

@@ -0,0 +1,99 @@
+export class FakeFastifyApp {
+  constructor () {
+    this.routes = []
+    this.parsers = []
+  }
+
+  route (definition) {
+    this.routes.push(definition)
+  }
+
+  addContentTypeParser (contentType, options, parser) {
+    this.parsers.push({ contentType, options, parser })
+  }
+
+  hasContentTypeParser (contentType) {
+    return this.parsers.some((entry) => entry.contentType === contentType)
+  }
+}
+
+export class FakeReply {
+  constructor () {
+    this.statusCode = null
+    this.contentType = null
+    this.headers = {}
+    this.payload = undefined
+  }
+
+  code (statusCode) {
+    this.statusCode = statusCode
+    return this
+  }
+
+  type (contentType) {
+    this.contentType = contentType
+    return this
+  }
+
+  header (name, value) {
+    this.headers[name] = value
+    return this
+  }
+
+  send (payload) {
+    this.payload = payload
+    return this
+  }
+}
+
+export function findFastifyRoute (app, method, url) {
+  return app.routes.find((route) => route.method === method && route.url === url)
+}
+
+export async function invokeFastifyRoute (
+  app,
+  {
+    method,
+    routeUrl,
+    requestUrl = routeUrl,
+    headers = {},
+    body,
+    params = {},
+    query = {}
+  }
+) {
+  const route = findFastifyRoute(app, method, routeUrl)
+  if (!route) {
+    throw new Error(`Fastify route not found: ${method} ${routeUrl}`)
+  }
+
+  const reply = new FakeReply()
+  const request = {
+    method,
+    url: requestUrl,
+    raw: { url: requestUrl },
+    headers,
+    body,
+    params,
+    query
+  }
+
+  if (typeof route.preValidation === 'function') {
+    await route.preValidation(request, reply)
+    if (reply.statusCode !== null || reply.payload !== undefined) {
+      return { route, request, reply }
+    }
+  }
+
+  try {
+    await route.handler(request, reply)
+  } catch (error) {
+    if (typeof route.errorHandler === 'function') {
+      await route.errorHandler(error, request, reply)
+    } else {
+      throw error
+    }
+  }
+
+  return { route, request, reply }
+}