json-rest-api 1.0.27 → 1.0.29

package/plugins/core/lib/storage/storage-mapping.js

@@ -1,3 +1,5 @@
+import { normalizeValueForDatabaseStorage } from '../querying-writing/database-value-normalizers.js'
+
 const EMPTY_STORAGE_INFO = Object.freeze({
   idColumn: 'id',
   storage: Object.freeze({
@@ -242,7 +244,11 @@ export const translateAttributesForStorage = (attributes, schemaInfo = {}, optio
         context,
         operation
       })
-      : value
+      : normalizeValueForDatabaseStorage(value, fieldStorage?.definition?.type, {
+        temporalPrecision: fieldStorage?.definition?.temporalPrecision,
+        fieldName,
+        resourceType: context?.scopeName || schemaInfo.tableName
+      })
 
     translated[columnName] = serializedValue
     return translated

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

@@ -13,6 +13,8 @@ import {
   getRequestContracts,
   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 }
 
@@ -582,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}`,
@@ -639,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 })
     }
   }
@@ -671,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
   }
 
@@ -690,6 +699,12 @@ export async function handleRecordReturnAfterWrite ({
     await runHooks('finish')
     await runHooks(`finish${methodSpecificHookSuffix}`)
 
+    context.responseRecord = normalizeRecordAttributes(context.responseRecord, scopes, {
+      source: 'response',
+      simplified: context.simplified,
+      resourceType: scopeName
+    })
+
     // No transformation needed - GET already returns the correct format
     // based on context.simplified
     return context.responseRecord

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')
 
@@ -181,6 +182,12 @@ export default async function getMethod ({
   await runHooks('finish')
   await runHooks('finishGet')
 
+  // Enrichers and finish hooks run after the database pass and may introduce
+  // native values. Reassert the public temporal contract at the return boundary.
+  context.record = normalizeRecordAttributes(context.record, scopes, {
+    source: 'response'
+  })
+
   // Get schema info for transformation
   context.schemaInfo = scopes[scopeName].vars.schemaInfo
 

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({
@@ -154,6 +155,12 @@ export default async function queryMethod ({
   await runHooks('finish')
   await runHooks('finishQuery')
 
+  // Enrichers and finish hooks run after the database pass and may introduce
+  // native values. Reassert the public temporal contract at the return boundary.
+  context.record = normalizeRecordAttributes(context.record, scopes, {
+    source: 'response'
+  })
+
   // Transform output if in simplified mode
   if (context.simplified) {
     // Convert JSON:API response back to simplified format

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/computed-fields.test.js

@@ -86,12 +86,31 @@ describe('Computed Fields and Sparse Fieldsets', () => {
       assert.equal(product.price, 99.99)
       assert.equal(product.profit_margin, 55.00)
       assert.equal(product.profit_amount, 54.99)
+      assert.equal(product.calculated_at, '2026-08-25T23:45:01Z')
+      assert.equal(product.calculated_time, '23:45:01.987')
 
       // normallyHidden fields should not be included
       assert.equal(product.cost, undefined)
       assert.equal(product.internal_notes, undefined)
     })
 
+    it('should normalize computed temporal values at the final return boundary', async () => {
+      const product = await api.resources.products.get({
+        id: testData.product.id,
+        queryParams: { include: ['reviews'] }
+      })
+      assert.equal(product.calculated_at, '2026-08-25T23:45:01Z')
+      assert.equal(product.calculated_time, '23:45:01.987')
+      assert.equal(product.reviews.length, 2)
+      for (const review of product.reviews) {
+        assert.equal(review.calculated_at, '2026-08-25T23:46:02Z')
+      }
+
+      const products = await api.resources.products.query()
+      assert.equal(products.data[0].calculated_at, '2026-08-25T23:45:01Z')
+      assert.equal(products.data[0].calculated_time, '23:45:01.987')
+    })
+
     it('should handle division by zero in computed fields', async () => {
       const freeProduct = await api.resources.products.post({
         name: 'Free Sample',
@@ -132,6 +151,8 @@ describe('Computed Fields and Sparse Fieldsets', () => {
       assert.equal(product.id, testData.product.id)
       assert.equal(product.name, 'Premium Widget')
       assert.equal(product.profit_margin, 55.00)
+      assert.equal(product.calculated_at, undefined)
+      assert.equal(product.calculated_time, undefined)
 
       // Other fields should not be included
       assert.equal(product.price, undefined)

package/tests/db-table-operations.test.js

@@ -176,7 +176,9 @@ describe('dbTablesOperations.createKnexTable', () => {
   it('defaults storage columns to snake_case and keeps per-field overrides', async () => {
     const schema = makeTableSchema({
       displayName: { type: 'string', required: true },
-      lastSeenAt: { type: 'dateTime' },
+      lastSeenAt: { type: 'dateTime', temporalPrecision: 3, defaultTo: () => new Date().toISOString() },
+      observedAtMs: { type: 'epochMilliseconds' },
+      observedAtSeconds: { type: 'epochSeconds' },
       externalRef: { type: 'string', storage: { column: 'legacy_ref' } }
     })
 
@@ -186,6 +188,9 @@ describe('dbTablesOperations.createKnexTable', () => {
     assert.ok(info.id)
     assert.ok(info.display_name)
     assert.ok(info.last_seen_at)
+    assert.equal(info.last_seen_at.defaultValue, null)
+    assert.ok(info.observed_at_ms)
+    assert.ok(info.observed_at_seconds)
     assert.ok(info.legacy_ref)
     assert.equal(info.displayName, undefined)
     assert.equal(info.external_ref, undefined)
@@ -363,6 +368,9 @@ describe('dbTablesOperations.generateKnexMigration', () => {
     const schema = makeTableSchema({
       displayName: { type: 'string', required: true },
       loginCount: { type: 'number', defaultTo: 0 },
+      createdAt: { type: 'dateTime', temporalPrecision: 3, defaultTo: () => new Date().toISOString() },
+      observedAtMs: { type: 'epochMilliseconds' },
+      observedAtSeconds: { type: 'epochSeconds' },
       externalRef: { type: 'string', storage: { column: 'legacy_ref' } }
     })
 
@@ -370,6 +378,10 @@ describe('dbTablesOperations.generateKnexMigration', () => {
 
     assert.ok(migration.includes("table.string('display_name').notNullable()"))
     assert.ok(migration.includes("table.float('login_count').defaultTo(0)"))
+    assert.ok(migration.includes("table.datetime('created_at', { precision: 3 })"))
+    assert.equal(migration.includes("table.datetime('created_at', { precision: 3 }).defaultTo"), false)
+    assert.ok(migration.includes("table.bigInteger('observed_at_ms')"))
+    assert.ok(migration.includes("table.bigInteger('observed_at_seconds')"))
     assert.ok(migration.includes("table.string('legacy_ref')"))
     assert.ok(!migration.includes("table.string('displayName')"))
   })

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
+    }
+  })
 })