json-rest-api 1.0.28 → 2.0.0

package/tests/pagination-enhanced.test.js

@@ -1,563 +0,0 @@
-import { describe, it, before, after, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import knexLib from 'knex'
-import {
-  validateJsonApiStructure,
-  cleanTables,
-  createJsonApiDocument,
-  createRelationship,
-  resourceIdentifier
-} from './helpers/test-utils.js'
-import { createPaginationApi } from './fixtures/api-configs.js'
-import { parseJsonApiQuery } from '../plugins/core/lib/querying-writing/connectors-query-parser.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
-
-const parseLinkQuery = (link) => {
-  const url = new URL(link, 'https://example.test')
-  return parseJsonApiQuery(url.search.slice(1))
-}
-
-describe('Enhanced Pagination Features', () => {
-  before(async () => {
-    // Initialize API once with pagination features
-    api = await createPaginationApi(knex)
-  })
-
-  after(async () => {
-    // Close database connection
-    await knex.destroy()
-  })
-
-  describe('Self Links', () => {
-    let countryId
-
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'pagination_countries', 'pagination_publishers', 'pagination_books'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-      countryId = countryResult.data.id
-
-      // Create some books
-      for (let i = 1; i <= 3; i++) {
-        const doc = createJsonApiDocument('books',
-          { title: `Book ${i}` },
-          { country: createRelationship(resourceIdentifier('countries', countryResult.data.id)) }
-        )
-        await api.resources.books.post({
-          inputRecord: doc,
-          simplified: false
-        })
-      }
-    })
-
-    it('should add self links to individual resources', async () => {
-      const list = await api.resources.books.query({ simplified: false })
-      const firstId = list.data[0]?.id
-
-      const result = await api.resources.books.get({
-        id: firstId,
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, false)
-      assert(result.data.links, 'Resource should have links')
-      assert.equal(result.data.links.self, `/books/${firstId}`)
-      assert(result.links, 'Response should have top-level links')
-      assert.equal(result.links.self, `/books/${firstId}`)
-    })
-
-    it('should add self links to collection resources', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {},
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-
-      // Check individual resource links
-      result.data.forEach(book => {
-        assert(book.links, 'Each resource should have links')
-        assert(book.links.self, 'Each resource should have self link')
-        assert(book.links.self.startsWith('/books/'))
-      })
-
-      // Check top-level links
-      assert(result.links, 'Response should have top-level links')
-      assert.equal(result.links.self, '/books')
-    })
-
-    it('should add self links to included resources', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          include: ['country']
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-      assert(result.included, 'Should have included resources')
-
-      result.included.forEach(resource => {
-        assert(resource.links, 'Included resource should have links')
-        assert(resource.links.self, 'Included resource should have self link')
-        assert(resource.links.self.startsWith('/'))
-      })
-    })
-
-    it('should add relative self links when no URL prefix configured', async () => {
-      // URLs are now always relative unless overridden via context
-      const result = await api.resources.books.query({
-        queryParams: {},
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-
-      // Links should be present and relative
-      result.data.forEach(book => {
-        assert(book.links, 'Resources should have links')
-        assert(book.links.self, 'Each resource should have self link')
-        assert(book.links.self.startsWith('/books/'), 'Self link should be relative')
-      })
-      assert(result.links, 'Response should have top-level links')
-      assert(result.links.self.startsWith('/books'), 'Top-level self link should be relative')
-    })
-
-    it('should serialize collection self-link query parameters in JSON:API form', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          filters: {
-            country: countryId
-          },
-          fields: {
-            books: 'title,country_id',
-            countries: 'name,code'
-          },
-          include: ['country'],
-          sort: ['title']
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-
-      const selfUrl = new URL(result.links.self, 'https://example.test')
-      const selfQuery = parseLinkQuery(result.links.self)
-
-      assert.equal(selfUrl.searchParams.get('filter[country]'), countryId)
-      assert.equal(selfUrl.searchParams.has('filters[country]'), false)
-      assert.deepEqual(selfQuery.filters, { country: countryId })
-      assert.deepEqual(selfQuery.include, ['country'])
-      assert.deepEqual(selfQuery.sort, ['title'])
-      assert.deepEqual(selfQuery.fields, {
-        books: 'title,country_id',
-        countries: 'name,code'
-      })
-    })
-  })
-
-  describe('Pagination Metadata', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'pagination_countries', 'pagination_publishers', 'pagination_books'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-
-      // Create 10 books for pagination testing
-      for (let i = 1; i <= 10; i++) {
-        const doc = createJsonApiDocument('books',
-          { title: `Book ${String(i).padStart(2, '0')}` },
-          { country: createRelationship(resourceIdentifier('countries', countryResult.data.id)) }
-        )
-        await api.resources.books.post({
-          inputRecord: doc,
-          simplified: false
-        })
-      }
-    })
-
-    it('should include pagination metadata in response', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 2, size: 3 }
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-      assert(result.meta, 'Response should have meta')
-      assert(result.meta.pagination, 'Meta should have pagination')
-
-      const pagination = result.meta.pagination
-      assert.equal(pagination.page, 2)
-      assert.equal(pagination.pageSize, 3)
-      assert.equal(pagination.total, 10)
-      assert.equal(pagination.pageCount, 4)
-      assert.equal(pagination.hasMore, true)
-    })
-
-    it('should calculate hasMore correctly for last page', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 4, size: 3 }
-        },
-        simplified: false
-      })
-
-      assert.equal(result.meta.pagination.hasMore, false)
-      assert.equal(result.meta.pagination.page, 4)
-      assert.equal(result.meta.pagination.pageCount, 4)
-    })
-
-    it('should include pagination links', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 2, size: 3 }
-        },
-        simplified: false
-      })
-
-      assert(result.links, 'Response should have links')
-      assert(result.links.self, 'Should have self link')
-      assert(result.links.first, 'Should have first link')
-      assert(result.links.last, 'Should have last link')
-      assert(result.links.prev, 'Should have prev link')
-      assert(result.links.next, 'Should have next link')
-
-      assert.deepEqual(parseLinkQuery(result.links.self).page, { number: 2, size: 3 })
-      assert.deepEqual(parseLinkQuery(result.links.first).page, { number: 1, size: 3 })
-      assert.deepEqual(parseLinkQuery(result.links.last).page, { number: 4, size: 3 })
-      assert.deepEqual(parseLinkQuery(result.links.prev).page, { number: 1, size: 3 })
-      assert.deepEqual(parseLinkQuery(result.links.next).page, { number: 3, size: 3 })
-    })
-
-    it('should not include prev link on first page', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 1, size: 3 }
-        },
-        simplified: false
-      })
-
-      assert(result.links.first)
-      assert(result.links.next)
-      assert(!result.links.prev, 'First page should not have prev link')
-    })
-
-    it('should not include next link on last page', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 4, size: 3 }
-        },
-        simplified: false
-      })
-
-      assert(result.links.first)
-      assert(result.links.prev)
-      assert(!result.links.next, 'Last page should not have next link')
-    })
-
-    it('should preserve other query parameters in pagination links', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 2, size: 3 },
-          sort: ['-title']
-        },
-        simplified: false
-      })
-
-      assert(result.links, 'Should have links')
-      assert(result.links.next, 'Should have next link since page 2 of 4')
-      const nextQuery = parseLinkQuery(result.links.next)
-      assert.deepEqual(nextQuery.sort, ['-title'])
-      assert.deepEqual(nextQuery.page, { number: 3, size: 3 })
-    })
-  })
-
-  describe('Cursor-based Pagination', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'pagination_countries', 'pagination_publishers', 'pagination_books'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-
-      // Create books
-      for (let i = 1; i <= 15; i++) {
-        const doc = createJsonApiDocument('books',
-          {
-            title: `Book ${String(i).padStart(2, '0')}`
-          },
-          { country: createRelationship(resourceIdentifier('countries', countryResult.data.id)) }
-        )
-        await api.resources.books.post({
-          inputRecord: doc,
-          simplified: false
-        })
-      }
-    })
-
-    it('should support cursor-based pagination with after parameter', async () => {
-      // Get first page
-      const firstPage = await api.resources.books.query({
-        queryParams: {
-          page: { size: 5 },
-          sort: ['-id']
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(firstPage, true)
-      assert.equal(firstPage.data.length, 5)
-      assert(firstPage.meta.pagination.hasMore)
-      assert(firstPage.meta.pagination.cursor?.next)
-
-      // Get next page using cursor
-      const secondPage = await api.resources.books.query({
-        queryParams: {
-          page: {
-            size: 5,
-            after: firstPage.meta.pagination.cursor.next
-          },
-          sort: ['-id']
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(secondPage, true)
-      assert.equal(secondPage.data.length, 5)
-
-      // Verify different records
-      const firstPageIds = firstPage.data.map(b => b.id)
-      const secondPageIds = secondPage.data.map(b => b.id)
-      assert(!firstPageIds.some(id => secondPageIds.includes(id)), 'Pages should have different records')
-    })
-
-    it('should include cursor pagination links', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { size: 5 }
-        },
-        simplified: false
-      })
-
-      assert(result.links)
-      assert(result.links.self)
-      assert(result.links.first)
-      assert(result.links.next)
-      assert(parseLinkQuery(result.links.next).page.after, 'Next link should include cursor parameter')
-    })
-
-    it('should handle last page with cursor pagination', async () => {
-      // Get to last page
-      let currentCursor = null
-      let result
-
-      // Navigate through pages
-      for (let i = 0; i < 3; i++) {
-        result = await api.resources.books.query({
-          queryParams: {
-            page: {
-              size: 5,
-              ...(currentCursor && { after: currentCursor })
-            }
-          },
-          simplified: false
-        })
-
-        if (result.meta.pagination.cursor?.next) {
-          currentCursor = result.meta.pagination.cursor.next
-        }
-      }
-
-      // Last page should have no next cursor
-      assert.equal(result.meta.pagination.hasMore, false)
-      assert(!result.meta.pagination.cursor?.next)
-      assert(!result.links.next)
-    })
-  })
-
-  describe('Count Query Configuration', () => {
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'pagination_countries', 'pagination_publishers', 'pagination_books'
-      ])
-
-      // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
-      const countryResult = await api.resources.countries.post({
-        inputRecord: countryDoc,
-        simplified: false
-      })
-
-      // Create books
-      for (let i = 1; i <= 20; i++) {
-        const doc = createJsonApiDocument('books',
-          { title: `Book ${i}` },
-          { country: createRelationship(resourceIdentifier('countries', countryResult.data.id)) }
-        )
-        await api.resources.books.post({
-          inputRecord: doc,
-          simplified: false
-        })
-      }
-    })
-
-    it('should include count by default', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 1, size: 5 }
-        },
-        simplified: false
-      })
-
-      assert(result.meta.pagination.total !== undefined)
-      assert.equal(result.meta.pagination.total, 20)
-      assert.equal(result.meta.pagination.pageCount, 4)
-    })
-
-    it('should respect enablePaginationCounts when set to false', async () => {
-      // Override the enablePaginationCounts setting for this scope
-      const booksScope = api.resources.books
-      const originalSetting = booksScope.vars.enablePaginationCounts
-      booksScope.vars.enablePaginationCounts = false
-
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 1, size: 5 }
-        },
-        simplified: false
-      })
-
-      assert(result.meta.pagination)
-      assert.equal(result.meta.pagination.page, 1)
-      assert.equal(result.meta.pagination.pageSize, 5)
-      assert(result.meta.pagination.total === undefined, 'Should not include total when counts disabled')
-      assert(result.meta.pagination.pageCount === undefined, 'Should not include pageCount when counts disabled')
-      assert(result.meta.pagination.hasMore === undefined, 'Should not include hasMore when counts disabled')
-
-      // Restore the setting
-      booksScope.vars.enablePaginationCounts = originalSetting
-    })
-  })
-
-  describe('Combined Features', () => {
-    let usCountryId
-
-    beforeEach(async () => {
-      await cleanTables(knex, [
-        'pagination_countries', 'pagination_publishers', 'pagination_books'
-      ])
-
-      // Create multiple countries
-      const countries = []
-      for (const code of ['US', 'UK', 'FR']) {
-        const doc = createJsonApiDocument('countries', { name: `Country ${code}`, code })
-        const result = await api.resources.countries.post({
-          inputRecord: doc,
-          simplified: false
-        })
-        countries.push(result.data)
-        if (code === 'US') {
-          usCountryId = result.data.id
-        }
-      }
-
-      // Create books distributed across countries
-      let bookIndex = 1
-      for (const country of countries) {
-        for (let i = 0; i < 8; i++) {
-          const doc = createJsonApiDocument('books',
-            { title: `Book ${String(bookIndex++).padStart(2, '0')}` },
-            { country: createRelationship(resourceIdentifier('countries', country.id)) }
-          )
-          await api.resources.books.post({
-            inputRecord: doc,
-            simplified: false
-          })
-        }
-      }
-    })
-
-    it('should combine pagination with filtering and includes', async () => {
-      const result = await api.resources.books.query({
-        queryParams: {
-          page: { number: 1, size: 5 },
-          filters: {
-            country: parseInt(usCountryId)
-          },
-          fields: {
-            books: 'title,country_id',
-            countries: 'name,code'
-          },
-          include: ['country'],
-          sort: ['title']
-        },
-        simplified: false
-      })
-
-      validateJsonApiStructure(result, true)
-
-      // Check pagination worked
-      assert.equal(result.data.length, 5)
-      assert.equal(result.meta.pagination.total, 8)
-      assert.equal(result.meta.pagination.pageCount, 2)
-
-      // Check filtering worked
-      const countryIds = result.data.map(b => b.relationships.country.data.id)
-      assert(countryIds.every(id => id === countryIds[0]), 'All books should be from same country')
-
-      // Check includes worked
-      assert(result.included)
-      const usCountry = result.included.find(r => r.type === 'countries' && r.attributes.code === 'US')
-      assert(usCountry)
-
-      // Check self links present
-      result.data.forEach(book => {
-        assert(book.links.self)
-      })
-
-      const nextUrl = new URL(result.links.next, 'https://example.test')
-      const nextQuery = parseJsonApiQuery(nextUrl.search.slice(1))
-      assert.equal(nextUrl.searchParams.get('filter[country]'), usCountryId)
-      assert.equal(nextUrl.searchParams.has('filters[country]'), false)
-      assert.deepEqual(nextQuery.filters, { country: usCountryId })
-      assert.deepEqual(nextQuery.include, ['country'])
-      assert.deepEqual(nextQuery.sort, ['title'])
-      assert.deepEqual(nextQuery.fields, {
-        books: 'title,country_id',
-        countries: 'name,code'
-      })
-      assert.deepEqual(nextQuery.page, { number: 2, size: 5 })
-    })
-  })
-})