json-rest-api 1.0.23 → 1.0.25

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

@@ -118,10 +118,10 @@ describe('dbTablesOperations.createKnexTable', () => {
 
     await db('users').insert({ username: 'testuser' })
     const user = await db('users').where('username', 'testuser').first()
-    await db('posts').insert({ title: 'Test Post', userId: user.id })
+    await db('posts').insert({ title: 'Test Post', user_id: user.id })
 
     const posts = await db('posts')
-      .join('users', 'posts.userId', 'users.id')
+      .join('users', 'posts.user_id', 'users.id')
       .select('posts.title', 'users.username')
 
     assert.equal(posts.length, 1)
@@ -173,10 +173,11 @@ describe('dbTablesOperations.createKnexTable', () => {
     })
   })
 
-  it('uses storage column overrides when creating tables', async () => {
+  it('defaults storage columns to snake_case and keeps per-field overrides', async () => {
     const schema = makeTableSchema({
-      displayName: { type: 'string', required: true, storage: { column: 'display_name' } },
-      lastSeenAt: { type: 'dateTime', storage: { column: 'last_seen_at' } }
+      displayName: { type: 'string', required: true },
+      lastSeenAt: { type: 'dateTime' },
+      externalRef: { type: 'string', storage: { column: 'legacy_ref' } }
     })
 
     await createKnexTable(db, makeSchemaInfo('mapped_profiles'), schema)
@@ -185,7 +186,9 @@ describe('dbTablesOperations.createKnexTable', () => {
     assert.ok(info.id)
     assert.ok(info.display_name)
     assert.ok(info.last_seen_at)
+    assert.ok(info.legacy_ref)
     assert.equal(info.displayName, undefined)
+    assert.equal(info.external_ref, undefined)
   })
 
   it('supports logical id fields mapped to custom storage columns', async () => {
@@ -221,10 +224,10 @@ describe('dbTablesOperations.createKnexTable', () => {
     `)
 
     const schema = makeTableSchema({
-      workspaceId: { type: 'id', required: true, storage: { column: 'workspace_id' } },
-      userId: { type: 'id', required: true, storage: { column: 'user_id' } },
+      workspaceId: { type: 'id', required: true },
+      userId: { type: 'id', required: true },
       role: { type: 'string', enum: ['owner', 'member'], required: true, defaultTo: 'member' },
-      noteCount: { type: 'number', defaultTo: 0, storage: { column: 'note_count' } }
+      noteCount: { type: 'number', defaultTo: 0 }
     }, {
       indexes: [
         {
@@ -352,20 +355,22 @@ describe('dbTablesOperations.generateKnexMigration', () => {
     assert.ok(migration.includes("table.string('title', 200).notNullable()"))
     assert.ok(migration.includes("table.decimal('price', 10, 2)"))
     assert.ok(migration.includes(".defaultTo(true)"))
-    assert.ok(migration.includes("table.foreign(['categoryId'], 'products_categoryId_foreign').references(['id']).inTable('categories').onDelete('SET NULL')"))
+    assert.ok(migration.includes("table.foreign(['category_id'], 'products_category_id_foreign').references(['id']).inTable('categories').onDelete('SET NULL')"))
     assert.ok(migration.includes('table.timestamps(true, true)'))
   })
 
-  it('uses storage column overrides in generated migrations', () => {
+  it('uses default snake_case columns in generated migrations and keeps per-field overrides', () => {
     const schema = makeTableSchema({
-      displayName: { type: 'string', required: true, storage: { column: 'display_name' } },
-      loginCount: { type: 'number', defaultTo: 0, storage: { column: 'login_count' } }
+      displayName: { type: 'string', required: true },
+      loginCount: { type: 'number', defaultTo: 0 },
+      externalRef: { type: 'string', storage: { column: 'legacy_ref' } }
     })
 
     const migration = generateKnexMigration('mapped_profiles', schema)
 
     assert.ok(migration.includes("table.string('display_name').notNullable()"))
     assert.ok(migration.includes("table.float('login_count').defaultTo(0)"))
+    assert.ok(migration.includes("table.string('legacy_ref')"))
     assert.ok(!migration.includes("table.string('displayName')"))
   })
 
@@ -384,11 +389,11 @@ describe('dbTablesOperations.generateKnexMigration', () => {
 
   it('includes named composite indexes, foreign keys, checks, enum, and set columns in generated migrations', () => {
     const schema = makeTableSchema({
-      workspaceId: { type: 'id', required: true, storage: { column: 'workspace_id' } },
-      userId: { type: 'id', required: true, storage: { column: 'user_id' } },
+      workspaceId: { type: 'id', required: true },
+      userId: { type: 'id', required: true },
       role: { type: 'string', enum: ['owner', 'member'], required: true, defaultTo: 'member' },
       flags: { type: 'string', setValues: ['featured', 'archived'] },
-      noteCount: { type: 'number', defaultTo: 0, storage: { column: 'note_count' } }
+      noteCount: { type: 'number', defaultTo: 0 }
     }, {
       indexes: [
         {
@@ -502,10 +507,10 @@ describe('dbTablesOperations.generateKnexMigrationDiff', () => {
       idColumn: 'id'
     })
     const desiredSchema = makeTableSchema({
-      workspaceId: { type: 'id', required: true, storage: { column: 'workspace_id' } },
-      userId: { type: 'id', required: true, storage: { column: 'user_id' } },
+      workspaceId: { type: 'id', required: true },
+      userId: { type: 'id', required: true },
       role: { type: 'string', enum: ['owner', 'member'], required: true, defaultTo: 'member' },
-      noteCount: { type: 'number', defaultTo: 0, storage: { column: 'note_count' } }
+      noteCount: { type: 'number', defaultTo: 0 }
     }, {
       indexes: [
         {
@@ -737,8 +742,8 @@ describe('RestApiKnexPlugin migration scope methods', () => {
     await api.addResource('memberships', {
       schema: {
         id: { type: 'id' },
-        workspaceId: { type: 'id', required: true, storage: { column: 'workspace_id' } },
-        userId: { type: 'id', required: true, storage: { column: 'user_id' } },
+        workspaceId: { type: 'id', required: true },
+        userId: { type: 'id', required: true },
         role: { type: 'string', enum: ['owner', 'member'], required: true, defaultTo: 'member' }
       },
       indexes: [

package/tests/fastify-plugin.test.js

@@ -2,12 +2,27 @@ import { describe, it, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
 import { Api } from 'hooked-api'
 import { RestApiPlugin, FastifyPlugin } from '../index.js'
+import { getRequestContracts } from '../plugins/core/lib/querying-writing/request-contracts.js'
 import {
   FakeFastifyApp,
   FakeReply,
   findFastifyRoute
 } from './helpers/fake-fastify.js'
 
+function resolveSchemaNode (rootSchema, schemaNode) {
+  if (!schemaNode || !Array.isArray(schemaNode.allOf) || schemaNode.allOf.length !== 1) {
+    return schemaNode
+  }
+
+  const ref = schemaNode.allOf[0]?.$ref || ''
+  if (!ref.startsWith('#/definitions/')) {
+    return schemaNode
+  }
+
+  const definitionName = ref.slice('#/definitions/'.length)
+  return rootSchema?.definitions?.[definitionName] || schemaNode
+}
+
 async function createFastifyConnectorApi () {
   const app = new FakeFastifyApp()
   const api = new Api({
@@ -61,6 +76,12 @@ describe('Fastify Plugin', () => {
     const postRelationshipRoute = findFastifyRoute(app, 'POST', '/api/articles/:id/relationships/:relationshipName')
     const patchRelationshipRoute = findFastifyRoute(app, 'PATCH', '/api/articles/:id/relationships/:relationshipName')
     const deleteRelationshipRoute = findFastifyRoute(app, 'DELETE', '/api/articles/:id/relationships/:relationshipName')
+    const relationshipContracts = getRequestContracts({
+      scopeName: 'articles',
+      schemaInfo: api.resources.articles.vars.schemaInfo,
+      includeDepthLimit: api.resources.articles.vars.includeDepthLimit,
+      sortableFields: api.resources.articles.vars.sortableFields
+    })
 
     assert.ok(postRoute?.schema?.body, 'POST route should have a body schema')
     assert.ok(putRoute?.schema?.body, 'PUT route should have a body schema')
@@ -70,7 +91,7 @@ describe('Fastify Plugin', () => {
     assert.ok(patchRelationshipRoute?.schema?.body, 'PATCH relationship route should have a body schema')
     assert.ok(deleteRelationshipRoute?.schema?.body, 'DELETE relationship route should have a body schema')
 
-    const postDataSchema = postRoute.schema.body.properties.data
+    const postDataSchema = resolveSchemaNode(postRoute.schema.body, postRoute.schema.body.properties.data)
     const postAttributes = postDataSchema.properties.attributes
 
     assert.deepEqual(postDataSchema.required, ['type'])
@@ -78,14 +99,15 @@ describe('Fastify Plugin', () => {
     assert.equal(postAttributes.properties.author_id, undefined, 'belongsTo foreign key should not be accepted in attributes')
     assert.equal(postAttributes.properties.internal_summary, undefined, 'computed fields should not be accepted in attributes')
     assert.equal(postAttributes.properties.id, undefined, 'resource ids should not appear in attributes')
-    assert.ok(postDataSchema.properties.relationships.properties.author, 'declared belongsTo relationships should be represented in the transport schema')
+    const postRelationships = resolveSchemaNode(postRoute.schema.body, postDataSchema.properties.relationships)
+    assert.ok(postRelationships.properties.author, 'declared belongsTo relationships should be represented in the transport schema')
 
-    const putDataSchema = putRoute.schema.body.properties.data
+    const putDataSchema = resolveSchemaNode(putRoute.schema.body, putRoute.schema.body.properties.data)
     assert.ok(putDataSchema.required.includes('id'), 'PUT body schema should require data.id')
 
-    const patchDataSchema = patchRoute.schema.body.properties.data
-    assert.ok(Array.isArray(patchDataSchema.anyOf), 'PATCH body schema should require at least one writable section')
-    assert.deepEqual(patchDataSchema.anyOf, [
+    const patchDataSchemaNode = patchRoute.schema.body.properties.data
+    assert.ok(Array.isArray(patchDataSchemaNode.anyOf), 'PATCH body schema should require at least one writable section')
+    assert.deepEqual(patchDataSchemaNode.anyOf, [
       { required: ['attributes'] },
       { required: ['relationships'] }
     ])
@@ -93,6 +115,27 @@ describe('Fastify Plugin', () => {
     assert.equal(postRelationshipRoute.schema.body.properties.data.type, 'array')
     assert.ok(Array.isArray(patchRelationshipRoute.schema.body.properties.data.anyOf))
     assert.equal(deleteRelationshipRoute.schema.body.properties.data.type, 'array')
+    assert.deepEqual(
+      postRelationshipRoute.schema.body,
+      relationshipContracts.postRelationship.schema.toJsonSchema({
+        mode: relationshipContracts.postRelationship.mode,
+        additionalProperties: false
+      })
+    )
+    assert.deepEqual(
+      patchRelationshipRoute.schema.body,
+      relationshipContracts.patchRelationship.schema.toJsonSchema({
+        mode: relationshipContracts.patchRelationship.mode,
+        additionalProperties: false
+      })
+    )
+    assert.deepEqual(
+      deleteRelationshipRoute.schema.body,
+      relationshipContracts.deleteRelationship.schema.toJsonSchema({
+        mode: relationshipContracts.deleteRelationship.mode,
+        additionalProperties: false
+      })
+    )
   })
 
   it('registers the JSON:API content-type parser and rejects unsupported write content types before the route handler', async () => {

package/tests/field-setters.test.js

@@ -176,7 +176,7 @@ describe('Field Setters', () => {
       await cleanTables(knex, ['setter_users'])
     })
 
-    it('should handle setter errors gracefully', async () => {
+    it('should reject setter errors and roll back the write', async () => {
       // Create a resource with a failing setter
       await api.addResource('error_test', {
         schema: {
@@ -196,16 +196,16 @@ describe('Field Setters', () => {
       })
       await api.resources.error_test.createKnexTable()
 
-      const record = await api.resources.error_test.post({
-        good_field: 'HELLO',
-        bad_field: 'world'
-      })
+      await assert.rejects(
+        api.resources.error_test.post({
+          good_field: 'HELLO',
+          bad_field: 'world'
+        }),
+        /Setter for field 'bad_field' failed: Setter failed!/
+      )
 
-      const fetchedRecord = await api.resources.error_test.get({ id: record.id })
-      // Good field should be transformed
-      assert.equal(fetchedRecord.good_field, 'hello')
-      // Bad field should keep validated value (error logged but not thrown)
-      assert.equal(fetchedRecord.bad_field, 'world')
+      const records = await api.resources.error_test.query()
+      assert.equal(records?.length || 0, 0)
 
       await cleanTables(knex, ['setter_errors'])
     })

package/tests/file-handling.test.js

@@ -0,0 +1,118 @@
+import { describe, it, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { cleanTables } from './helpers/test-utils.js'
+import { createFileUploadApi } from './fixtures/api-configs.js'
+
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+})
+
+let api
+let detectorState
+let storage
+
+function createTrackingStorage () {
+  return {
+    uploaded: [],
+    deleted: [],
+
+    async upload (file) {
+      const url = `/uploads/${file.filename}`
+      this.uploaded.push(url)
+      return url
+    },
+
+    async delete (url) {
+      this.deleted.push(url)
+    }
+  }
+}
+
+function createTestFile ({ filename = 'upload.png', mimetype = 'image/png', cleanup } = {}) {
+  return {
+    filename,
+    mimetype,
+    size: 1,
+    data: Buffer.from('x'),
+    cleanup
+  }
+}
+
+describe('File handling cleanup', () => {
+  before(async () => {
+    detectorState = { payload: null }
+    storage = createTrackingStorage()
+    api = await createFileUploadApi(knex, { detectorState, storage })
+  })
+
+  after(async () => {
+    await knex.destroy()
+  })
+
+  beforeEach(async () => {
+    await cleanTables(knex, ['file_documents'])
+    detectorState.payload = null
+    storage.uploaded = []
+    storage.deleted = []
+  })
+
+  it('cleans detector temp files when MIME validation rejects an upload', async () => {
+    let cleanupCalls = 0
+    detectorState.payload = {
+      fields: { title: 'Invalid MIME' },
+      files: {
+        attachment: createTestFile({
+          filename: 'invalid.txt',
+          mimetype: 'text/plain',
+          cleanup: async () => {
+            cleanupCalls++
+          }
+        })
+      }
+    }
+
+    await assert.rejects(
+      api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: {} } },
+        simplified: false
+      }),
+      /Invalid file type for field 'attachment'/
+    )
+
+    assert.equal(cleanupCalls, 1)
+    assert.deepEqual(storage.uploaded, [])
+    assert.deepEqual(storage.deleted, [])
+  })
+
+  it('deletes uploaded files when a later write validation error rolls back', async () => {
+    let cleanupCalls = 0
+    detectorState.payload = {
+      fields: {},
+      files: {
+        attachment: createTestFile({
+          filename: 'valid.png',
+          cleanup: async () => {
+            cleanupCalls++
+          }
+        })
+      }
+    }
+
+    await assert.rejects(
+      api.resources.documents.post({
+        inputRecord: { data: { type: 'documents', attributes: {} } },
+        simplified: false
+      }),
+      /Schema validation failed for resource attributes/
+    )
+
+    assert.equal(cleanupCalls, 1)
+    assert.deepEqual(storage.uploaded, ['/uploads/valid.png'])
+    assert.deepEqual(storage.deleted, ['/uploads/valid.png'])
+  })
+})