json-rest-api 1.0.22 → 1.0.23

package/audit/evidence/tests/query-include-test-signals.txt

@@ -1,948 +0,0 @@
-tests/custom-idproperty-relationships.test.js:151:      // Verify through GET with include
-tests/custom-idproperty-relationships.test.js:154:        queryParams: {
-tests/custom-idproperty-relationships.test.js:155:          include: ['country']
-tests/custom-idproperty-relationships.test.js:160:      assert(getResult.included, 'Should have included data')
-tests/custom-idproperty-relationships.test.js:161:      assert.equal(getResult.included.length, 1)
-tests/custom-idproperty-relationships.test.js:162:      assert.equal(getResult.included[0].type, 'countries')
-tests/custom-idproperty-relationships.test.js:163:      assert.equal(getResult.included[0].attributes.name, 'United States')
-tests/custom-idproperty-relationships.test.js:204:      // Verify update via GET with include
-tests/custom-idproperty-relationships.test.js:207:        queryParams: { include: ['country'] }
-tests/custom-idproperty-relationships.test.js:210:      assert.equal(updated.included[0].id, country2.data.id)
-tests/custom-idproperty-relationships.test.js:211:      assert.equal(updated.included[0].attributes.name, 'UK')
-tests/custom-idproperty-relationships.test.js:288:      // Verify through GET with include
-tests/custom-idproperty-relationships.test.js:291:        queryParams: { include: ['authors'] }
-tests/custom-idproperty-relationships.test.js:294:      assert(getResult.included)
-tests/custom-idproperty-relationships.test.js:295:      assert.equal(getResult.included.length, 2)
-tests/custom-idproperty-relationships.test.js:296:      const includedNames = getResult.included.map(a => a.attributes.name).sort()
-tests/custom-idproperty-relationships.test.js:297:      assert.deepEqual(includedNames, ['Author One', 'Author Two'])
-tests/custom-idproperty-relationships.test.js:328:        queryParams: {
-tests/custom-idproperty-relationships.test.js:329:          include: ['authors']
-tests/custom-idproperty-relationships.test.js:335:      // With include, we should get the authors relationship data
-tests/custom-idproperty-relationships.test.js:342:        queryParams: { include: ['authors'] }
-tests/custom-idproperty-relationships.test.js:345:      assert.equal(updated.included.length, 2)
-tests/custom-idproperty-relationships.test.js:424:    it('should query polymorphic reviews by type', async () => {
-tests/custom-idproperty-relationships.test.js:449:      const bookReviews = await api.resources.reviews.query({
-tests/custom-idproperty-relationships.test.js:450:        queryParams: {
-tests/custom-idproperty-relationships.test.js:467:    it('should handle nested includes through custom ID relationships', async () => {
-tests/custom-idproperty-relationships.test.js:495:      // Query with nested includes
-tests/custom-idproperty-relationships.test.js:496:      const result = await api.resources.books.query({
-tests/custom-idproperty-relationships.test.js:497:        queryParams: {
-tests/custom-idproperty-relationships.test.js:498:          include: ['publisher.country', 'authors']
-tests/custom-idproperty-relationships.test.js:503:      assert(result.included)
-tests/custom-idproperty-relationships.test.js:505:      // Find each type in included
-tests/custom-idproperty-relationships.test.js:506:      const includedPublisher = result.included.find(r => r.type === 'publishers')
-tests/custom-idproperty-relationships.test.js:507:      const includedCountry = result.included.find(r => r.type === 'countries')
-tests/custom-idproperty-relationships.test.js:508:      const includedAuthor = result.included.find(r => r.type === 'authors')
-tests/custom-idproperty-relationships.test.js:510:      assert(includedPublisher, 'Should include publisher')
-tests/custom-idproperty-relationships.test.js:511:      assert(includedCountry, 'Should include country')
-tests/custom-idproperty-relationships.test.js:512:      assert(includedAuthor, 'Should include author')
-tests/custom-idproperty-relationships.test.js:515:      assert.equal(includedPublisher.relationships.country.data.id, country.data.id)
-tests/custom-idproperty-relationships.test.js:518:    it('should handle 3+ levels of nested includes', async () => {
-tests/custom-idproperty-relationships.test.js:550:      const result = await api.resources.books.query({
-tests/custom-idproperty-relationships.test.js:551:        queryParams: {
-tests/custom-idproperty-relationships.test.js:552:          include: ['authors.country', 'publisher.country']
-tests/custom-idproperty-relationships.test.js:557:      assert(result.included)
-tests/custom-idproperty-relationships.test.js:559:      const types = result.included.map(r => r.type)
-tests/custom-idproperty-relationships.test.js:560:      assert(types.includes('authors'), 'Should include authors')
-tests/custom-idproperty-relationships.test.js:561:      assert(types.includes('publishers'), 'Should include publishers')
-tests/custom-idproperty-relationships.test.js:562:      assert(types.includes('countries'), 'Should include countries')
-tests/custom-idproperty-relationships.test.js:607:    it('should combine sparse fieldsets with includes using custom IDs', async () => {
-tests/custom-idproperty-relationships.test.js:610:        queryParams: {
-tests/custom-idproperty-relationships.test.js:611:          include: ['publisher', 'authors'],
-tests/custom-idproperty-relationships.test.js:625:      // Check included resources have only requested fields
-tests/custom-idproperty-relationships.test.js:626:      const publisher = result.included.find(r => r.type === 'publishers')
-tests/custom-idproperty-relationships.test.js:628:      assert(publisher.id) // ID is always included
-tests/custom-idproperty-relationships.test.js:630:      const author = result.included.find(r => r.type === 'authors')
-tests/custom-idproperty-relationships.test.js:645:    it('should enforce include depth limits', async () => {
-tests/custom-idproperty-relationships.test.js:678:      const validDepth = await api.resources.books.query({
-tests/custom-idproperty-relationships.test.js:679:        queryParams: {
-tests/custom-idproperty-relationships.test.js:680:          include: ['authors.country']
-tests/custom-idproperty-relationships.test.js:687:      const maxDepth = await api.resources.books.query({
-tests/custom-idproperty-relationships.test.js:688:        queryParams: {
-tests/custom-idproperty-relationships.test.js:689:          include: ['publisher.country', 'authors.country']
-tests/custom-idproperty-relationships.test.js:704:    it('should handle complex queries with filters, includes, and custom IDs', async () => {
-tests/custom-idproperty-relationships.test.js:764:      // Complex query: US books with their publishers and authors
-tests/custom-idproperty-relationships.test.js:765:      const result = await api.resources.books.query({
-tests/custom-idproperty-relationships.test.js:766:        queryParams: {
-tests/custom-idproperty-relationships.test.js:768:          include: ['publisher.country', 'authors'],
-tests/custom-idproperty-relationships.test.js:776:      // Verify includes
-tests/custom-idproperty-relationships.test.js:777:      const includedTypes = result.included.map(r => r.type)
-tests/custom-idproperty-relationships.test.js:778:      assert(includedTypes.includes('publishers'))
-tests/custom-idproperty-relationships.test.js:779:      assert(includedTypes.includes('countries'))
-tests/custom-idproperty-relationships.test.js:780:      assert(includedTypes.includes('authors'))
-tests/custom-idproperty-relationships.test.js:813:        queryParams: { include: ['authors'] }
-tests/custom-idproperty-relationships.test.js:816:      assert.equal(bookWithAuthors.included.length, 3)
-tests/custom-idproperty-relationships.test.js:850:        assert(error.message.includes('not found') || error.message.includes('404'))
-tests/cors.test.js:146:      includeExpress: true,
-tests/cors.test.js:273:      assert(response.headers['access-control-allow-headers'].includes('X-Custom-Header'))
-tests/cors.test.js:384:        includeExpress: true,
-tests/cors.test.js:421:        includeExpress: true,
-tests/cors.test.js:467:        includeExpress: true,
-tests/cors.test.js:508:        includeExpress: true,
-tests/cors.test.js:526:      assert(response.body.error.includes('CORS origin not allowed'))
-tests/cors.test.js:587:        includeExpress: true,
-tests/cors.test.js:614:        includeExpress: true,
-tests/cors.test.js:641:        includeExpress: true,
-tests/cors.test.js:668:        includeExpress: true,
-tests/cors.test.js:697:        includeExpress: true,
-tests/cors.test.js:774:      assert(response.headers['access-control-allow-methods'].includes('PUT'))
-tests/cors.test.js:785:        includeExpress: true,
-tests/cors.test.js:813:        includeExpress: true,
-tests/curl.test.js:71:    basicApi = await createBasicApi(knex, { includeExpress: true })
-tests/curl.test.js:216:    it('should handle query parameters using CURL', async () => {
-tests/curl.test.js:239:    it('should handle includes using CURL', async () => {
-tests/curl.test.js:250:      const result = await executeCurl(['-s', '-H', 'Accept: application/vnd.api+json', `http://localhost:${TEST_PORT}/api/publishers/${publisherResult.data.id}?include=country`])
-tests/curl.test.js:258:      assert(response.included, 'Should have included data')
-tests/curl.test.js:259:      assert.equal(response.included.length, 1, 'Should include one resource')
-tests/curl.test.js:260:      assert.equal(response.included[0].type, 'countries')
-tests/curl.test.js:261:      assert.equal(response.included[0].id, testData.country.id)
-tests/curl.test.js:327:      assert(result.stderr.includes('X-Custom-Header: test-value'), 'Should send custom header')
-tests/curl.test.js:328:      assert(result.stderr.includes('User-Agent: CURL-Test/1.0'), 'Should send custom user agent')
-tests/curl.test.js:388:    it('should handle nested includes using CURL', async () => {
-tests/curl.test.js:389:      const result = await executeCurl(['-s', '-H', 'Accept: application/vnd.api+json', `http://localhost:${TEST_PORT}/api/books/${testData.book.id}?include=publisher.country,authors`])
-tests/curl.test.js:397:      assert(response.included, 'Should have included data')
-tests/curl.test.js:399:      // Should include publisher, country, and 2 authors
-tests/curl.test.js:400:      assert.equal(response.included.length, 4, 'Should include 4 resources')
-tests/curl.test.js:402:      const includedTypes = response.included.map(r => r.type)
-tests/curl.test.js:403:      assert(includedTypes.includes('publishers'), 'Should include publisher')
-tests/curl.test.js:404:      assert(includedTypes.includes('countries'), 'Should include country')
-tests/curl.test.js:405:      assert.equal(includedTypes.filter(t => t === 'authors').length, 2, 'Should include 2 authors')
-tests/curl.test.js:408:    it('should handle pagination using CURL', async () => {
-tests/curl.test.js:423:      // Test pagination (URL encode square brackets)
-tests/curl.test.js:432:      // Note: Links are now always included, using relative URLs whenreturnBasePath isn't configured
-tests/curl.test.js:449:    it('should handle sparse fieldsets using CURL', async () => {
-tests/curl.test.js:450:      const result = await executeCurl(['-s', '-H', 'Accept: application/vnd.api+json', `http://localhost:${TEST_PORT}/api/books/${testData.book.id}?fields%5Bbooks%5D=title&fields%5Bpublishers%5D=name&include=publisher`])
-tests/curl.test.js:462:      const publisher = response.included.find(r => r.type === 'publishers')
-tests/pagination-cursor-multifield.test.js:25:    // Initialize API once with cursor pagination configuration
-tests/pagination-cursor-multifield.test.js:36:      await cleanTables(knex, ['cursor_products'])
-tests/pagination-cursor-multifield.test.js:58:    it.skip('should handle cursor pagination with multi-field sorting without skipping records', async () => {
-tests/pagination-cursor-multifield.test.js:62:      let cursor = null
-tests/pagination-cursor-multifield.test.js:65:      // Collect all products through cursor pagination
-tests/pagination-cursor-multifield.test.js:67:        const result = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:68:          queryParams: {
-tests/pagination-cursor-multifield.test.js:71:              ...(cursor && { after: cursor })
-tests/pagination-cursor-multifield.test.js:82:        if (!result.meta.pagination.hasMore) {
-tests/pagination-cursor-multifield.test.js:85:        cursor = result.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:107:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:108:        queryParams: {
-tests/pagination-cursor-multifield.test.js:115:      const secondPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:116:        queryParams: {
-tests/pagination-cursor-multifield.test.js:119:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:132:      assert(secondPageNames.includes('Apple') || secondPageNames.includes('Banana'),
-tests/pagination-cursor-multifield.test.js:133:        'Second page should include fruits that come after vegetables')
-tests/pagination-cursor-multifield.test.js:151:      let cursor = null
-tests/pagination-cursor-multifield.test.js:156:        const result = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:157:          queryParams: {
-tests/pagination-cursor-multifield.test.js:160:              ...(cursor && { after: cursor })
-tests/pagination-cursor-multifield.test.js:169:        if (!result.meta.pagination.hasMore) {
-tests/pagination-cursor-multifield.test.js:172:        cursor = result.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:176:      assert(iterations < 20, 'Cursor pagination should converge within expected page count')
-tests/pagination-cursor-multifield.test.js:192:    it.skip('should handle cursor pagination with numeric and text fields', async () => {
-tests/pagination-cursor-multifield.test.js:194:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:195:        queryParams: {
-tests/pagination-cursor-multifield.test.js:207:      const secondPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:208:        queryParams: {
-tests/pagination-cursor-multifield.test.js:211:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:225:    it.skip('should generate correct cursor values for multi-field sorting', async () => {
-tests/pagination-cursor-multifield.test.js:226:      const result = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:227:        queryParams: {
-tests/pagination-cursor-multifield.test.js:234:      // Check that cursor is present
-tests/pagination-cursor-multifield.test.js:235:      assert(result.meta.pagination.cursor?.next, 'Should have next cursor')
-tests/pagination-cursor-multifield.test.js:237:      // The cursor should be parseable (not throwing an error)
-tests/pagination-cursor-multifield.test.js:238:      const cursor = result.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:239:      assert(typeof cursor === 'string', 'Cursor should be a string')
-tests/pagination-cursor-multifield.test.js:243:      assert(cursor.includes('category:'), 'Cursor should include category field')
-tests/pagination-cursor-multifield.test.js:244:      assert(cursor.includes('name:'), 'Cursor should include name field')
-tests/pagination-cursor-multifield.test.js:249:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:250:        queryParams: {
-tests/pagination-cursor-multifield.test.js:257:      const secondPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:258:        queryParams: {
-tests/pagination-cursor-multifield.test.js:261:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:269:      const previousPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:270:        queryParams: {
-tests/pagination-cursor-multifield.test.js:273:            before: secondPage.meta.pagination.cursor?.next ||
-tests/pagination-cursor-multifield.test.js:274:                    // If no next cursor, create one from the last record
-tests/pagination-cursor-multifield.test.js:285:      assert(!secondPageIds.some(id => previousPageIds.includes(id)),
-tests/pagination-cursor-multifield.test.js:292:      await cleanTables(knex, ['cursor_products', 'cursor_items'])
-tests/pagination-cursor-multifield.test.js:315:      let cursor = null
-tests/pagination-cursor-multifield.test.js:318:        const result = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:319:          queryParams: {
-tests/pagination-cursor-multifield.test.js:322:              ...(cursor && { after: cursor })
-tests/pagination-cursor-multifield.test.js:331:        if (!result.meta.pagination.hasMore) {
-tests/pagination-cursor-multifield.test.js:334:        cursor = result.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:351:    it.skip('should handle empty results with multi-field cursor', async () => {
-tests/pagination-cursor-multifield.test.js:365:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:366:        queryParams: {
-tests/pagination-cursor-multifield.test.js:374:      assert.equal(firstPage.meta.pagination.hasMore, false)
-tests/pagination-cursor-multifield.test.js:375:      assert(!firstPage.meta.pagination.cursor?.next, 'Should not have next cursor on last page')
-tests/pagination-cursor-multifield.test.js:378:    it.skip('should handle special characters in multi-field cursors', async () => {
-tests/pagination-cursor-multifield.test.js:394:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:395:        queryParams: {
-tests/pagination-cursor-multifield.test.js:402:      assert(firstPage.meta.pagination.cursor?.next, 'Should have cursor')
-tests/pagination-cursor-multifield.test.js:404:      // Use the cursor to get next page - should not throw
-tests/pagination-cursor-multifield.test.js:405:      const secondPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:406:        queryParams: {
-tests/pagination-cursor-multifield.test.js:409:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:438:      const result = await api.resources.items.query({
-tests/pagination-cursor-multifield.test.js:439:        queryParams: {
-tests/pagination-cursor-multifield.test.js:451:      if (result.meta.pagination.cursor?.next) {
-tests/pagination-cursor-multifield.test.js:452:        const secondPage = await api.resources.items.query({
-tests/pagination-cursor-multifield.test.js:453:          queryParams: {
-tests/pagination-cursor-multifield.test.js:456:              after: result.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:469:      await cleanTables(knex, ['cursor_products'])
-tests/pagination-cursor-multifield.test.js:487:      const firstPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:488:        queryParams: {
-tests/pagination-cursor-multifield.test.js:499:      // Get second page - MUST include Date (the bug would skip it)
-tests/pagination-cursor-multifield.test.js:500:      const secondPage = await api.resources.products.query({
-tests/pagination-cursor-multifield.test.js:501:        queryParams: {
-tests/pagination-cursor-multifield.test.js:504:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-cursor-multifield.test.js:512:      assert(secondPageNames.includes('Date'),
-tests/pagination-cursor-multifield.test.js:513:        'Second page MUST include Date - this was the bug where it would be skipped')
-tests/ownership-optout.test.js:48:  it('ownerField:false - allows create+query without user_id column present', async () => {
-tests/ownership-optout.test.js:53:    const resultAuth = await api.resources.public_items_ownerfield.query({ simplified: false }, { auth: { userId: 1 } })
-tests/ownership-optout.test.js:58:    const resultNoAuth = await api.resources.public_items_ownerfield.query({ simplified: false })
-tests/ownership-optout.test.js:63:  it('ownership:false - allows create+query without user_id column present', async () => {
-tests/ownership-optout.test.js:67:    const resultAuth = await api.resources.public_items_ownership.query({ simplified: false }, { auth: { userId: 99 } })
-tests/ownership-optout.test.js:71:    const resultNoAuth = await api.resources.public_items_ownership.query({ simplified: false })
-tests/nested-includes.test.js:29:      name: 'test-nested-includes'
-tests/nested-includes.test.js:33:      queryDefaultLimit: 10,
-tests/nested-includes.test.js:34:      queryMaxLimit: 50,
-tests/nested-includes.test.js:64:          // Relationships are always includable via ?include=
-tests/nested-includes.test.js:83:          // Relationships are always includable via ?include=
-tests/nested-includes.test.js:84:          include: {
-tests/nested-includes.test.js:86:            strategy: 'window'
-tests/nested-includes.test.js:106:          // Relationships are always includable via ?include=
-tests/nested-includes.test.js:112:          // Relationships are always includable via ?include=
-tests/nested-includes.test.js:242:    it('should populate reverse relationships when using nested includes', async () => {
-tests/nested-includes.test.js:243:      const result = await api.resources.authors.query({
-tests/nested-includes.test.js:244:        queryParams: {
-tests/nested-includes.test.js:245:          include: ['books', 'books.authors']
-tests/nested-includes.test.js:253:      // Check that books are included
-tests/nested-includes.test.js:254:      const books = result.included.filter(r => r.type === 'books')
-tests/nested-includes.test.js:255:      assert.equal(books.length, 3, 'Should include 3 books')
-tests/nested-includes.test.js:257:      // Check that authors are included (for the books.authors include)
-tests/nested-includes.test.js:258:      const includedAuthors = result.included.filter(r => r.type === 'authors')
-tests/nested-includes.test.js:259:      assert.equal(includedAuthors.length, 2, 'Should include 2 authors')
-tests/nested-includes.test.js:279:    it('should work with window strategy limits', async () => {
-tests/nested-includes.test.js:280:      // Create more books to test window limits
-tests/nested-includes.test.js:281:      const publisher = await api.resources.publishers.query({ simplified: false })
-tests/nested-includes.test.js:285:      const authorsResult = await api.resources.authors.query({ simplified: false })
-tests/nested-includes.test.js:306:      const result = await api.resources.authors.query({
-tests/nested-includes.test.js:307:        queryParams: {
-tests/nested-includes.test.js:308:          include: ['books', 'books.authors'],
-tests/nested-includes.test.js:316:      // But window limit is 5, so should only get 5
-tests/nested-includes.test.js:321:      // The window limit should apply
-tests/nested-includes.test.js:324:      assert(bookCount <= 5, `Author 1 should have at most 5 books (window limit), got ${bookCount}`)
-tests/nested-includes.test.js:326:      // All included books should have their authors relationship populated
-tests/nested-includes.test.js:327:      const books = result.included.filter(r => r.type === 'books')
-tests/nested-includes.test.js:328:      assert(books.length >= 2, 'Should include at least 2 books')
-tests/nested-includes.test.js:405:    it('should handle 3+ levels of nested includes', async () => {
-tests/nested-includes.test.js:406:      const result = await api.resources.authors.query({
-tests/nested-includes.test.js:407:        queryParams: {
-tests/nested-includes.test.js:408:          include: ['books', 'books.publisher', 'books.publisher.country']
-tests/nested-includes.test.js:415:      // Check all resource types are included
-tests/nested-includes.test.js:416:      const books = result.included.filter(r => r.type === 'books')
-tests/nested-includes.test.js:417:      const publishers = result.included.filter(r => r.type === 'publishers')
-tests/nested-includes.test.js:418:      const countries = result.included.filter(r => r.type === 'countries')
-tests/nested-includes.test.js:420:      assert.equal(books.length, 2, 'Should include 2 books')
-tests/nested-includes.test.js:421:      assert.equal(publishers.length, 2, 'Should include 2 publishers')
-tests/nested-includes.test.js:422:      // All defined relationships will be included when requested via ?include=
-tests/nested-includes.test.js:435:      const result = await api.resources.publishers.query({
-tests/nested-includes.test.js:436:        queryParams: {
-tests/nested-includes.test.js:437:          include: ['books', 'books.authors', 'books.authors.country', 'country']
-tests/nested-includes.test.js:445:      const countries = result.included.filter(r => r.type === 'countries')
-tests/nested-includes.test.js:450:      const authors = result.included.filter(r => r.type === 'authors')
-tests/nested-includes.test.js:516:    it('should respect sparse fieldsets with nested includes', async () => {
-tests/nested-includes.test.js:517:      const result = await api.resources.authors.query({
-tests/nested-includes.test.js:518:        queryParams: {
-tests/nested-includes.test.js:519:          include: ['books', 'books.reviews'],
-tests/nested-includes.test.js:531:      // Check sparse fieldsets are applied
-tests/nested-includes.test.js:535:      const book = result.included.find(r => r.type === 'books')
-tests/nested-includes.test.js:536:      assert(book, 'Should include book')
-tests/nested-includes.test.js:541:      const review = result.included.find(r => r.type === 'reviews')
-tests/nested-includes.test.js:542:      assert(review, 'Should include review')
-tests/nested-includes.test.js:590:    it('should handle circular includes gracefully', async () => {
-tests/nested-includes.test.js:591:      const result = await api.resources.books.query({
-tests/nested-includes.test.js:592:        queryParams: {
-tests/nested-includes.test.js:593:          include: ['authors', 'authors.books', 'authors.books.authors']
-tests/nested-includes.test.js:601:      const books = result.data.concat(result.included.filter(r => r.type === 'books'))
-tests/nested-includes.test.js:602:      const authors = result.included.filter(r => r.type === 'authors')
-tests/positioning.test.js:226:      const { data: allTasks } = await api.resources.tasks.query({
-tests/positioning.test.js:227:        queryParams: {
-tests/positioning.test.js:532:      const { data: sorted } = await api.resources.tasks.query({
-tests/positioning.test.js:533:        queryParams: {
-tests/positioning.test.js:547:      const { data: reverseSorted } = await api.resources.tasks.query({
-tests/positioning.test.js:548:        queryParams: {
-tests/computed-fields.test.js:73:      // normallyHidden fields should not be included
-tests/computed-fields.test.js:110:        queryParams: {
-tests/computed-fields.test.js:119:      // Other fields should not be included
-tests/computed-fields.test.js:125:    it('should fetch dependencies but not include them in response', async () => {
-tests/computed-fields.test.js:128:        queryParams: {
-tests/computed-fields.test.js:136:      // Dependencies should not be included
-tests/computed-fields.test.js:144:        queryParams: {
-tests/computed-fields.test.js:160:        queryParams: {
-tests/computed-fields.test.js:168:      // Shared dependencies should not be included
-tests/computed-fields.test.js:175:    it('should compute fields in hasMany included resources', async () => {
-tests/computed-fields.test.js:178:        queryParams: {
-tests/computed-fields.test.js:179:          include: ['reviews']
-tests/computed-fields.test.js:195:    it('should apply sparse fieldsets to included resources with computed fields', async () => {
-tests/computed-fields.test.js:198:        queryParams: {
-tests/computed-fields.test.js:199:          include: ['reviews'],
-tests/computed-fields.test.js:216:      // Other fields should not be included
-tests/computed-fields.test.js:223:    it('should handle computed dependencies in included resources', async () => {
-tests/computed-fields.test.js:226:        queryParams: {
-tests/computed-fields.test.js:227:          include: ['reviews'],
-tests/computed-fields.test.js:238:      // Dependencies should not be included
-tests/computed-fields.test.js:247:      const products = await api.resources.products.query()
-tests/computed-fields.test.js:255:    it('should apply sparse fieldsets to collections', async () => {
-tests/computed-fields.test.js:256:      const products = await api.resources.products.query({
-tests/computed-fields.test.js:257:        queryParams: {
-tests/computed-fields.test.js:269:    it('should handle includes with computed fields in collections', async () => {
-tests/computed-fields.test.js:270:      const products = await api.resources.products.query({
-tests/computed-fields.test.js:271:        queryParams: {
-tests/computed-fields.test.js:272:          include: ['reviews'],
-tests/computed-fields.test.js:293:    it('should always include minimal relationship objects regardless of sparse fieldsets', async () => {
-tests/computed-fields.test.js:296:        queryParams: {
-tests/computed-fields.test.js:301:      // Minimal relationship objects should still be included
-tests/computed-fields.test.js:311:    it('should include empty arrays for empty relationships', async () => {
-tests/computed-fields.test.js:320:        queryParams: {
-tests/computed-fields.test.js:360:    it('should reject unknown fields in sparse fieldsets', async () => {
-tests/computed-fields.test.js:364:          queryParams: {
-tests/computed-fields.test.js:368:        /Unknown sparse field 'unknown_field'/
-tests/computed-fields.test.js:372:    it('should reject requests for _ids fields in sparse fieldsets', async () => {
-tests/computed-fields.test.js:376:          queryParams: {
-tests/computed-fields.test.js:380:        /Unknown sparse field 'reviews_ids'/
-tests/computed-fields.test.js:485:        queryParams: {
-tests/queries.test.js:126:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:127:        queryParams: {
-tests/queries.test.js:147:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:148:        queryParams: {
-tests/queries.test.js:163:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:164:        queryParams: {
-tests/queries.test.js:177:          await basicApi.resources.countries.query({
-tests/queries.test.js:178:            queryParams: {
-tests/queries.test.js:222:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:223:        queryParams: {
-tests/queries.test.js:237:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:238:        queryParams: {
-tests/queries.test.js:286:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:287:        queryParams: {
-tests/queries.test.js:356:      const page1 = await basicApi.resources.books.query({
-tests/queries.test.js:357:        queryParams: {
-tests/queries.test.js:371:      const page2 = await basicApi.resources.books.query({
-tests/queries.test.js:372:        queryParams: {
-tests/queries.test.js:388:      assert.equal(page1Ids.some(id => page2Ids.includes(id)), false, 'Pages should have different results')
-tests/queries.test.js:392:      const lastPage = await basicApi.resources.books.query({
-tests/queries.test.js:393:        queryParams: {
-tests/queries.test.js:406:      const emptyPage = await basicApi.resources.books.query({
-tests/queries.test.js:407:        queryParams: {
-tests/queries.test.js:417:    it('should respect queryMaxLimit limit', async () => {
-tests/queries.test.js:418:      // Assuming queryMaxLimit is 100 (from vars)
-tests/queries.test.js:419:      const result = await basicApi.resources.books.query({
-tests/queries.test.js:420:        queryParams: {
-tests/queries.test.js:427:      assert(result.data.length <= 100, 'Should not exceed queryMaxLimit')
-tests/queries.test.js:480:      const result = await extendedApi.resources.books.query({
-tests/queries.test.js:481:        queryParams: {
-tests/queries.test.js:497:    it('should filter and include relationships', async () => {
-tests/queries.test.js:498:      const result = await extendedApi.resources.books.query({
-tests/queries.test.js:499:        queryParams: {
-tests/queries.test.js:501:          include: ['country']
-tests/queries.test.js:509:      // Verify includes
-tests/queries.test.js:510:      assert(result.included, 'Should have included data')
-tests/queries.test.js:511:      const includedCountries = result.included.filter(r => r.type === 'countries')
-tests/queries.test.js:512:      assert(includedCountries.length >= 1, 'Should include at least one country')
-tests/queries.test.js:514:      // Verify included countries have the expected fields
-tests/queries.test.js:515:      for (const country of includedCountries) {
-tests/socketio.test.js:184:        assert(!notification.data, 'Should not include data in notification')
-tests/positioning-multifilter.test.js:101:      const { data: p1ActiveItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:102:        queryParams: {
-tests/positioning-multifilter.test.js:112:      const { data: p1ArchivedItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:113:        queryParams: {
-tests/positioning-multifilter.test.js:123:      const { data: p2ActiveItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:124:        queryParams: {
-tests/positioning-multifilter.test.js:173:      const { data: projectActiveItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:174:        queryParams: {
-tests/positioning-multifilter.test.js:182:      const { data: projectNullStatusItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:183:        queryParams: {
-tests/positioning-multifilter.test.js:191:      const { data: nullProjectActiveItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:192:        queryParams: {
-tests/positioning-multifilter.test.js:200:      const { data: bothNullItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:201:        queryParams: {
-tests/positioning-multifilter.test.js:243:      const { data: archivedItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:244:        queryParams: {
-tests/positioning-multifilter.test.js:262:      const { data: activeItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:263:        queryParams: {
-tests/positioning-multifilter.test.js:315:      const { data: p1Items } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:316:        queryParams: {
-tests/positioning-multifilter.test.js:327:      const { data: p2Items } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:328:        queryParams: {
-tests/positioning-multifilter.test.js:345:      const { data: p1ActiveItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:346:        queryParams: {
-tests/positioning-multifilter.test.js:355:      const { data: p1ArchivedItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:356:        queryParams: {
-tests/positioning-multifilter.test.js:408:          const { data: filtered } = await multiApi.resources.items.query({
-tests/positioning-multifilter.test.js:409:            queryParams: {
-tests/positioning-multifilter.test.js:438:      const { data: activeHighItems } = await multiApi.resources.items.query({
-tests/positioning-multifilter.test.js:439:        queryParams: {
-tests/positioning-multifilter.test.js:489:      const { data: activeItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:490:        queryParams: {
-tests/positioning-multifilter.test.js:548:      const { data: p1Active } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:549:        queryParams: {
-tests/positioning-multifilter.test.js:556:      const { data: p1Archived } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:557:        queryParams: {
-tests/positioning-multifilter.test.js:564:      const { data: p2Active } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:565:        queryParams: {
-tests/positioning-multifilter.test.js:572:      const { data: p2Archived } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:573:        queryParams: {
-tests/positioning-multifilter.test.js:622:      const { data: emptyStatusItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:623:        queryParams: {
-tests/positioning-multifilter.test.js:633:      const { data: nullStatusItems } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:634:        queryParams: {
-tests/positioning-multifilter.test.js:674:      const { data: status1Items } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:675:        queryParams: {
-tests/positioning-multifilter.test.js:687:      const { data: status01Items } = await api.resources.items.query({
-tests/positioning-multifilter.test.js:688:        queryParams: {
-tests/virtual-fields.test.js:176:    it('should respect sparse fieldsets with virtual fields on PATCH', async () => {
-tests/virtual-fields.test.js:179:        username: 'sparseuser',
-tests/virtual-fields.test.js:180:        email: 'sparse@example.com',
-tests/virtual-fields.test.js:206:        queryParams: {
-tests/virtual-fields.test.js:223:    it('should exclude virtual fields when not requested in sparse fieldsets', async () => {
-tests/virtual-fields.test.js:240:      // Fetch with sparse fieldsets NOT including virtual fields
-tests/virtual-fields.test.js:243:        queryParams: {
-tests/searchschema-merge.test.js:39:    // First do a query to trigger schema compilation
-tests/searchschema-merge.test.js:40:    await api.resources.products.query({
-tests/searchschema-merge.test.js:41:      queryParams: {}
-tests/searchschema-merge.test.js:75:    // Check that non-searchable fields are not included
-tests/searchschema-merge.test.js:80:    // First do a query to trigger schema compilation
-tests/searchschema-merge.test.js:81:    await api.resources.users.query({
-tests/searchschema-merge.test.js:82:      queryParams: {}
-tests/searchschema-merge.test.js:98:    // First do a query to trigger schema compilation
-tests/searchschema-merge.test.js:99:    await api.resources.orders.query({
-tests/searchschema-merge.test.js:100:      queryParams: {}
-tests/searchschema-merge.test.js:139:    const nameResults = await api.resources.products.query({
-tests/searchschema-merge.test.js:140:      queryParams: {
-tests/searchschema-merge.test.js:150:    const priceResults = await api.resources.products.query({
-tests/searchschema-merge.test.js:151:      queryParams: {
-tests/searchschema-merge.test.js:161:    const statusResults = await api.resources.products.query({
-tests/searchschema-merge.test.js:162:      queryParams: {
-tests/searchschema-merge.test.js:172:    const skuResults = await api.resources.products.query({
-tests/searchschema-merge.test.js:173:      queryParams: {
-tests/multihome.test.js:106:      const resultA = await api.resources.projects.query({
-tests/multihome.test.js:117:      const resultB = await api.resources.projects.query({
-tests/multihome.test.js:190:          return err.message.includes('must match current context')
-tests/multihome.test.js:257:      // Query with includes - should only see own tenant data
-tests/multihome.test.js:260:        queryParams: {
-tests/multihome.test.js:261:          include: ['tasks']
-tests/multihome.test.js:269:      assert(projectWithTasks.included, 'Should have included tasks')
-tests/multihome.test.js:270:      assert.equal(projectWithTasks.included.length, 1, 'Should include one task')
-tests/multihome.test.js:271:      assert.equal(projectWithTasks.included[0].attributes.tenant_id, 'tenant-a')
-tests/multihome.test.js:291:      const allSettings = await api.resources.system_settings.query({
-tests/multihome.test.js:322:          return err.message.includes('multihome context')
-tests/multihome.test.js:335:      assert(api.vars.multihome.excludeResources.includes('system_settings'))
-tests/multihome.test.js:376:      const adminsA = await api.resources.users.query({
-tests/multihome.test.js:377:        queryParams: {
-tests/multihome.test.js:389:      const usersB = await api.resources.users.query({
-tests/multihome.test.js:399:    it('should apply tenant filter with sorting and pagination', async () => {
-tests/multihome.test.js:425:      // Query with pagination as tenant A
-tests/multihome.test.js:426:      const page1 = await api.resources.projects.query({
-tests/multihome.test.js:427:        queryParams: {
-tests/multihome.test.js:441:      const page2 = await api.resources.projects.query({
-tests/multihome.test.js:442:        queryParams: {
-tests/multihome.test.js:460:          await api.resources.projects.query({
-tests/multihome.test.js:465:          return err.message.includes('No multihome context available')
-tests/multihome.test.js:549:        assert(err.code === 'REST_API_RESOURCE' || err.message.includes('Access denied'))
-tests/rest-api.test.js:129:          queryParams: {
-tests/rest-api.test.js:130:            include: ['country']
-tests/rest-api.test.js:142:        // Verify included data
-tests/rest-api.test.js:143:        assert(getResult.included, 'Should have included data')
-tests/rest-api.test.js:144:        assert.equal(getResult.included.length, 1, 'Should include one resource')
-tests/rest-api.test.js:145:        assert.equal(getResult.included[0].type, 'countries')
-tests/rest-api.test.js:146:        assert.equal(getResult.included[0].attributes.name, 'United Kingdom')
-tests/rest-api.test.js:235:        const queryResult = await basicApi.resources.countries.query({
-tests/rest-api.test.js:239:        validateJsonApiStructure(queryResult, true)
-tests/rest-api.test.js:240:        assert.equal(queryResult.data.length, 3, 'Should return 3 countries')
-tests/rest-api.test.js:243:        const names = queryResult.data.map(c => c.attributes.name).sort()
-tests/bulk-operations.test.js:76:      // Verify via API query
-tests/bulk-operations.test.js:77:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:78:      assert.equal(queryResult.data.length, 3, 'Should have 3 records via query')
-tests/bulk-operations.test.js:95:        assert(error.message.includes('validation failed') || error.message.includes('required'), 'Error should mention validation or required field')
-tests/bulk-operations.test.js:99:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:100:      assert.equal(queryResult.data.length, 0, 'Should have no records due to rollback')
-tests/bulk-operations.test.js:127:      assert(result.errors[0].error.message.includes('validation failed') || result.errors[0].error.message.includes('required'))
-tests/bulk-operations.test.js:130:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:131:      assert.equal(queryResult.data.length, 3)
-tests/bulk-operations.test.js:173:        assert(error.message.includes('limited to 100'))
-tests/bulk-operations.test.js:177:    it('should respect atomic query parameter override', async () => {
-tests/bulk-operations.test.js:406:      // Verify via API query
-tests/bulk-operations.test.js:407:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:408:      assert.equal(queryResult.data.length, 2, 'Should have 2 remaining records')
-tests/bulk-operations.test.js:411:      const remainingIds = queryResult.data.map(r => r.id)
-tests/bulk-operations.test.js:412:      assert(!remainingIds.includes(testData.authorIds[0]))
-tests/bulk-operations.test.js:413:      assert(remainingIds.includes(testData.authorIds[1]))
-tests/bulk-operations.test.js:414:      assert(!remainingIds.includes(testData.authorIds[2]))
-tests/bulk-operations.test.js:441:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:442:      assert.equal(queryResult.data.length, 2)
-tests/bulk-operations.test.js:463:      const queryResult = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:464:      assert.equal(queryResult.data.length, 5, 'Should still have all 5 records')
-tests/bulk-operations.test.js:474:        assert(error.message.includes('array'))
-tests/bulk-operations.test.js:550:      const queryResult = await api.resources.authors.query({
-tests/bulk-operations.test.js:552:        queryParams: { page: { size: 100 } }
-tests/bulk-operations.test.js:554:      assert.equal(queryResult.data.length, 50)
-tests/bulk-operations.test.js:611:      const finalQuery = await api.resources.authors.query({ simplified: false })
-tests/bulk-operations.test.js:615:      const seniorAuthors = finalQuery.data.filter(a => a.attributes.name.includes('Senior'))
-tests/bulk-operations.test.js:649:      const allPublishers = await api.resources.publishers.query({
-tests/polymorphic-simple.test.js:88:  it('should query all reviews', async () => {
-tests/polymorphic-simple.test.js:135:    const result = await api.resources.reviews.query({})
-tests/positioning-advanced.test.js:198:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:199:        queryParams: {
-tests/positioning-advanced.test.js:248:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:249:        queryParams: {
-tests/positioning-advanced.test.js:298:      const { data: items } = await api.resources.items.query({
-tests/positioning-advanced.test.js:299:        queryParams: {
-tests/positioning-advanced.test.js:342:      const { data: items } = await api.resources.items.query({
-tests/positioning-advanced.test.js:343:        queryParams: {
-tests/positioning-advanced.test.js:390:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:391:        queryParams: {
-tests/positioning-advanced.test.js:456:      const { data: finalTasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:457:        queryParams: {
-tests/positioning-advanced.test.js:502:      const { data: allTasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:503:        queryParams: {
-tests/positioning-advanced.test.js:518:      const { data: updatedTasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:519:        queryParams: {
-tests/positioning-advanced.test.js:551:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-advanced.test.js:552:        queryParams: {
-tests/positioning-advanced.test.js:603:      const { data: activeTasks } = await softDeleteApi.resources.tasks.query({
-tests/positioning-advanced.test.js:604:        queryParams: {
-tests/positioning-advanced.test.js:663:      const { data: v1Items } = await versionApi.resources.tasks.query({
-tests/positioning-advanced.test.js:664:        queryParams: {
-tests/positioning-advanced.test.js:676:      const { data: v2Items } = await versionApi.resources.tasks.query({
-tests/positioning-advanced.test.js:677:        queryParams: {
-tests/positioning-extended.test.js:77:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:78:        queryParams: {
-tests/positioning-extended.test.js:123:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:124:        queryParams: {
-tests/positioning-extended.test.js:155:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:156:        queryParams: {
-tests/positioning-extended.test.js:183:      const { data: cat2Tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:184:        queryParams: {
-tests/positioning-extended.test.js:229:      const { data: finalTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:230:        queryParams: {
-tests/positioning-extended.test.js:273:      const { data: cat1Tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:274:        queryParams: {
-tests/positioning-extended.test.js:284:      const { data: cat2Tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:285:        queryParams: {
-tests/positioning-extended.test.js:323:      const { data: allTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:324:        queryParams: {
-tests/positioning-extended.test.js:358:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:359:        queryParams: {
-tests/positioning-extended.test.js:405:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:406:        queryParams: {
-tests/positioning-extended.test.js:462:      const { data: ascTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:463:        queryParams: {
-tests/positioning-extended.test.js:473:      const { data: descTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:474:        queryParams: {
-tests/positioning-extended.test.js:484:    it('should handle pagination with position sorting', async () => {
-tests/positioning-extended.test.js:496:      const { data: page1 } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:497:        queryParams: {
-tests/positioning-extended.test.js:509:      const { data: page2 } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:510:        queryParams: {
-tests/positioning-extended.test.js:547:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:548:        queryParams: {
-tests/positioning-extended.test.js:590:      const { data: allTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:591:        queryParams: {
-tests/positioning-extended.test.js:655:      const { data: finalTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:656:        queryParams: {
-tests/positioning-extended.test.js:705:      const { data: tasksWithCat } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:706:        queryParams: {
-tests/positioning-extended.test.js:716:      const { data: tasksNoCat } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:717:        queryParams: {
-tests/positioning-extended.test.js:724:      const { data: allTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:725:        queryParams: {
-tests/positioning-extended.test.js:732:      // Try querying without filter
-tests/positioning-extended.test.js:733:      const { data: tasksNoFilter } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:734:        queryParams: {
-tests/positioning-extended.test.js:804:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:805:        queryParams: {
-tests/positioning-extended.test.js:832:      const { data: tasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:833:        queryParams: {
-tests/positioning-extended.test.js:855:      const { data: updatedTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:856:        queryParams: {
-tests/positioning-extended.test.js:894:      const { data: finalTasks } = await api.resources.tasks.query({
-tests/positioning-extended.test.js:895:        queryParams: {
-tests/rest-api-access.test.js:127:  it('filters query results by ownership for non-admin users', async () => {
-tests/rest-api-access.test.js:134:    const queryResult = await api.resources.projects.query({
-tests/rest-api-access.test.js:138:    validateJsonApiStructure(queryResult, true)
-tests/rest-api-access.test.js:139:    assert.equal(queryResult.data.length, 1)
-tests/rest-api-access.test.js:140:    assert.equal(queryResult.data[0].id, aliceProject.id)
-tests/rest-api-access.test.js:141:    assertResourceRelationship(queryResult.data[0], 'user', {
-tests/rest-api-access.test.js:154:    const adminQuery = await api.resources.projects.query({
-tests/includes.test.js:99:    it('should include single belongsTo relationship', async () => {
-tests/includes.test.js:102:        queryParams: {
-tests/includes.test.js:103:          include: ['publisher']
-tests/includes.test.js:110:      // Verify included array exists
-tests/includes.test.js:111:      assert(result.included, 'Should have included data')
-tests/includes.test.js:112:      assert.equal(result.included.length, 1, 'Should include one resource')
-tests/includes.test.js:114:      // Verify included publisher
-tests/includes.test.js:115:      const includedPublisher = result.included[0]
-tests/includes.test.js:116:      assert.equal(includedPublisher.type, 'publishers')
-tests/includes.test.js:117:      assert.equal(includedPublisher.id, testData.publisher.id)
-tests/includes.test.js:118:      assert.equal(includedPublisher.attributes.name, 'Test Publisher')
-tests/includes.test.js:121:    it('should include multiple relationships', async () => {
-tests/includes.test.js:124:        queryParams: {
-tests/includes.test.js:125:          include: ['publisher', 'authors', 'country']
-tests/includes.test.js:132:      // Verify included array
-tests/includes.test.js:133:      assert(result.included)
-tests/includes.test.js:134:      assert.equal(result.included.length, 4, 'Should include 4 resources (1 publisher + 2 authors + 1 country)')
-tests/includes.test.js:136:      // Verify each type is included
-tests/includes.test.js:137:      const includedTypes = result.included.map(r => r.type)
-tests/includes.test.js:138:      assert(includedTypes.includes('publishers'))
-tests/includes.test.js:139:      assert(includedTypes.includes('authors'))
-tests/includes.test.js:140:      assert(includedTypes.includes('countries'))
-tests/includes.test.js:143:      const authors = result.included.filter(r => r.type === 'authors')
-tests/includes.test.js:149:    it('should include relationships in collection queries', async () => {
-tests/includes.test.js:150:      const result = await basicApi.resources.books.query({
-tests/includes.test.js:151:        queryParams: {
-tests/includes.test.js:152:          include: ['publisher', 'country']
-tests/includes.test.js:162:      // Should have included resources
-tests/includes.test.js:163:      assert(result.included)
-tests/includes.test.js:164:      const includedTypes = result.included.map(r => r.type)
-tests/includes.test.js:165:      assert(includedTypes.includes('publishers'))
-tests/includes.test.js:166:      assert(includedTypes.includes('countries'))
-tests/includes.test.js:210:    it('should include nested relationships', async () => {
-tests/includes.test.js:213:        queryParams: {
-tests/includes.test.js:214:          include: ['publisher.country']
-tests/includes.test.js:221:      // Should include both publisher and its country
-tests/includes.test.js:222:      assert(result.included)
-tests/includes.test.js:223:      assert.equal(result.included.length, 2)
-tests/includes.test.js:226:      const publisher = result.included.find(r => r.type === 'publishers')
-tests/includes.test.js:227:      const country = result.included.find(r => r.type === 'countries')
-tests/includes.test.js:229:      assert(publisher, 'Should include publisher')
-tests/includes.test.js:230:      assert(country, 'Should include country')
-tests/includes.test.js:237:    it('should handle multiple nested includes', async () => {
-tests/includes.test.js:263:      // Query with multiple nested includes
-tests/includes.test.js:264:      const result = await basicApi.resources.books.query({
-tests/includes.test.js:265:        queryParams: {
-tests/includes.test.js:266:          include: ['publisher.country', 'authors', 'country']
-tests/includes.test.js:273:      // Should have all included resources
-tests/includes.test.js:274:      assert(result.included)
-tests/includes.test.js:275:      const includedTypes = result.included.map(r => r.type)
-tests/includes.test.js:276:      assert(includedTypes.includes('publishers'))
-tests/includes.test.js:277:      assert(includedTypes.includes('countries'))
-tests/includes.test.js:278:      assert(includedTypes.includes('authors'))
-tests/includes.test.js:281:      const countryResources = result.included.filter(r => r.type === 'countries')
-tests/includes.test.js:343:    it('should include relationships with sparse fieldsets', async () => {
-tests/includes.test.js:346:        queryParams: {
-tests/includes.test.js:347:          include: ['publisher', 'country'],
-tests/includes.test.js:362:      assert(!result.data.attributes.pages, 'Should not include pages')
-tests/includes.test.js:363:      assert(!result.data.attributes.price, 'Should not include price')
-tests/includes.test.js:365:      // Verify included resources have only requested fields
-tests/includes.test.js:366:      const publisher = result.included.find(r => r.type === 'publishers')
-tests/includes.test.js:368:      assert(!publisher.attributes.founded_year, 'Should not include founded_year')
-tests/includes.test.js:369:      assert(!publisher.attributes.website, 'Should not include website')
-tests/includes.test.js:371:      const country = result.included.find(r => r.type === 'countries')
-tests/includes.test.js:374:      assert(!country.attributes.capital, 'Should not include capital')
-tests/includes.test.js:375:      assert(!country.attributes.population, 'Should not include population')
-tests/relationship-endpoints.test.js:34:      includeExpress: true
-tests/relationship-endpoints.test.js:135:      // Verify through GET with include
-tests/relationship-endpoints.test.js:138:        queryParams: {
-tests/relationship-endpoints.test.js:139:          include: ['authors']
-tests/relationship-endpoints.test.js:144:      assert(getResult.included, 'Should have included data')
-tests/relationship-endpoints.test.js:145:      assert.equal(getResult.included.length, 2, 'Should include 2 authors')
-tests/field-setters.test.js:253:      // No records should be created - verify with query
-tests/field-setters.test.js:254:      const records = await api.resources.validated_data.query()
-tests/include-depth-validation.test.js:20:    // Initialize API with custom includeDepthLimit
-tests/include-depth-validation.test.js:23:        includeDepthLimit: 3 // Default is 3, but being explicit
-tests/include-depth-validation.test.js:85:    it('should allow includes within depth limit', async () => {
-tests/include-depth-validation.test.js:87:      const depth1 = await api.resources.publishers.query({
-tests/include-depth-validation.test.js:88:        queryParams: { include: ['country'] }
-tests/include-depth-validation.test.js:91:      assert(depth1.included, 'Should have included resources')
-tests/include-depth-validation.test.js:94:      const depth2 = await api.resources.authors.query({
-tests/include-depth-validation.test.js:95:        queryParams: { include: ['publisher.country'] }
-tests/include-depth-validation.test.js:98:      // The included array may or may not be present depending on whether relationships exist
-tests/include-depth-validation.test.js:101:      const depth3 = await api.resources.books.query({
-tests/include-depth-validation.test.js:102:        queryParams: { include: ['publisher.country.publishers'] }
-tests/include-depth-validation.test.js:105:      // Note: The included array might be present even if some relationships don't have data
-tests/include-depth-validation.test.js:108:    it('should reject includes exceeding depth limit', async () => {
-tests/include-depth-validation.test.js:111:          await api.resources.books.query({
-tests/include-depth-validation.test.js:112:            queryParams: { include: ['publisher.country.publishers.books'] }
-tests/include-depth-validation.test.js:124:          await api.resources.books.query({
-tests/include-depth-validation.test.js:125:            queryParams: { include: ['publisher.country.publishers.books.authors'] }
-tests/include-depth-validation.test.js:136:    it('should validate each include path independently', async () => {
-tests/include-depth-validation.test.js:139:          await api.resources.books.query({
-tests/include-depth-validation.test.js:140:            queryParams: {
-tests/include-depth-validation.test.js:141:              include: [
-tests/include-depth-validation.test.js:159:    it('should allow includes within depth limit', async () => {
-tests/include-depth-validation.test.js:160:      const books = await api.resources.books.query()
-tests/include-depth-validation.test.js:166:        queryParams: { include: ['publisher'] }
-tests/include-depth-validation.test.js:169:      assert(depth1.included, 'Should have included resources')
-tests/include-depth-validation.test.js:174:        queryParams: { include: ['publisher.country.publishers'] }
-tests/include-depth-validation.test.js:179:    it('should reject includes exceeding depth limit', async () => {
-tests/include-depth-validation.test.js:180:      const books = await api.resources.books.query()
-tests/include-depth-validation.test.js:187:            queryParams: { include: ['publisher.country.publishers.books'] }
-tests/include-depth-validation.test.js:200:    it('should respect custom includeDepthLimit configuration', async () => {
-tests/include-depth-validation.test.js:243:      const depth2 = await limitedApi.resources.authors.query({
-tests/include-depth-validation.test.js:244:        queryParams: { include: ['publisher.country'] }
-tests/include-depth-validation.test.js:251:          await limitedApi.resources.books.query({
-tests/include-depth-validation.test.js:252:            queryParams: { include: ['publisher.country.publishers'] }
-tests/include-depth-validation.test.js:265:    it('should handle empty include arrays', async () => {
-tests/include-depth-validation.test.js:266:      const result = await api.resources.books.query({
-tests/include-depth-validation.test.js:267:        queryParams: { include: [] }
-tests/include-depth-validation.test.js:270:      assert(!result.included, 'Should not have included resources')
-tests/include-depth-validation.test.js:308:      const result = await api.resources.books.query({
-tests/include-depth-validation.test.js:309:        queryParams: { include: ['publisher'] }
-tests/include-depth-validation.test.js:312:      assert(result.included, 'Should have included resources')
-tests/include-depth-validation.test.js:319:          await api.resources.books.query({
-tests/include-depth-validation.test.js:320:            queryParams: { include: ['a.b.c.d'] }
-tests/polymorphic-relationships.test.js:158:    it('should query reviews and include polymorphic reviewable resource', async () => {
-tests/polymorphic-relationships.test.js:186:      // Query reviews with include
-tests/polymorphic-relationships.test.js:187:      const result = await api.resources.reviews.query({
-tests/polymorphic-relationships.test.js:188:        queryParams: {
-tests/polymorphic-relationships.test.js:189:          include: ['reviewable']
-tests/polymorphic-relationships.test.js:197:      // Check included resources
-tests/polymorphic-relationships.test.js:198:      assert(result.included)
-tests/polymorphic-relationships.test.js:199:      assert.equal(result.included.length, 1)
-tests/polymorphic-relationships.test.js:200:      assert.equal(result.included[0].type, 'books')
-tests/polymorphic-relationships.test.js:201:      assert.equal(result.included[0].id, book.data.id)
-tests/polymorphic-relationships.test.js:202:      assert.equal(result.included[0].attributes.title, 'Test Book for Review')
-tests/polymorphic-relationships.test.js:205:    it('should handle mixed polymorphic types in a single query', async () => {
-tests/polymorphic-relationships.test.js:251:      // Query all reviews with includes
-tests/polymorphic-relationships.test.js:252:      const result = await api.resources.reviews.query({
-tests/polymorphic-relationships.test.js:253:        queryParams: {
-tests/polymorphic-relationships.test.js:254:          include: ['reviewable']
-tests/polymorphic-relationships.test.js:261:      // Check included resources
-tests/polymorphic-relationships.test.js:262:      assert(result.included)
-tests/polymorphic-relationships.test.js:263:      assert.equal(result.included.length, 2)
-tests/polymorphic-relationships.test.js:265:      // Find each type in included
-tests/polymorphic-relationships.test.js:266:      const includedBook = result.included.find(r => r.type === 'books')
-tests/polymorphic-relationships.test.js:267:      const includedAuthor = result.included.find(r => r.type === 'authors')
-tests/polymorphic-relationships.test.js:269:      assert(includedBook)
-tests/polymorphic-relationships.test.js:270:      assert.equal(includedBook.attributes.title, 'German Book')
-tests/polymorphic-relationships.test.js:272:      assert(includedAuthor)
-tests/polymorphic-relationships.test.js:273:      assert.equal(includedAuthor.attributes.name, 'German Author')
-tests/polymorphic-relationships.test.js:285:    it('should query books and include their reviews', async () => {
-tests/polymorphic-relationships.test.js:328:        queryParams: {
-tests/polymorphic-relationships.test.js:329:          include: ['reviews']
-tests/polymorphic-relationships.test.js:336:      // Check included reviews
-tests/polymorphic-relationships.test.js:337:      console.log('Result included:', JSON.stringify(result.included, null, 2))
-tests/polymorphic-relationships.test.js:338:      assert(result.included)
-tests/polymorphic-relationships.test.js:339:      assert.equal(result.included.length, 2)
-tests/polymorphic-relationships.test.js:340:      assert(result.included.every(r => r.type === 'reviews'))
-tests/polymorphic-relationships.test.js:341:      assert(result.included.every(r =>
-tests/relationships.test.js:83:      // Verify through GET with include
-tests/relationships.test.js:86:        queryParams: {
-tests/relationships.test.js:87:          include: ['country']
-tests/relationships.test.js:93:      assert(getResult.included, 'Should have included data')
-tests/relationships.test.js:94:      assert.equal(getResult.included.length, 1)
-tests/relationships.test.js:95:      assert.equal(getResult.included[0].type, 'countries')
-tests/relationships.test.js:96:      assert.equal(getResult.included[0].attributes.name, 'United States')
-tests/relationships.test.js:145:        queryParams: { include: ['country'] },
-tests/relationships.test.js:151:      assert.equal(getResult.included[0].attributes.code, 'UK')
-tests/relationships.test.js:256:      // GET book with authors included
-tests/relationships.test.js:259:        queryParams: { include: ['authors'] },
-tests/relationships.test.js:267:      // Verify included authors
-tests/relationships.test.js:268:      assert(getResult.included)
-tests/relationships.test.js:269:      assert.equal(getResult.included.length, 2)
-tests/relationships.test.js:270:      const authorNames = getResult.included.map(a => a.attributes.name).sort()
-tests/relationships.test.js:348:        queryParams: { include: ['authors'] },
-tests/relationships.test.js:419:        queryParams: { include: ['authors'] },
-tests/relationships.test.js:501:        queryParams: { include: ['authors'] },
-tests/relationships.test.js:565:      // Verify with full includes
-tests/relationships.test.js:568:        queryParams: {
-tests/relationships.test.js:569:          include: ['publisher', 'publisher.country', 'authors', 'country']
-tests/relationships.test.js:581:      // Verify included resources
-tests/relationships.test.js:582:      assert(getResult.included)
-tests/relationships.test.js:583:      const includedTypes = getResult.included.map(r => r.type)
-tests/relationships.test.js:584:      assert(includedTypes.includes('publishers'))
-tests/relationships.test.js:585:      assert(includedTypes.includes('authors'))
-tests/relationships.test.js:586:      assert(includedTypes.includes('countries'))
-tests/relationships.test.js:589:      const publisher = getResult.included.find(r => r.type === 'publishers')
-tests/relationships.test.js:669:        queryParams: { include: ['publisher', 'authors'] },
-tests/TEST_TEMPLATE.test.js:49: * 1. NEVER query the database directly with knex('table').select()
-tests/TEST_TEMPLATE.test.js:52: *    - Use api.resources.[resource].query() to fetch multiple items
-tests/field-getters.test.js:119:    it('should work with sparse fieldsets', async () => {
-tests/field-getters.test.js:127:      // Fetch with sparse fieldsets
-tests/field-getters.test.js:128:      const sparse = await api.resources.products.get({
-tests/field-getters.test.js:130:        queryParams: {
-tests/field-getters.test.js:135:      assert.equal(sparse.name, 'ANOTHER WIDGET')
-tests/field-getters.test.js:136:      assert.ok(Math.abs(sparse.total_price - 55) < 0.0001, `Expected total_price to be ~55, got ${sparse.total_price}`)
-tests/field-getters.test.js:137:      assert.equal(sparse.description, undefined)
-tests/field-getters.test.js:138:      assert.equal(sparse.price_str, undefined)
-tests/field-getters.test.js:223:    it('should apply getters to included resources', async () => {
-tests/field-getters.test.js:244:      // Fetch with includes
-tests/field-getters.test.js:247:        queryParams: {
-tests/field-getters.test.js:248:          include: ['reviews']
-tests/field-getters.test.js:255:      // Review getters should apply to included resources
-tests/field-getters.test.js:261:    it('should work with sparse fieldsets on included resources', async () => {
-tests/field-getters.test.js:277:        queryParams: {
-tests/field-getters.test.js:278:          include: ['reviews'],
-tests/pagination-enhanced.test.js:27:    // Initialize API once with pagination features
-tests/pagination-enhanced.test.js:39:        'pagination_countries', 'pagination_publishers', 'pagination_books'
-tests/pagination-enhanced.test.js:63:      const list = await api.resources.books.query({ simplified: false })
-tests/pagination-enhanced.test.js:79:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:80:        queryParams: {},
-tests/pagination-enhanced.test.js:98:    it('should add self links to included resources', async () => {
-tests/pagination-enhanced.test.js:99:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:100:        queryParams: {
-tests/pagination-enhanced.test.js:101:          include: ['country']
-tests/pagination-enhanced.test.js:107:      assert(result.included, 'Should have included resources')
-tests/pagination-enhanced.test.js:109:      result.included.forEach(resource => {
-tests/pagination-enhanced.test.js:118:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:119:        queryParams: {},
-tests/pagination-enhanced.test.js:139:        'pagination_countries', 'pagination_publishers', 'pagination_books'
-tests/pagination-enhanced.test.js:149:      // Create 10 books for pagination testing
-tests/pagination-enhanced.test.js:162:    it('should include pagination metadata in response', async () => {
-tests/pagination-enhanced.test.js:163:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:164:        queryParams: {
-tests/pagination-enhanced.test.js:172:      assert(result.meta.pagination, 'Meta should have pagination')
-tests/pagination-enhanced.test.js:174:      const pagination = result.meta.pagination
-tests/pagination-enhanced.test.js:175:      assert.equal(pagination.page, 2)
-tests/pagination-enhanced.test.js:176:      assert.equal(pagination.pageSize, 3)
-tests/pagination-enhanced.test.js:177:      assert.equal(pagination.total, 10)
-tests/pagination-enhanced.test.js:178:      assert.equal(pagination.pageCount, 4)
-tests/pagination-enhanced.test.js:179:      assert.equal(pagination.hasMore, true)
-tests/pagination-enhanced.test.js:183:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:184:        queryParams: {
-tests/pagination-enhanced.test.js:190:      assert.equal(result.meta.pagination.hasMore, false)
-tests/pagination-enhanced.test.js:191:      assert.equal(result.meta.pagination.page, 4)
-tests/pagination-enhanced.test.js:192:      assert.equal(result.meta.pagination.pageCount, 4)
-tests/pagination-enhanced.test.js:195:    it('should include pagination links', async () => {
-tests/pagination-enhanced.test.js:196:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:197:        queryParams: {
-tests/pagination-enhanced.test.js:211:      assert(result.links.self.includes('page[number]=2'))
-tests/pagination-enhanced.test.js:212:      assert(result.links.self.includes('page[size]=3'))
-tests/pagination-enhanced.test.js:213:      assert(result.links.first.includes('page[number]=1'))
-tests/pagination-enhanced.test.js:214:      assert(result.links.last.includes('page[number]=4'))
-tests/pagination-enhanced.test.js:215:      assert(result.links.prev.includes('page[number]=1'))
-tests/pagination-enhanced.test.js:216:      assert(result.links.next.includes('page[number]=3'))
-tests/pagination-enhanced.test.js:219:    it('should not include prev link on first page', async () => {
-tests/pagination-enhanced.test.js:220:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:221:        queryParams: {
-tests/pagination-enhanced.test.js:232:    it('should not include next link on last page', async () => {
-tests/pagination-enhanced.test.js:233:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:234:        queryParams: {
-tests/pagination-enhanced.test.js:245:    it('should preserve other query parameters in pagination links', async () => {
-tests/pagination-enhanced.test.js:246:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:247:        queryParams: {
-tests/pagination-enhanced.test.js:256:      assert(result.links.next.includes('sort=-title'))
-tests/pagination-enhanced.test.js:257:      assert(result.links.next.includes('page[number]=3'))
-tests/pagination-enhanced.test.js:258:      assert(result.links.next.includes('page[size]=3'))
-tests/pagination-enhanced.test.js:265:        'pagination_countries', 'pagination_publishers', 'pagination_books'
-tests/pagination-enhanced.test.js:290:    it('should support cursor-based pagination with after parameter', async () => {
-tests/pagination-enhanced.test.js:292:      const firstPage = await api.resources.books.query({
-tests/pagination-enhanced.test.js:293:        queryParams: {
-tests/pagination-enhanced.test.js:302:      assert(firstPage.meta.pagination.hasMore)
-tests/pagination-enhanced.test.js:303:      assert(firstPage.meta.pagination.cursor?.next)
-tests/pagination-enhanced.test.js:305:      // Get next page using cursor
-tests/pagination-enhanced.test.js:306:      const secondPage = await api.resources.books.query({
-tests/pagination-enhanced.test.js:307:        queryParams: {
-tests/pagination-enhanced.test.js:310:            after: firstPage.meta.pagination.cursor.next
-tests/pagination-enhanced.test.js:323:      assert(!firstPageIds.some(id => secondPageIds.includes(id)), 'Pages should have different records')
-tests/pagination-enhanced.test.js:326:    it('should include cursor pagination links', async () => {
-tests/pagination-enhanced.test.js:327:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:328:        queryParams: {
-tests/pagination-enhanced.test.js:338:      assert(result.links.next.includes('page[after]='), 'Next link should include cursor parameter')
-tests/pagination-enhanced.test.js:341:    it('should handle last page with cursor pagination', async () => {
-tests/pagination-enhanced.test.js:348:        result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:349:          queryParams: {
-tests/pagination-enhanced.test.js:358:        if (result.meta.pagination.cursor?.next) {
-tests/pagination-enhanced.test.js:359:          currentCursor = result.meta.pagination.cursor.next
-tests/pagination-enhanced.test.js:363:      // Last page should have no next cursor
-tests/pagination-enhanced.test.js:364:      assert.equal(result.meta.pagination.hasMore, false)
-tests/pagination-enhanced.test.js:365:      assert(!result.meta.pagination.cursor?.next)
-tests/pagination-enhanced.test.js:373:        'pagination_countries', 'pagination_publishers', 'pagination_books'
-tests/pagination-enhanced.test.js:396:    it('should include count by default', async () => {
-tests/pagination-enhanced.test.js:397:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:398:        queryParams: {
-tests/pagination-enhanced.test.js:404:      assert(result.meta.pagination.total !== undefined)
-tests/pagination-enhanced.test.js:405:      assert.equal(result.meta.pagination.total, 20)
-tests/pagination-enhanced.test.js:406:      assert.equal(result.meta.pagination.pageCount, 4)
-tests/pagination-enhanced.test.js:415:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:416:        queryParams: {
-tests/pagination-enhanced.test.js:422:      assert(result.meta.pagination)
-tests/pagination-enhanced.test.js:423:      assert.equal(result.meta.pagination.page, 1)
-tests/pagination-enhanced.test.js:424:      assert.equal(result.meta.pagination.pageSize, 5)
-tests/pagination-enhanced.test.js:425:      assert(result.meta.pagination.total === undefined, 'Should not include total when counts disabled')
-tests/pagination-enhanced.test.js:426:      assert(result.meta.pagination.pageCount === undefined, 'Should not include pageCount when counts disabled')
-tests/pagination-enhanced.test.js:427:      assert(result.meta.pagination.hasMore === undefined, 'Should not include hasMore when counts disabled')
-tests/pagination-enhanced.test.js:439:        'pagination_countries', 'pagination_publishers', 'pagination_books'
-tests/pagination-enhanced.test.js:472:    it('should combine pagination with filtering and includes', async () => {
-tests/pagination-enhanced.test.js:473:      const result = await api.resources.books.query({
-tests/pagination-enhanced.test.js:474:        queryParams: {
-tests/pagination-enhanced.test.js:479:          include: ['country'],
-tests/pagination-enhanced.test.js:487:      // Check pagination worked
-tests/pagination-enhanced.test.js:489:      assert.equal(result.meta.pagination.total, 8)
-tests/pagination-enhanced.test.js:490:      assert.equal(result.meta.pagination.pageCount, 2)
-tests/pagination-enhanced.test.js:496:      // Check includes worked
-tests/pagination-enhanced.test.js:497:      assert(result.included)
-tests/pagination-enhanced.test.js:498:      const usCountry = result.included.find(r => r.type === 'countries' && r.attributes.code === 'US')
-tests/pagination-enhanced.test.js:506:      // Check pagination links include all parameters
-tests/pagination-enhanced.test.js:507:      assert(result.links.next.includes(`filters[country]=${usCountryId}`))
-tests/pagination-enhanced.test.js:508:      assert(result.links.next.includes('include=country'))
-tests/pagination-enhanced.test.js:509:      assert(result.links.next.includes('sort=title'))
-tests/query-limits.test.js:34:      queryDefaultLimit: 10,
-tests/query-limits.test.js:35:      queryMaxLimit: 50,
-tests/query-limits.test.js:68:          // Relationships are always includable via ?include=
-tests/query-limits.test.js:69:          include: {
-tests/query-limits.test.js:70:            strategy: 'window'  // Use window strategy for per-publisher limits
-tests/query-limits.test.js:90:          // Relationships are always includable via ?include=
-tests/query-limits.test.js:91:          include: {
-tests/query-limits.test.js:93:            strategy: 'window'
-tests/query-limits.test.js:113:          // Relationships are always includable via ?include=
-tests/query-limits.test.js:164:    it('should apply queryDefaultLimit when no page size specified', async () => {
-tests/query-limits.test.js:176:      const result = await api.resources.countries.query({
-tests/query-limits.test.js:177:        queryParams: {},
-tests/query-limits.test.js:181:      // Should use queryDefaultLimit of 10
-tests/query-limits.test.js:185:    it('should respect queryMaxLimit when page size exceeds it', async () => {
-tests/query-limits.test.js:196:      // Query with page size exceeding max (use offset-based pagination)
-tests/query-limits.test.js:197:      const result = await api.resources.countries.query({
-tests/query-limits.test.js:198:        queryParams: {
-tests/query-limits.test.js:199:          page: { size: 100, number: 1 }  // Exceeds queryMaxLimit of 50
-tests/query-limits.test.js:204:      // Should be capped at queryMaxLimit of 50
-tests/query-limits.test.js:205:      assert.equal(result.data.length, 50, 'Should cap at queryMaxLimit of 50')
-tests/query-limits.test.js:239:    it('should apply default limit to hasMany includes when not specified', async () => {
-tests/query-limits.test.js:240:      // Query publishers with books (no explicit limit in include config)
-tests/query-limits.test.js:241:      const result = await api.resources.publishers.query({
-tests/query-limits.test.js:242:        queryParams: {
-tests/query-limits.test.js:243:          include: ['books']
-tests/query-limits.test.js:252:      const publisherBooks = (result.included || []).filter(r => r.type === 'books')
-tests/query-limits.test.js:254:      // Should apply queryDefaultLimit of 10
-tests/query-limits.test.js:255:      assert.equal(publisherBooks.length, 10, 'Should include only 10 books by default')
-tests/query-limits.test.js:304:      const result = await api.resources.authors.query({
-tests/query-limits.test.js:305:        queryParams: {
-tests/query-limits.test.js:306:          include: ['books']
-tests/query-limits.test.js:311:      const authorBooks = result.included.filter(r => r.type === 'books')
-tests/query-limits.test.js:375:    it('should apply default limit to polymorphic hasMany includes', async () => {
-tests/query-limits.test.js:377:      const result = await api.resources.books.query({
-tests/query-limits.test.js:378:        queryParams: {
-tests/query-limits.test.js:379:          include: ['reviews']
-tests/query-limits.test.js:384:      // Without window strategy, the default strategy will limit total reviews
-tests/query-limits.test.js:385:      const totalReviews = result.included.filter(r => r.type === 'reviews')
-tests/query-limits.test.js:387:      // Should apply queryDefaultLimit of 10 to total reviews
-tests/query-limits.test.js:393:    it('should throw error when include limit exceeds queryMaxLimit at resource definition', async () => {
-tests/query-limits.test.js:398:        queryDefaultLimit: 5,
-tests/query-limits.test.js:399:        queryMaxLimit: 20,
-tests/query-limits.test.js:408:      // Try to create a resource with include limit exceeding max
-tests/query-limits.test.js:421:                include: {
-tests/query-limits.test.js:422:                  limit: 25  // Exceeds queryMaxLimit of 20
-tests/query-limits.test.js:429:          return err.message && err.message.includes('limit') && err.message.includes('exceeds queryMaxLimit')
-tests/query-limits.test.js:431:        'Should throw error for excessive include limit'
-tests/query-limits.test.js:478:    it('should apply per-parent limits with window strategy', async () => {
-tests/query-limits.test.js:479:      // Query all publishers with books (window strategy configured)
-tests/query-limits.test.js:480:      const result = await api.resources.publishers.query({
-tests/query-limits.test.js:481:        queryParams: {
-tests/query-limits.test.js:482:          include: ['books']
-tests/query-limits.test.js:489:        const publisherBooks = result.included.filter(r =>
-tests/query-limits.test.js:494:        // Each publisher gets up to queryDefaultLimit (10) books
-tests/query-limits.test.js:496:          `Publisher ${publisher.id} should have at most 10 books with window strategy`)
-tests/query-limits.test.js:499:      // Total books can exceed queryDefaultLimit since each parent gets its own limit
-tests/query-limits.test.js:500:      const totalBooks = result.included.filter(r => r.type === 'books').length
-tests/query-limits.test.js:501:      assert(totalBooks > 10, 'Total books should exceed 10 with window strategy')
-tests/query-limits.test.js:508:    it('should apply window limits to many-to-many relationships', async () => {
-tests/query-limits.test.js:559:      // Query authors with books (configured with limit: 3, strategy: window)
-tests/query-limits.test.js:560:      const result = await api.resources.authors.query({
-tests/query-limits.test.js:561:        queryParams: {
-tests/query-limits.test.js:562:          include: ['books']
-tests/query-limits.test.js:572:        // Verify the books exist in the included array
-tests/query-limits.test.js:573:        const authorBooks = result.included.filter(r =>
-tests/query-limits.test.js:574:          r.type === 'books' && authorBookIds.includes(r.id)
-tests/query-limits.test.js:580:          `Author ${author.id} should have exactly 3 books in included array`)