json-rest-api 1.0.24 → 1.0.25

package/tests/post-commit-hooks.test.js

@@ -0,0 +1,120 @@
+import { describe, it, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import {
+  cleanTables,
+  countRecords,
+  createJsonApiDocument,
+  createRelationship,
+  resourceIdentifier
+} from './helpers/test-utils.js'
+import { createBasicApi } from './fixtures/api-configs.js'
+
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+})
+
+let api
+let afterCommitFailureMethod = null
+const rollbackEvents = []
+
+describe('Post-commit hook failure semantics', () => {
+  before(async () => {
+    api = await createBasicApi(knex, {
+      apiName: 'post-commit-hook-test',
+      tablePrefix: 'post_commit'
+    })
+
+    await api.customize({
+      hooks: {
+        afterCommit: {
+          functionName: 'post-commit-failure-test',
+          handler: async ({ context }) => {
+            if (context.method === afterCommitFailureMethod) {
+              throw new Error(`afterCommit failed for ${context.method}`)
+            }
+          }
+        },
+        afterRollback: {
+          functionName: 'post-commit-rollback-tracker',
+          handler: async ({ context }) => {
+            rollbackEvents.push(context.method)
+          }
+        }
+      }
+    })
+  })
+
+  after(async () => {
+    await knex.destroy()
+  })
+
+  beforeEach(async () => {
+    afterCommitFailureMethod = null
+    rollbackEvents.length = 0
+
+    await cleanTables(knex, [
+      'post_commit_countries',
+      'post_commit_publishers',
+      'post_commit_authors',
+      'post_commit_books',
+      'post_commit_book_authors'
+    ])
+  })
+
+  it('surfaces afterCommit errors without rolling back committed resource writes', async () => {
+    afterCommitFailureMethod = 'post'
+
+    await assert.rejects(
+      api.resources.countries.post({
+        inputRecord: createJsonApiDocument('countries', {
+          name: 'Committed Country',
+          code: 'CC'
+        }),
+        simplified: false
+      }),
+      /afterCommit failed for post/
+    )
+
+    assert.equal(await countRecords(knex, 'post_commit_countries'), 1)
+    assert.deepEqual(rollbackEvents, [])
+  })
+
+  it('surfaces afterCommit errors without rolling back committed relationship writes', async () => {
+    const country = await api.resources.countries.post({
+      inputRecord: createJsonApiDocument('countries', { name: 'USA', code: 'US' }),
+      simplified: false
+    })
+    const book = await api.resources.books.post({
+      inputRecord: createJsonApiDocument(
+        'books',
+        { title: 'Committed Book' },
+        { country: createRelationship(resourceIdentifier('countries', country.data.id)) }
+      ),
+      simplified: false
+    })
+    const author = await api.resources.authors.post({
+      inputRecord: createJsonApiDocument('authors', { name: 'Committed Author' }),
+      simplified: false
+    })
+
+    rollbackEvents.length = 0
+    afterCommitFailureMethod = 'postRelationship'
+
+    await assert.rejects(
+      api.resources.books.postRelationship({
+        id: book.data.id,
+        relationshipName: 'authors',
+        relationshipData: [resourceIdentifier('authors', author.data.id)]
+      }),
+      /afterCommit failed for postRelationship/
+    )
+
+    assert.equal(await countRecords(knex, 'post_commit_book_authors'), 1)
+    assert.deepEqual(rollbackEvents, [])
+  })
+})

package/tests/public-exports.test.js

@@ -0,0 +1,15 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { RowPolicyPlugin, SocketIOPlugin } from '../index.js'
+
+describe('Public exports', () => {
+  it('exports the documented Socket.IO plugin from the package entrypoint', () => {
+    assert.equal(SocketIOPlugin.name, 'socketio')
+    assert.equal(typeof SocketIOPlugin.install, 'function')
+  })
+
+  it('exports the row-policy plugin from the package entrypoint', () => {
+    assert.equal(RowPolicyPlugin.name, 'row-policy')
+    assert.equal(typeof RowPolicyPlugin.install, 'function')
+  })
+})

