json-rest-api 1.0.28 → 2.0.0

package/tests/relationship-endpoints.test.js

@@ -1,620 +0,0 @@
-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,
-  cleanTables,
-  createJsonApiDocument,
-  createRelationship,
-  createToManyRelationship,
-  resourceIdentifier,
-  countRecords
-} from './helpers/test-utils.js'
-import { createBasicApi } from './fixtures/api-configs.js'
-
-// Create Knex instance for tests
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-// 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 () => {
-    // Close database connection
-    await knex.destroy()
-  })
-
-  describe('Many-to-Many Relationship Endpoints', () => {
-    let countryId
-    let book1Id
-    let author1Id
-    let author2Id
-    let author3Id
-
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'USA', code: 'US' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-      countryId = countryResult.data.id
-
-      // Create a book
-      const bookDoc = createJsonApiDocument('books',
-        { title: 'Test Book' },
-        { country: createRelationship(resourceIdentifier('countries', countryId)) }
-      )
-      const bookResult = await api.resources.books.post({
-        inputRecord: bookDoc,
-        simplified: false
-      })
-      book1Id = bookResult.data.id
-
-      // Create authors
-      const author1Doc = createJsonApiDocument('authors', { name: 'Author One' })
-      const author1Result = await api.resources.authors.post({
-        inputRecord: author1Doc,
-        simplified: false
-      })
-      author1Id = author1Result.data.id
-
-      const author2Doc = createJsonApiDocument('authors', { name: 'Author Two' })
-      const author2Result = await api.resources.authors.post({
-        inputRecord: author2Doc,
-        simplified: false
-      })
-      author2Id = author2Result.data.id
-
-      const author3Doc = createJsonApiDocument('authors', { name: 'Author Three' })
-      const author3Result = await api.resources.authors.post({
-        inputRecord: author3Doc,
-        simplified: false
-      })
-      author3Id = author3Result.data.id
-    })
-
-    it('should get empty relationship data for new book', async () => {
-      const result = await api.resources.books.getRelationship({
-        id: book1Id,
-        relationshipName: 'authors'
-      })
-
-      assert(result.links, 'Should have links')
-      assert.equal(result.links.self, `/books/${book1Id}/relationships/authors`)
-      assert.equal(result.links.related, `/books/${book1Id}/authors`)
-      assert(Array.isArray(result.data), 'Data should be an array')
-      assert.equal(result.data.length, 0, 'Should have no authors')
-    })
-
-    it('should add authors to book via POST relationship endpoint', async () => {
-      // Add authors via relationship endpoint
-      await api.resources.books.postRelationship({
-        id: book1Id,
-        relationshipName: 'authors',
-        relationshipData: [
-          resourceIdentifier('authors', author1Id),
-          resourceIdentifier('authors', author2Id)
-        ]
-      })
-
-      // Verify authors were added via getRelationship
-      const relResult = await api.resources.books.getRelationship({
-        id: book1Id,
-        relationshipName: 'authors'
-      })
-
-      assert.equal(relResult.data.length, 2, 'Should have 2 authors')
-      assert.deepEqual(relResult.data[0], resourceIdentifier('authors', author1Id))
-      assert.deepEqual(relResult.data[1], resourceIdentifier('authors', author2Id))
-
-      // Verify pivot table records
-      const pivotCount = await countRecords(knex, 'basic_book_authors')
-      assert.equal(pivotCount, 2, 'Should have 2 pivot records')
-
-      // Verify through GET with include
-      const getResult = await api.resources.books.get({
-        id: book1Id,
-        queryParams: {
-          include: ['authors']
-        },
-        simplified: false
-      })
-
-      assert(getResult.included, 'Should have included data')
-      assert.equal(getResult.included.length, 2, 'Should include 2 authors')
-      assert(getResult.data.relationships.authors, 'Should have authors relationship')
-      assert.equal(getResult.data.relationships.authors.data.length, 2)
-    })
-
-    it('should get related resources via GET related endpoint', async () => {
-      // Add authors first
-      await api.resources.books.postRelationship({
-        id: book1Id,
-        relationshipName: 'authors',
-        relationshipData: [
-          resourceIdentifier('authors', author1Id),
-          resourceIdentifier('authors', author2Id)
-        ]
-      })
-
-      // Get related resources
-      const result = await api.resources.books.getRelated({
-        id: book1Id,
-        relationshipName: 'authors'
-      })
-
-      // Verify response
-      validateJsonApiStructure(result, true) // true for collection
-      assert.equal(result.data.length, 2, 'Should have 2 authors')
-      assert.equal(result.data[0].type, 'authors')
-      assert.equal(result.data[1].type, 'authors')
-
-      const authorNames = result.data.map(a => a.attributes.name).sort()
-      assert.deepEqual(authorNames, ['Author One', 'Author Two'])
-    })
-
-    it('should remove specific authors via DELETE relationship endpoint', async () => {
-      // Add all authors first
-      await api.resources.books.postRelationship({
-        id: book1Id,
-        relationshipName: 'authors',
-        relationshipData: [
-          resourceIdentifier('authors', author1Id),
-          resourceIdentifier('authors', author2Id),
-          resourceIdentifier('authors', author3Id)
-        ]
-      })
-
-      // Verify all were added
-      let pivotCount = await countRecords(knex, 'basic_book_authors')
-      assert.equal(pivotCount, 3, 'Should have 3 pivot records')
-
-      // Remove one author
-      await api.resources.books.deleteRelationship({
-        id: book1Id,
-        relationshipName: 'authors',
-        relationshipData: [
-          resourceIdentifier('authors', author2Id)
-        ]
-      })
-
-      // Verify only two authors remain
-      const relResult = await api.resources.books.getRelationship({
-        id: book1Id,
-        relationshipName: 'authors'
-      })
-
-      assert.equal(relResult.data.length, 2, 'Should have 2 authors remaining')
-      assert.deepEqual(relResult.data[0], resourceIdentifier('authors', author1Id))
-      assert.deepEqual(relResult.data[1], resourceIdentifier('authors', author3Id))
-
-      // Verify pivot table
-      pivotCount = await countRecords(knex, 'basic_book_authors')
-      assert.equal(pivotCount, 2, 'Should have 2 pivot records')
-    })
-
-    it('should handle errors when relationship does not exist', async () => {
-      await assert.rejects(
-        api.resources.books.getRelationship({
-          id: book1Id,
-          relationshipName: 'nonexistent'
-        }),
-        {
-          message: /Relationship 'nonexistent' not found/
-        }
-      )
-    })
-
-    it('should handle errors when posting to belongsTo relationship', async () => {
-      await assert.rejects(
-        api.resources.books.postRelationship({
-          id: book1Id,
-          relationshipName: 'country',
-          relationshipData: [
-            resourceIdentifier('countries', countryId)
-          ]
-        }),
-        {
-          message: /Cannot POST to to-one relationship/
-        }
-      )
-    })
-
-    it('should work with inverse relationship (authors to books)', async () => {
-      // First add the relationship from book side
-      await api.resources.books.postRelationship({
-        id: book1Id,
-        relationshipName: 'authors',
-        relationshipData: [
-          resourceIdentifier('authors', author1Id)
-        ]
-      })
-
-      // Now check from author side
-      const relResult = await api.resources.authors.getRelationship({
-        id: author1Id,
-        relationshipName: 'books'
-      })
-
-      assert.equal(relResult.data.length, 1, 'Author should have 1 book')
-      assert.deepEqual(relResult.data[0], resourceIdentifier('books', book1Id))
-
-      // Get related books
-      const booksResult = await api.resources.authors.getRelated({
-        id: author1Id,
-        relationshipName: 'books'
-      })
-
-      validateJsonApiStructure(booksResult, true)
-      assert.equal(booksResult.data.length, 1)
-      assert.equal(booksResult.data[0].attributes.title, 'Test Book')
-    })
-  })
-
-  describe('One-to-Many Relationship Endpoints', () => {
-    let countryId
-    let publisherId
-    let book1Id
-    let book2Id
-
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'USA', code: 'US' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-      countryId = countryResult.data.id
-
-      // Create a publisher
-      const publisherDoc = createJsonApiDocument('publishers',
-        { name: 'Test Publisher' },
-        { country: createRelationship(resourceIdentifier('countries', countryId)) }
-      )
-      const publisherResult = await api.resources.publishers.post({
-        inputRecord: publisherDoc,
-        simplified: false
-      })
-      publisherId = publisherResult.data.id
-
-      // Create books
-      const book1Doc = createJsonApiDocument('books',
-        { title: 'Book One' },
-        {
-          country: createRelationship(resourceIdentifier('countries', countryId)),
-          publisher: createRelationship(resourceIdentifier('publishers', publisherId))
-        }
-      )
-      const book1Result = await api.resources.books.post({
-        inputRecord: book1Doc,
-        simplified: false
-      })
-      book1Id = book1Result.data.id
-
-      const book2Doc = createJsonApiDocument('books',
-        { title: 'Book Two' },
-        {
-          country: createRelationship(resourceIdentifier('countries', countryId)),
-          publisher: createRelationship(resourceIdentifier('publishers', publisherId))
-        }
-      )
-      const book2Result = await api.resources.books.post({
-        inputRecord: book2Doc,
-        simplified: false
-      })
-      book2Id = book2Result.data.id
-    })
-
-    it('should get one-to-many relationship data', async () => {
-      const result = await api.resources.publishers.getRelationship({
-        id: publisherId,
-        relationshipName: 'books'
-      })
-
-      assert(result.links, 'Should have links')
-      assert.equal(result.links.self, `/publishers/${publisherId}/relationships/books`)
-      assert.equal(result.links.related, `/publishers/${publisherId}/books`)
-      assert(Array.isArray(result.data), 'Data should be an array')
-      assert.equal(result.data.length, 2, 'Should have 2 books')
-    })
-
-    it('should get related resources for one-to-many', async () => {
-      const result = await api.resources.publishers.getRelated({
-        id: publisherId,
-        relationshipName: 'books'
-      })
-
-      validateJsonApiStructure(result, true)
-      assert.equal(result.data.length, 2)
-      const titles = result.data.map(b => b.attributes.title).sort()
-      assert.deepEqual(titles, ['Book One', 'Book Two'])
-    })
-
-    // 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)
-    })
-  })
-})

