json-rest-api 1.0.28 → 1.0.29

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

@@ -18,7 +18,6 @@ import { getUrlPrefix, buildResourceUrl, buildRelationshipUrl } from './lib/quer
 import {
   normalizeId,
   resolveFieldInfo,
-  coerceValueForDefinition,
   normalizeFilterValues,
   ensureFilterableField,
 } from './lib/anyapi/utils/descriptor-helpers.js'
@@ -48,13 +47,15 @@ import {
   translateCanonicalRecordFromStorage,
 } from './lib/storage/canonical-storage-mapping.js'
 import {
-  buildCursorPredicateChains,
+  applyCursorPredicate,
+  validateCursorValues,
   applyQueryFieldOrder,
   buildEffectiveSortList,
   parseSortEntry
 } from './lib/querying/query-field-sort-helpers.js'
 import { unwrapQueryBuilderState } from './lib/querying/query-builder-utils.js'
 import { serializeJsonApiQuery } from './lib/querying-writing/connectors-query-parser.js'
+import { normalizeValueForDatabaseStorage } from './lib/querying-writing/database-value-normalizers.js'
 
 const DEFAULT_TENANT = 'default'
 const LINKS_TABLE = 'any_links'
@@ -237,7 +238,7 @@ export const RestApiAnyapiKnexPlugin = {
       }
     }
 