package/tests/put-create-parity.test.js

@@ -0,0 +1,216 @@
+import { describe, it, before, beforeEach, after } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { Api } from 'hooked-api'
+
+import {
+  RestApiAnyapiKnexPlugin,
+  RestApiKnexPlugin,
+  RestApiPlugin,
+} from '../index.js'
+import { ensureAnyApiSchema } from '../plugins/core/lib/anyapi/schema-utils.js'
+import {
+  cleanTables,
+  validateJsonApiStructure,
+} from './helpers/test-utils.js'
+import { storageMode } from './helpers/storage-mode.js'
+
+const knex = knexLib({
+  client: 'better-sqlite3',
+  connection: {
+    filename: ':memory:'
+  },
+  useNullAsDefault: true
+})
+
+const tenantId = 'put_create_parity_tenant'
+const profilesTable = 'put_create_profiles'
+const accountsTable = 'put_create_accounts'
+
+let api
+
+const registerTable = (tableName, resourceName) => {
+  if (storageMode.isAnyApi()) {
+    storageMode.registerTable(tableName, resourceName, tenantId)
+  }
+}
+
+const findStoredRow = async (tableName, resourceName, idColumn, id) => {
+  if (storageMode.isAnyApi()) {
+    return knex('any_records')
+      .where({
+        tenant_id: tenantId,
+        resource: resourceName,
+        logical_id: String(id),
+      })
+      .first()
+  }
+
+  return knex(tableName)
+    .where(idColumn, id)
+    .first()
+}
+
+const countStoredRows = async (tableName, resourceName, idColumn, id) => {
+  if (storageMode.isAnyApi()) {
+    const row = await knex('any_records')
+      .where({
+        tenant_id: tenantId,
+        resource: resourceName,
+        logical_id: String(id),
+      })
+      .count('* as count')
+      .first()
+    return Number(row?.count || 0)
+  }
+
+  const row = await knex(tableName)
+    .where(idColumn, id)
+    .count('* as count')
+    .first()
+  return Number(row?.count || 0)
+}
+
+describe(`PUT create parity (${storageMode.mode})`, () => {
+  before(async () => {
+    if (storageMode.isAnyApi()) {
+      storageMode.clearRegistry()
+      storageMode.setCurrentTenant(tenantId)
+      await ensureAnyApiSchema(knex)
+    }
+
+    api = new Api({
+      name: 'put-create-parity-test',
+      log: { level: 'warn' }
+    })
+
+    await api.use(RestApiPlugin, {
+      simplifiedApi: false,
+      simplifiedTransport: false,
+      returnRecordApi: {
+        post: 'full',
+        put: 'full',
+        patch: 'full'
+      },
+      returnRecordTransport: {
+        post: 'full',
+        put: 'full',
+        patch: 'full'
+      },
+      sortableFields: ['id', 'account_id', 'name', 'code']
+    })
+
+    if (storageMode.isAnyApi()) {
+      await api.use(RestApiAnyapiKnexPlugin, { knex, tenantId })
+    } else {
+      await api.use(RestApiKnexPlugin, { knex })
+    }
+
+    await api.addResource('profiles', {
+      tableName: profilesTable,
+      schema: {
+        id: { type: 'id' },
+        name: { type: 'string', required: true },
+        code: { type: 'string', required: true },
+      }
+    })
+    await api.resources.profiles.createKnexTable()
+    registerTable(profilesTable, 'profiles')
+
+    await api.addResource('accounts', {
+      tableName: accountsTable,
+      idProperty: 'account_id',
+      schema: {
+        name: { type: 'string', required: true },
+        code: { type: 'string', required: true },
+      }
+    })
+    await api.resources.accounts.createKnexTable()
+    registerTable(accountsTable, 'accounts')
+  })
+
+  after(async () => {
+    await api?.release()
+    await knex.destroy()
+    if (storageMode.isAnyApi()) {
+      storageMode.clearRegistry()
+    }
+  })
+
+  beforeEach(async () => {
+    await cleanTables(knex, [profilesTable, accountsTable])
+  })
+
+  it('creates a missing resource through PUT with the default id property', async () => {
+    const created = await api.resources.profiles.put({
+      id: '101',
+      inputRecord: {
+        data: {
+          type: 'profiles',
+          id: '101',
+          attributes: {
+            name: 'Created Profile',
+            code: 'CP'
+          }
+        }
+      },
+      simplified: false
+    })
+
+    validateJsonApiStructure(created)
+    assert.equal(created.data.id, '101')
+    assert.equal(created.data.attributes.name, 'Created Profile')
+
+    const stored = await findStoredRow(profilesTable, 'profiles', 'id', 101)
+    assert(stored, 'PUT create should persist a row')
+  })
+
+  it('creates and then replaces a missing resource through PUT with a custom id property', async () => {
+    const created = await api.resources.accounts.put({
+      id: '501',
+      inputRecord: {
+        data: {
+          type: 'accounts',
+          id: '501',
+          attributes: {
+            name: 'Created Account',
+            code: 'CA'
+          }
+        }
+      },
+      simplified: false
+    })
+
+    validateJsonApiStructure(created)
+    assert.equal(created.data.id, '501')
+    assert.equal(created.data.attributes.name, 'Created Account')
+    assert.equal(created.data.attributes.account_id, undefined)
+
+    const replaced = await api.resources.accounts.put({
+      id: '501',
+      inputRecord: {
+        data: {
+          type: 'accounts',
+          id: '501',
+          attributes: {
+            name: 'Replaced Account',
+            code: 'RA'
+          }
+        }
+      },
+      simplified: false
+    })
+
+    assert.equal(replaced.data.id, '501')
+    assert.equal(replaced.data.attributes.name, 'Replaced Account')
+    assert.equal(await countStoredRows(accountsTable, 'accounts', 'account_id', 501), 1)
+
+    const fetched = await api.resources.accounts.get({
+      id: '501',
+      simplified: false
+    })
+    assert.equal(fetched.data.attributes.name, 'Replaced Account')
+    assert.equal(fetched.data.attributes.code, 'RA')
+    assert.equal(fetched.data.attributes.account_id, undefined)
+  })
+})