package/tests/relationship-include-storage-adapter.test.js

@@ -1,56 +0,0 @@
-import { after, before, beforeEach, describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import {
-  createRelationshipIncludeStorageAdapterApi,
-  seedRelationshipIncludeStorageAdapterApi
-} from './fixtures/api-configs.js'
-import { cleanTables } from './helpers/test-utils.js'
-
-const knex = knexLib({
-  client: 'better-sqlite3',
-  connection: {
-    filename: ':memory:'
-  },
-  useNullAsDefault: true
-})
-
-describe('Relationship include storage adapters', () => {
-  let api
-
-  before(async () => {
-    api = await createRelationshipIncludeStorageAdapterApi(knex)
-  })
-
-  beforeEach(async () => {
-    await cleanTables(knex, [
-      'uninitialized_bookings',
-      'uninitialized_pets'
-    ])
-    await seedRelationshipIncludeStorageAdapterApi(knex)
-  })
-
-  after(async () => {
-    await knex.destroy()
-  })
-
-  it('maps sparse fields for an included scope whose adapter is not initialized', async () => {
-    assert.equal(api.resources.pets.vars.storageAdapter, undefined)
-
-    const result = await api.resources.bookings.get({
-      id: 41,
-      queryParams: {
-        include: ['pet'],
-        fields: {
-          bookings: 'reference,petId',
-          pets: 'firstName'
-        }
-      },
-      simplified: false
-    })
-
-    const includedPet = result.included.find(resource => resource.type === 'pets')
-    assert(includedPet)
-    assert.deepEqual(includedPet.attributes, { firstName: 'Coco' })
-  })
-})