-    const applySortingToQuery = ({ query, sort, descriptor, scope, queryFieldRuntimeByField = new Map() }) => {
+    const applySortingToQuery = ({ query, sort, descriptor, scope, adapter, before = false, queryFieldRuntimeByField = new Map() }) => {
       const effectiveSort = buildEffectiveSortList(sort, {
         defaultSort: scope?.vars?.defaultSort,
         idField: 'id'
@@ -245,10 +246,11 @@ export const RestApiAnyapiKnexPlugin = {
       const descriptors = []
 
       for (const entry of effectiveSort) {
-        const { field, direction, sqlDirection } = parseSortEntry(entry)
+        const { field, direction } = parseSortEntry(entry)
+        const queryDirection = before ? (direction === 'asc' ? 'desc' : 'asc') : direction
         const queryFieldRuntime = queryFieldRuntimeByField.get(field)
         if (queryFieldRuntime) {
-          applyQueryFieldOrder(query, queryFieldRuntime, sqlDirection)
+          applyQueryFieldOrder(query, queryFieldRuntime, queryDirection.toUpperCase(), before ? 'first' : 'last')
           descriptors.push({
             field,
             direction,
@@ -261,7 +263,8 @@ export const RestApiAnyapiKnexPlugin = {
 
         const fieldInfo = resolveFieldInfo(descriptor, field)
         if (!fieldInfo?.column) continue
-        query.orderBy(fieldInfo.column, direction)
+        query.orderByRaw(`?? IS NULL ${before ? 'DESC' : 'ASC'}`, [adapter.translateColumn(fieldInfo.column)])
+        query.orderBy(fieldInfo.column, queryDirection)
         descriptors.push({
           field,
           column: fieldInfo.column,
@@ -328,55 +331,21 @@ export const RestApiAnyapiKnexPlugin = {
         }
       }
 
-      const coerceCursorValues = (cursorMap) => {
-        const typed = {}
-        for (const descriptor of descriptors) {
-          if (descriptor.field === undefined) continue
-          const raw = cursorMap[descriptor.field]
-          if (raw === undefined) continue
-          typed[descriptor.field] = coerceValueForDefinition(
-            raw,
-            descriptor.definition,
-            { isRelationship: descriptor.isRelationship }
-          )
-        }
-        return typed
-      }
-
       const applyRawCursorPredicate = (cursorValues, operatorSelector) => {
-        const predicateChains = buildCursorPredicateChains(
+        applyCursorPredicate(
+          query,
           descriptors,
           cursorValues,
           operatorSelector,
-          { onMissingValue: () => {} }
+          (builder, descriptor, operator, value) => builder.where(
+            descriptor.column,
+            operator,
+            normalizeValueForDatabaseStorage(
+              value, descriptor.isRelationship ? null : descriptor.definition?.type,
+              { temporalPrecision: descriptor.definition?.temporalPrecision }
+            )
+          )
         )
-
-        if (predicateChains.length === 0) {
-          return
-        }
-
-        const predicateParts = []
-        const predicateBindings = []
-
-        predicateChains.forEach((chain) => {
-          const chainParts = chain.map(({ descriptor, operator, value }) => {
-            const normalizedValue = adapter?.translateFilterValue
-              ? adapter.translateFilterValue(descriptor.field, value)
-              : value
-            if (descriptor.queryFieldRuntime) {
-              predicateBindings.push(...(descriptor.queryFieldRuntime.bindings || []), normalizedValue)
-              return `(${descriptor.queryFieldRuntime.sql}) ${operator} ?`
-            }
-
-            const columnRef = adapter ? adapter.translateColumn(descriptor.column) : descriptor.column
-            predicateBindings.push(normalizedValue)
-            return `${columnRef} ${operator} ?`
-          })
-
-          predicateParts.push(`(${chainParts.join(' AND ')})`)
-        })
-
-        query.whereRaw(`(${predicateParts.join(' OR ')})`, predicateBindings)
       }
 
       const ensurePageSize = () => {
@@ -414,11 +383,11 @@ export const RestApiAnyapiKnexPlugin = {
 
         if (pageParams.after) {
           const cursorMap = parseCursorOrThrow(pageParams.after, 'after')
-          const cursorValues = coerceCursorValues(cursorMap)
+          const cursorValues = validateCursorValues(descriptors, cursorMap, 'after')
           applyRawCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '<' : '>'))
         } else if (pageParams.before) {
           const cursorMap = parseCursorOrThrow(pageParams.before, 'before')
-          const cursorValues = coerceCursorValues(cursorMap)
+          const cursorValues = validateCursorValues(descriptors, cursorMap, 'before')
           applyRawCursorPredicate(cursorValues, (direction) => (direction === 'desc' ? '>' : '<'))
         }
 
@@ -445,11 +414,11 @@ export const RestApiAnyapiKnexPlugin = {
         }
       }
 
-      query.limit(defaultLimit)
+      query.limit(Math.min(defaultLimit, maxLimit))
       return {
         mode: 'default',
         page: 1,
-        pageSize: defaultLimit,
+        pageSize: Math.min(defaultLimit, maxLimit),
         sortDescriptors: descriptors,
       }
     }
@@ -2186,6 +2155,8 @@ export const RestApiAnyapiKnexPlugin = {
         sort: queryParams.sort,
         descriptor,
         scope,
+        adapter,
+        before: Boolean(queryParams.page?.before),
         queryFieldRuntimeByField: selectionState.queryFieldRuntimeByField
       })
 
@@ -2222,6 +2193,10 @@ export const RestApiAnyapiKnexPlugin = {
           rows = rows.slice(0, pageSize)
           cursorRecords = cursorRecords.slice(0, pageSize)
         }
+        if (queryParams.page?.before) {
+          rows.reverse()
+          cursorRecords.reverse()
+        }
       }
 
       const data = rows.map((row) => {
@@ -2313,14 +2288,17 @@ export const RestApiAnyapiKnexPlugin = {
         )
       } else if (paginationInfo.mode === 'cursor' && cursorRecords) {
         const cursorFields = paginationInfo.sortDescriptors.map((descriptorEntry) => descriptorEntry.field)
+        const cursorOptions = {
+          schemaInfo,
+          definitions: Object.fromEntries(paginationInfo.sortDescriptors.map(({ field, definition }) => [field, definition])),
+          before: Boolean(queryParams.page?.before)
+        }
         const paginationMeta = buildCursorMeta(
           cursorRecords,
           paginationInfo.pageSize,
           hasMore,
           cursorFields,
-          {
-            schemaInfo
-          }
+          cursorOptions
         )
         context.returnMeta.paginationMeta = paginationMeta
         const urlPrefix = getUrlPrefix(context, scope)
@@ -2332,9 +2310,7 @@ export const RestApiAnyapiKnexPlugin = {
           paginationInfo.pageSize,
           hasMore,
           cursorFields,
-          {
-            schemaInfo
-          }
+          cursorOptions
         )
       }
 

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

@@ -33,6 +33,7 @@ import { getUrlPrefix } from './lib/querying/url-helpers.js'
 import { createStorageAdapter } from './lib/storage/storage-adapter.js'
 import {
   applyCursorPredicate,
+  validateCursorValues,
   applyQueryFieldOrder,
   buildEffectiveSortList,
   parseSortEntry
@@ -113,6 +114,7 @@ export const RestApiKnexPlugin = {
       sortableFields,
       storageAdapter,
       defaultSort,
+      before = false,
       queryFieldRuntimeByField = new Map()
     }) => {
       const effectiveSort = buildEffectiveSortList(sort, { defaultSort, idField: 'id' })
@@ -120,6 +122,7 @@ export const RestApiKnexPlugin = {
 
       for (const sortEntry of effectiveSort) {
         const { field, direction, sqlDirection } = parseSortEntry(sortEntry)
+        const queryDirection = before ? (direction === 'asc' ? 'desc' : 'asc') : direction
 
         if (field !== 'id' && sortableFields?.length > 0 && !sortableFields.includes(field)) {
           log.warn(`Ignoring non-sortable field: ${field}`)
@@ -128,7 +131,7 @@ export const RestApiKnexPlugin = {
 
         const queryFieldRuntime = queryFieldRuntimeByField.get(field)
         if (queryFieldRuntime) {
-          applyQueryFieldOrder(query, queryFieldRuntime, sqlDirection)
+          applyQueryFieldOrder(query, queryFieldRuntime, queryDirection.toUpperCase(), before ? 'first' : 'last')
           descriptors.push({
             field,
             direction: sqlDirection,
@@ -145,11 +148,15 @@ export const RestApiKnexPlugin = {
           dbField = searchField.actualField
         }
 
-        const translatedField = storageAdapter?.translateColumn
+        const storageColumn = storageAdapter?.translateColumn
           ? storageAdapter.translateColumn(dbField)
           : dbField
+        const translatedField = storageColumn.includes('.')
+          ? storageColumn
+          : `${storageAdapter?.getTableName?.() || schemaInfo.tableName}.${storageColumn}`
 
-        query.orderBy(translatedField, direction)
+        query.orderByRaw(`?? IS NULL ${before ? 'DESC' : 'ASC'}`, [translatedField])
+        query.orderBy(translatedField, queryDirection)
         descriptors.push({
           field,
           direction: sqlDirection,
@@ -659,6 +666,7 @@ export const RestApiKnexPlugin = {
         schemaInfo,
         sortableFields,
         defaultSort: scope.vars.defaultSort,
+        before: Boolean(queryParams.page?.before),
         storageAdapter,
         queryFieldRuntimeByField
       })
@@ -671,13 +679,13 @@ export const RestApiKnexPlugin = {
          queryParams.page.after !== undefined ||
          queryParams.page.before !== undefined)
 
-      if (hasPageParams) {
-        const requestedSize = queryParams.page.size || scope.vars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
-        const pageSize = Math.min(
-          requestedSize,
-          scope.vars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT
-        )
+      const requestedSize = queryParams.page?.size || scope.vars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
+      const pageSize = Math.min(
+        requestedSize,
+        scope.vars.queryMaxLimit || DEFAULT_MAX_QUERY_LIMIT
+      )
 
+      if (hasPageParams) {
         // Validate page size
         if (requestedSize <= 0) {
           throw new RestApiValidationError(
@@ -721,6 +729,7 @@ export const RestApiKnexPlugin = {
               )
             }
 
+            cursorData = validateCursorValues(sortDescriptors, cursorData, 'after')
             applyCursorPredicate(
               query,
               sortDescriptors,
@@ -755,6 +764,7 @@ export const RestApiKnexPlugin = {
               )
             }
 
+            cursorData = validateCursorValues(sortDescriptors, cursorData, 'before')
             applyCursorPredicate(
               query,
               sortDescriptors,
@@ -778,8 +788,7 @@ export const RestApiKnexPlugin = {
         }
       } else {
         // No pagination params provided - apply default limit
-        const defaultLimit = scope.vars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
-        query.limit(defaultLimit)
+        query.limit(pageSize)
       }
 
       // Execute query
@@ -793,7 +802,6 @@ export const RestApiKnexPlugin = {
       // Execute count query for pagination if offset-based pagination is used
       if (queryParams.page?.number !== undefined || (queryParams.page?.size !== undefined && !queryParams.page?.after && !queryParams.page?.before)) {
         const page = parseInt(queryParams.page?.number) || 1
-        const pageSize = parseInt(queryParams.page?.size) || scope.vars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
 
         // Only execute count query if enabled
         if (scope.vars.enablePaginationCounts) {
@@ -855,8 +863,6 @@ export const RestApiKnexPlugin = {
       // Generate cursor metadata when using cursor parameters OR when only size is specified (no page number)
       if (queryParams.page?.after || queryParams.page?.before ||
           (queryParams.page?.size && queryParams.page?.number === undefined)) {
-        const pageSize = parseInt(queryParams.page?.size) || scope.vars.queryDefaultLimit || DEFAULT_QUERY_LIMIT
-
         // Check if there are more records
         // We fetched pageSize + 1 records to detect if there are more
         const hasMore = records.length > pageSize
@@ -865,12 +871,16 @@ export const RestApiKnexPlugin = {
         if (hasMore) {
           records.pop()
         }
+        if (queryParams.page?.before) records.reverse()
 
         const sortFields = sortDescriptors.map((descriptor) => descriptor.field)
+        const cursorOptions = {
+          schemaInfo,
+          definitions: Object.fromEntries(sortDescriptors.map(({ field, definition }) => [field, definition])),
+          before: Boolean(queryParams.page?.before)
+        }
 
-        context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields, {
-          schemaInfo
-        })
+        context.returnMeta.paginationMeta = buildCursorMeta(records, pageSize, hasMore, sortFields, cursorOptions)
         const urlPrefix = getUrlPrefix(context, scope)
         context.returnMeta.paginationLinks = generateCursorPaginationLinks(
           urlPrefix,
@@ -880,9 +890,7 @@ export const RestApiKnexPlugin = {
           pageSize,
           hasMore,
           sortFields,
-          {
-            schemaInfo
-          }
+          cursorOptions
         )
       }
 

package/plugins/core/rest-api-plugin-methods/common.js

@@ -14,6 +14,7 @@ import {
   validateRequestContractOrThrow
 } from '../lib/querying-writing/request-contracts.js'
 import { normalizeRecordAttributes } from '../lib/querying-writing/database-value-normalizers.js'
+import { isRestApiError } from '../../../lib/error-context.js'
 
 export { normalizeReturnRecordMode as normalizeReturnValue }
 
@@ -583,6 +584,7 @@ export const applyFieldSetters = async (attributes, schemaInfo, context, api, he
         setterContext
       )
     } catch (error) {
+      if (isRestApiError(error)) throw error
       const message = error instanceof Error ? error.message : String(error)
       throw new RestApiValidationError(
         `Setter for field '${fieldName}' failed: ${message}`,
@@ -640,6 +642,7 @@ export async function handleRecordReturnAfterWrite ({
       })
       context.minimalRecord = currentRecord
     } catch (error) {
+      if (isRestApiError(error)) throw error
       enhancedLog.warn(`Could not fetch minimal record after ${context.method} operation`, { error, id: context.id })
     }
   }
@@ -672,6 +675,11 @@ export async function handleRecordReturnAfterWrite ({
     }
     await runHooks('finish')
     await runHooks(`finish${methodSpecificHookSuffix}`)
+    context.responseRecord = normalizeRecordAttributes(context.responseRecord, scopes, {
+      source: 'response',
+      simplified: context.simplified,
+      resourceType: scopeName
+    })
     return context.responseRecord
   }
 
@@ -692,7 +700,9 @@ export async function handleRecordReturnAfterWrite ({
     await runHooks(`finish${methodSpecificHookSuffix}`)
 
     context.responseRecord = normalizeRecordAttributes(context.responseRecord, scopes, {
-      source: 'response'
+      source: 'response',
+      simplified: context.simplified,
+      resourceType: scopeName
     })
 
     // No transformation needed - GET already returns the correct format

package/plugins/core/rest-api-plugin-methods/enrich-attributes.js

@@ -1,4 +1,5 @@
 import { filterHiddenFields } from '../lib/querying-writing/field-utils.js'
+import { isRestApiError } from '../../../lib/error-context.js'
 
 /**
  * enrichAttributes
@@ -64,6 +65,7 @@ export default async function enrichAttributesMethod ({ context, params, runHook
           getterContext
         )
       } catch (error) {
+        if (isRestApiError(error)) throw error
         console.error(`Error in getter for field '${fieldName}' in ${scopeName}:`, error)
         // Keep current value on error (don't break the whole request)
       }
@@ -144,6 +146,7 @@ export default async function enrichAttributesMethod ({ context, params, runHook
         // and returns: ((100 - 60) / 100 * 100) = "40.00"
         filteredAttributes[fieldName] = await fieldDef.compute(computeContext)
       } catch (error) {
+        if (isRestApiError(error)) throw error
         // Log error but don't fail the request - computed fields shouldn't break API
         console.error(`Error computing field '${fieldName}' for ${scopeName}:`, error)
         filteredAttributes[fieldName] = null

package/plugins/core/rest-api-plugin-methods/get.js

@@ -1,6 +1,6 @@
 import { RestApiResourceError } from '../../../lib/rest-api-errors.js'
 import { normalizeRecordAttributes } from '../lib/querying-writing/database-value-normalizers.js'
-import { getRequestedComputedFields } from '../lib/querying-writing/knex-field-helpers.js'
+import { getRequestedComputedFields, validateRequestedFieldsets } from '../lib/querying-writing/knex-field-helpers.js'
 import { transformJsonApiToSimplified } from '../lib/querying-writing/simplified-helpers.js'
 import { getRequestContracts, validateRequestContractOrThrow } from '../lib/querying-writing/request-contracts.js'
 import { requireExistingResourceId } from '../lib/querying-writing/resource-id-normalization.js'
@@ -106,6 +106,7 @@ export default async function getMethod ({
     originalContext: context,
   })
 
+  await validateRequestedFieldsets(context, scopes)
   await runHooks('beforeData')
   await runHooks('beforeDataGet')
 

package/plugins/core/rest-api-plugin-methods/query.js

@@ -1,5 +1,5 @@
 import { normalizeRecordAttributes } from '../lib/querying-writing/database-value-normalizers.js'
-import { getRequestedComputedFields } from '../lib/querying-writing/knex-field-helpers.js'
+import { getRequestedComputedFields, validateRequestedFieldsets } from '../lib/querying-writing/knex-field-helpers.js'
 import { getEffectiveSortableFields } from '../lib/querying/query-field-sort-helpers.js'
 import { transformJsonApiToSimplified } from '../lib/querying-writing/simplified-helpers.js'
 import { getRequestContracts, validateRequestContractOrThrow } from '../lib/querying-writing/request-contracts.js'
@@ -90,6 +90,7 @@ export default async function queryMethod ({
     originalContext: context,
   })
 
+  await validateRequestedFieldsets(context, scopes)
   await runHooks('beforeData')
   await runHooks('beforeDataQuery')
   context.record = await helpers.dataQuery({

package/tests/anyapi-cursor-pagination.test.js

@@ -127,9 +127,7 @@ maybeDescribe('AnyAPI Cursor Pagination', () => {
       simplified: false,
     })
 
-    const beforeCursor =
-      secondPage.meta.pagination.cursor?.next ||
-      `id:${encodeURIComponent(secondPage.data[0].id)}`
+    const beforeCursor = `id:${encodeURIComponent(secondPage.data[0].id)}`
 
     const previousPage = await api.resources.books.query({
       queryParams: {

package/tests/file-handling.test.js

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict'
 import knexLib from 'knex'
 import { cleanTables } from './helpers/test-utils.js'
 import { createFileUploadApi } from './fixtures/api-configs.js'
+import { RestApiPayloadError, RestApiResourceError } from '../lib/rest-api-errors.js'
 
 const knex = knexLib({
   client: 'better-sqlite3',
@@ -115,4 +116,40 @@ describe('File handling cleanup', () => {
     assert.deepEqual(storage.uploaded, ['/uploads/valid.png'])
     assert.deepEqual(storage.deleted, ['/uploads/valid.png'])
   })
+
+  it('preserves typed errors from file detectors', async () => {
+    const detector = api.rest.fileDetectors[0]
+    const originalParse = detector.parse
+    const error = new RestApiPayloadError('Malformed upload', { path: 'attachment' })
+    detectorState.payload = { fields: { title: 'Upload' }, files: {} }
+    detector.parse = async () => { throw error }
+    try {
+      await assert.rejects(api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: { title: 'Upload' } } }, simplified: false
+      }), actual => actual === error)
+      assert.equal((await api.resources.documents.query({ simplified: false })).data.length, 0)
+    } finally {
+      detector.parse = originalParse
+    }
+  })
+
+  it('preserves typed upload errors and still cleans temporary files', async () => {
+    const originalUpload = storage.upload
+    const error = new RestApiResourceError('Upload forbidden', { subtype: 'forbidden' })
+    let cleanupCalls = 0
+    detectorState.payload = {
+      fields: { title: 'Upload' },
+      files: { attachment: createTestFile({ cleanup: async () => { cleanupCalls++ } }) }
+    }
+    storage.upload = async () => { throw error }
+    try {
+      await assert.rejects(api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: {} } }, simplified: false
+      }), actual => actual === error)
+      assert.equal(cleanupCalls, 1)
+      assert.equal((await api.resources.documents.query({ simplified: false })).data.length, 0)
+    } finally {
+      storage.upload = originalUpload
+    }
+  })
 })

package/tests/fixtures/api-configs.js

@@ -58,6 +58,63 @@ async function withTenantContext (tenantId, fn) {
   }
 }
 
+export async function createTemporalBoundaryApi (knex) {
+  const api = new Api({ name: 'temporal-boundaries', log: { level: 'error' } })
+  await api.use(RestApiPlugin, {
+    simplifiedApi: false,
+    simplifiedTransport: false,
+    returnRecordApi: { post: 'full', put: 'full', patch: 'full' },
+    queryDefaultLimit: 2,
+    queryMaxLimit: 3
+  })
+  await api.use(QueryProjectionsPlugin)
+  await useStoragePlugin(api, knex)
+  const producedAt = {
+    type: 'dateTime', temporalPrecision: 0, computed: true,
+    compute: () => new Date('2026-09-08T01:02:03.456Z')
+  }
+  await api.addResource('people', {
+    schema: { id: { type: 'id' }, name: { type: 'string' }, producedAt },
+    relationships: { events: { type: 'hasMany', target: 'events', foreignKey: 'personId' } },
+    tableName: 'temporal_people'
+  })
+  await api.resources.people.createKnexTable()
+  mapTable('temporal_people', 'people')
+  await api.addResource('events', {
+    sortableFields: ['id', 'name', 'occurredAt', 'day', 'atTime', 'observedAtMs'],
+    schema: {
+      id: { type: 'id' },
+      name: { type: 'string', required: true },
+      occurredAt: { type: 'dateTime', temporalPrecision: 6, nullable: true, search: true },
+      day: { type: 'date', nullable: true, search: true },
+      atTime: { type: 'time', temporalPrecision: 3, nullable: true, search: true },
+      observedAtMs: { type: 'epochMilliseconds', nullable: true, search: true },
+      observedAtSeconds: { type: 'epochSeconds', nullable: true, search: true },
+      serializedAt: {
+        type: 'dateTime', temporalPrecision: 6, nullable: true, search: true,
+        storage: { serialize: value => value == null ? null : value.replace('T', ' ').replace(/Z$/, '') }
+      },
+      personId: { type: 'id', belongsTo: 'people', as: 'person', nullable: true },
+      subjectId: { type: 'number', nullable: true },
+      subjectType: { type: 'string', nullable: true },
+      producedAt
+    },
+    queryFields: {
+      projectedAt: {
+        type: 'dateTime', temporalPrecision: 3, sortable: true,
+        select: ({ knex, column }) => knex.raw('??', [column('occurredAt')])
+      }
+    },
+    relationships: {
+      subject: { belongsToPolymorphic: { types: ['people'], typeField: 'subjectType', idField: 'subjectId' } }
+    },
+    tableName: 'temporal_events'
+  })
+  await api.resources.events.createKnexTable()
+  mapTable('temporal_events', 'events')
+  return api
+}
+
 /**
  * Creates a basic API configuration with Countries, Publishers, Authors, Books
  */