package/tests/relationship-endpoints.test.js

@@ -1,5 +1,7 @@
 import { describe, it, before, after, beforeEach } from 'node:test'
 import assert from 'node:assert/strict'
+import express from 'express'
+import request from 'supertest'
 import knexLib from 'knex'
 import {
   validateJsonApiStructure,
@@ -23,16 +25,50 @@ const knex = knexLib({
 
 // API instance that persists across tests
 let api
+let app
+const relationshipCommitEvents = []
+const relationshipRollbackEvents = []
 
 describe('Relationship Endpoints Plugin', () => {
   before(async () => {
     // Initialize API with the relationships plugin
+    app = express()
     api = await createBasicApi(knex, {
       express: {
         mountPath: ''  // No mount path for this test
       },
       includeExpress: true
     })
+    api.http.express.mount(app)
+
+    await api.customize({
+      hooks: {
+        afterCommit: {
+          functionName: 'relationship-after-commit-test-tracker',
+          handler: async ({ context }) => {
+            if (context.method?.endsWith('Relationship')) {
+              relationshipCommitEvents.push({
+                method: context.method,
+                shouldCommit: context.shouldCommit,
+                hasTransaction: !!context.transaction
+              })
+            }
+          }
+        },
+        afterRollback: {
+          functionName: 'relationship-after-rollback-test-tracker',
+          handler: async ({ context }) => {
+            if (context.method?.endsWith('Relationship')) {
+              relationshipRollbackEvents.push({
+                method: context.method,
+                shouldCommit: context.shouldCommit,
+                hasTransaction: !!context.transaction
+              })
+            }
+          }
+        }
+      }
+    })
   })
 
   after(async () => {
@@ -358,4 +394,227 @@ describe('Relationship Endpoints Plugin', () => {
     // Note: belongsTo relationships (like 'publisher') are not accessible via relationship endpoints
     // They are foreign key fields, not true JSON:API relationships
   })
+
+  describe('Relationship Cardinality Validation', () => {
+    let countryId
+    let bookId
+    let authorId
+
+    const assertRelationshipIdValidationError = (error) => {
+      assert.equal(error.code, 'REST_API_VALIDATION')
+      assert.match(error.message, /id/i)
+      return true
+    }
+
+    beforeEach(async () => {
+      await cleanTables(knex, [
+        'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
+      ])
+
+      const country = await api.resources.countries.post({
+        inputRecord: createJsonApiDocument('countries', { name: 'USA', code: 'US' }),
+        simplified: false
+      })
+      countryId = country.data.id
+
+      const book = await api.resources.books.post({
+        inputRecord: createJsonApiDocument(
+          'books',
+          { title: 'Cardinality Book' },
+          { country: createRelationship(resourceIdentifier('countries', countryId)) }
+        ),
+        simplified: false
+      })
+      bookId = book.data.id
+
+      const author = await api.resources.authors.post({
+        inputRecord: createJsonApiDocument('authors', { name: 'Author One' }),
+        simplified: false
+      })
+      authorId = author.data.id
+    })
+
+    it('rejects arrays for to-one relationship PATCH calls', async () => {
+      await assert.rejects(
+        api.resources.books.patchRelationship({
+          id: bookId,
+          relationshipName: 'country',
+          relationshipData: [resourceIdentifier('countries', countryId)]
+        }),
+        (error) => {
+          assert.equal(error.code, 'REST_API_VALIDATION')
+          assert.match(error.message, /single resource identifier or null/)
+          assert(error.details.fields.includes('data.relationships.country.data'))
+          return true
+        }
+      )
+    })
+
+    it('rejects scalars for to-many relationship PATCH calls', async () => {
+      await assert.rejects(
+        api.resources.books.patchRelationship({
+          id: bookId,
+          relationshipName: 'authors',
+          relationshipData: resourceIdentifier('authors', authorId)
+        }),
+        (error) => {
+          assert.equal(error.code, 'REST_API_VALIDATION')
+          assert.match(error.message, /array of resource identifiers/)
+          assert(error.details.fields.includes('data.relationships.authors.data'))
+          return true
+        }
+      )
+    })
+
+    it('rejects invalid relationship cardinality through Express transport', async () => {
+      const toOneResponse = await request(app)
+        .patch(`/books/${bookId}/relationships/country`)
+        .set('Content-Type', 'application/vnd.api+json')
+        .set('Accept', 'application/vnd.api+json')
+        .send({
+          data: [resourceIdentifier('countries', countryId)]
+        })
+
+      assert.equal(toOneResponse.status, 422)
+      assert.match(toOneResponse.body.errors?.[0]?.detail || '', /single resource identifier or null/)
+
+      const toManyResponse = await request(app)
+        .patch(`/books/${bookId}/relationships/authors`)
+        .set('Content-Type', 'application/vnd.api+json')
+        .set('Accept', 'application/vnd.api+json')
+        .send({
+          data: resourceIdentifier('authors', authorId)
+        })
+
+      assert.equal(toManyResponse.status, 422)
+      assert.match(toManyResponse.body.errors?.[0]?.detail || '', /array of resource identifiers/)
+    })
+
+    it('rejects malformed relationship identifiers through direct relationship methods', async () => {
+      await assert.rejects(
+        api.resources.books.postRelationship({
+          id: bookId,
+          relationshipName: 'authors',
+          relationshipData: [{ type: 'authors' }]
+        }),
+        assertRelationshipIdValidationError
+      )
+
+      await assert.rejects(
+        api.resources.books.patchRelationship({
+          id: bookId,
+          relationshipName: 'country',
+          relationshipData: { type: 'countries' }
+        }),
+        assertRelationshipIdValidationError
+      )
+    })
+
+    it('rejects malformed relationship identifiers through Express transport', async () => {
+      const response = await request(app)
+        .delete(`/books/${bookId}/relationships/authors`)
+        .set('Content-Type', 'application/vnd.api+json')
+        .set('Accept', 'application/vnd.api+json')
+        .send({
+          data: [{ type: 'authors' }]
+        })
+
+      assert.equal(response.status, 422)
+      assert.match(response.body.errors?.[0]?.detail || '', /id/i)
+    })
+  })
+
+  describe('Relationship Transaction Hooks', () => {
+    let countryId
+    let secondCountryId
+    let bookId
+    let authorId
+
+    beforeEach(async () => {
+      relationshipCommitEvents.length = 0
+      relationshipRollbackEvents.length = 0
+
+      await cleanTables(knex, [
+        'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
+      ])
+
+      const country = await api.resources.countries.post({
+        inputRecord: createJsonApiDocument('countries', { name: 'USA', code: 'US' }),
+        simplified: false
+      })
+      countryId = country.data.id
+
+      const secondCountry = await api.resources.countries.post({
+        inputRecord: createJsonApiDocument('countries', { name: 'Canada', code: 'CA' }),
+        simplified: false
+      })
+      secondCountryId = secondCountry.data.id
+
+      const book = await api.resources.books.post({
+        inputRecord: createJsonApiDocument(
+          'books',
+          { title: 'Hook Book' },
+          { country: createRelationship(resourceIdentifier('countries', countryId)) }
+        ),
+        simplified: false
+      })
+      bookId = book.data.id
+
+      const author = await api.resources.authors.post({
+        inputRecord: createJsonApiDocument('authors', { name: 'Hook Author' }),
+        simplified: false
+      })
+      authorId = author.data.id
+
+      relationshipCommitEvents.length = 0
+      relationshipRollbackEvents.length = 0
+    })
+
+    it('runs afterCommit for relationship methods that own their transaction', async () => {
+      await api.resources.books.postRelationship({
+        id: bookId,
+        relationshipName: 'authors',
+        relationshipData: [resourceIdentifier('authors', authorId)]
+      })
+
+      await api.resources.books.patchRelationship({
+        id: bookId,
+        relationshipName: 'country',
+        relationshipData: resourceIdentifier('countries', secondCountryId)
+      })
+
+      await api.resources.books.deleteRelationship({
+        id: bookId,
+        relationshipName: 'authors',
+        relationshipData: [resourceIdentifier('authors', authorId)]
+      })
+
+      assert.deepEqual(
+        relationshipCommitEvents.map((event) => event.method),
+        ['postRelationship', 'patchRelationship', 'deleteRelationship']
+      )
+      assert(relationshipCommitEvents.every((event) => event.shouldCommit))
+      assert(relationshipCommitEvents.every((event) => event.hasTransaction))
+      assert.equal(relationshipRollbackEvents.length, 0)
+    })
+
+    it('preserves afterRollback for failed relationship methods that own their transaction', async () => {
+      await assert.rejects(
+        api.resources.books.postRelationship({
+          id: bookId,
+          relationshipName: 'missing',
+          relationshipData: []
+        }),
+        /Relationship 'missing' not found/
+      )
+
+      assert.deepEqual(
+        relationshipRollbackEvents.map((event) => event.method),
+        ['postRelationship']
+      )
+      assert(relationshipRollbackEvents[0].shouldCommit)
+      assert(relationshipRollbackEvents[0].hasTransaction)
+      assert.equal(relationshipCommitEvents.length, 0)
+    })
+  })
 })