json-rest-api 1.0.14 → 1.0.16

package/tests/queries.test.js

@@ -1,7 +1,7 @@
-import { describe, it, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import knexLib from 'knex';
-import { createBasicApi, createExtendedApi } from './fixtures/api-configs.js';
+import { describe, it, before, beforeEach, after } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { createBasicApi, createExtendedApi } from './fixtures/api-configs.js'
 import {
   validateJsonApiStructure,
   resourceIdentifier,
@@ -12,7 +12,7 @@ import {
   createToManyRelationship,
   assertResourceAttributes,
   assertResourceRelationship
-} from './helpers/test-utils.js';
+} from './helpers/test-utils.js'
 
 // Create Knex instance for tests
 const knex = knexLib({
@@ -21,75 +21,75 @@ const knex = knexLib({
     filename: ':memory:'
   },
   useNullAsDefault: true
-});
+})
 
 // API instances that persist across tests
-let basicApi;
-let extendedApi;
+let basicApi
+let extendedApi
 
 describe('Query Operations', () => {
   before(async () => {
     // Initialize APIs once
-    basicApi = await createBasicApi(knex);
-    extendedApi = await createExtendedApi(knex);
-  });
+    basicApi = await createBasicApi(knex)
+    extendedApi = await createExtendedApi(knex)
+  })
 
   after(async () => {
     // Close database connection to allow tests to exit
-    await knex.destroy();
-  });
+    await knex.destroy()
+  })
 
   describe('Filtering', () => {
-    let testData = {};
+    const testData = {}
 
     beforeEach(async () => {
       // Clean all tables
       await cleanTables(knex, [
         'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
-      ]);
+      ])
 
       // Create test data set
       // Create 3 countries
-      const countries = [];
+      const countries = []
       for (const [name, code] of [['United States', 'US'], ['United Kingdom', 'UK'], ['France', 'FR']]) {
-        const doc = createJsonApiDocument('countries', { name, code });
+        const doc = createJsonApiDocument('countries', { name, code })
         const result = await basicApi.resources.countries.post({
           inputRecord: doc,
           simplified: false
-        });
-        countries.push(result.data);
+        })
+        countries.push(result.data)
       }
-      testData.countries = countries;
+      testData.countries = countries
 
       // Create 2 publishers per country
-      const publishers = [];
-      let pubIndex = 0;
+      const publishers = []
+      let pubIndex = 0
       for (const country of countries) {
         for (let i = 0; i < 2; i++) {
           const doc = createJsonApiDocument('publishers',
             { name: `Publisher ${++pubIndex}` },
             { country: createRelationship(resourceIdentifier('countries', country.id)) }
-          );
+          )
           const result = await basicApi.resources.publishers.post({
             inputRecord: doc,
             simplified: false
-          });
-          publishers.push({ ...result.data, countryId: country.id });
+          })
+          publishers.push({ ...result.data, countryId: country.id })
         }
       }
-      testData.publishers = publishers;
+      testData.publishers = publishers
 
       // Create 3 authors
-      const authors = [];
+      const authors = []
       for (const name of ['Author One', 'Author Two', 'Author Three']) {
-        const doc = createJsonApiDocument('authors', { name });
+        const doc = createJsonApiDocument('authors', { name })
         const result = await basicApi.resources.authors.post({
           inputRecord: doc,
           simplified: false
-        });
-        authors.push(result.data);
+        })
+        authors.push(result.data)
       }
-      testData.authors = authors;
+      testData.authors = authors
 
       // Create 5 books with various relationships
       const books = [
@@ -98,9 +98,9 @@ describe('Query Operations', () => {
         { title: 'Book C', countryId: countries[1].id, publisherId: publishers[2].id, authorIds: [authors[1].id] },
         { title: 'Book D', countryId: countries[1].id, publisherId: publishers[3].id, authorIds: [authors[2].id] },
         { title: 'Book E', countryId: countries[2].id, publisherId: publishers[4].id, authorIds: [authors[0].id, authors[2].id] }
-      ];
+      ]
 
-      testData.books = [];
+      testData.books = []
       for (const bookData of books) {
         const doc = createJsonApiDocument('books',
           {
@@ -113,14 +113,14 @@ describe('Query Operations', () => {
               bookData.authorIds.map(id => resourceIdentifier('authors', id))
             )
           }
-        );
+        )
         const result = await basicApi.resources.books.post({
           inputRecord: doc,
           simplified: false
-        });
-        testData.books.push(result.data);
+        })
+        testData.books.push(result.data)
       }
-    });
+    })
 
     it('should filter by simple field', async () => {
       const result = await basicApi.resources.books.query({
@@ -128,20 +128,20 @@ describe('Query Operations', () => {
           filters: { country: testData.countries[0].id }
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 2, 'Should return 2 books from US')
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 2, 'Should return 2 books from US');
-      
       // Verify all returned books are from the correct country
       for (const book of result.data) {
-        const bookData = testData.books.find(b => b.id === book.id);
-        assert(bookData);
-        const originalBook = testData.books.find(b => b.id === book.id);
-        assert.equal(originalBook.attributes.title.startsWith('Book A') || 
-                    originalBook.attributes.title.startsWith('Book B'), true);
+        const bookData = testData.books.find(b => b.id === book.id)
+        assert(bookData)
+        const originalBook = testData.books.find(b => b.id === book.id)
+        assert.equal(originalBook.attributes.title.startsWith('Book A') ||
+                    originalBook.attributes.title.startsWith('Book B'), true)
       }
-    });
+    })
 
     it('should filter by multiple fields', async () => {
       const result = await basicApi.resources.books.query({
@@ -152,12 +152,12 @@ describe('Query Operations', () => {
           }
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 1, 'Should return 1 book matching both filters');
-      assert.equal(result.data[0].attributes.title, 'Book A');
-    });
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 1, 'Should return 1 book matching both filters')
+      assert.equal(result.data[0].attributes.title, 'Book A')
+    })
 
     it('should return empty array when no matches', async () => {
       const result = await basicApi.resources.books.query({
@@ -165,11 +165,11 @@ describe('Query Operations', () => {
           filters: { country: 99999 }
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 0, 'Should return empty array');
-    });
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 0, 'Should return empty array')
+    })
 
     it('should throw error when filtering on non-searchable field', async () => {
       await assert.rejects(
@@ -179,44 +179,44 @@ describe('Query Operations', () => {
               filters: { invalid_field: 'test' }
             },
             simplified: false
-          });
+          })
         },
         (err) => {
-          return err.code === 'REST_API_VALIDATION';
+          return err.code === 'REST_API_VALIDATION'
         },
         'Should throw validation error for invalid filter field'
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('Sorting', () => {
     beforeEach(async () => {
       await cleanTables(knex, [
         'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
-      ]);
+      ])
 
       // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' });
+      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
       const countryResult = await basicApi.resources.countries.post({
         inputRecord: countryDoc,
         simplified: false
-      });
+      })
 
       // Create books with different titles
-      const titles = ['Zebra Book', 'Apple Book', 'Mango Book', 'Banana Book'];
+      const titles = ['Zebra Book', 'Apple Book', 'Mango Book', 'Banana Book']
       for (const title of titles) {
         const doc = createJsonApiDocument('books', {
           title
         },
         {
           country: createRelationship(resourceIdentifier('countries', countryResult.data.id))
-        });
+        })
         await basicApi.resources.books.post({
           inputRecord: doc,
           simplified: false
-        });
+        })
       }
-    });
+    })
 
     it('should sort by single field ascending', async () => {
       const result = await basicApi.resources.books.query({
@@ -224,14 +224,14 @@ describe('Query Operations', () => {
           sort: ['title']
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 4)
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 4);
-      
-      const titles = result.data.map(b => b.attributes.title);
-      assert.deepEqual(titles, ['Apple Book', 'Banana Book', 'Mango Book', 'Zebra Book']);
-    });
+      const titles = result.data.map(b => b.attributes.title)
+      assert.deepEqual(titles, ['Apple Book', 'Banana Book', 'Mango Book', 'Zebra Book'])
+    })
 
     it('should sort by single field descending', async () => {
       const result = await basicApi.resources.books.query({
@@ -239,29 +239,29 @@ describe('Query Operations', () => {
           sort: ['-title']
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 4)
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 4);
-      
-      const titles = result.data.map(b => b.attributes.title);
-      assert.deepEqual(titles, ['Zebra Book', 'Mango Book', 'Banana Book', 'Apple Book']);
-    });
+      const titles = result.data.map(b => b.attributes.title)
+      assert.deepEqual(titles, ['Zebra Book', 'Mango Book', 'Banana Book', 'Apple Book'])
+    })
 
     it('should sort by multiple fields', async () => {
       // Create books with same country but different titles
-      const countryDoc1 = createJsonApiDocument('countries', { name: 'Country A', code: 'CA' });
-      const countryDoc2 = createJsonApiDocument('countries', { name: 'Country B', code: 'CB' });
-      
+      const countryDoc1 = createJsonApiDocument('countries', { name: 'Country A', code: 'CA' })
+      const countryDoc2 = createJsonApiDocument('countries', { name: 'Country B', code: 'CB' })
+
       const country1Result = await basicApi.resources.countries.post({
         inputRecord: countryDoc1,
         simplified: false
-      });
-      
+      })
+
       const country2Result = await basicApi.resources.countries.post({
         inputRecord: countryDoc2,
         simplified: false
-      });
+      })
 
       // Create books
       const booksToCreate = [
@@ -269,17 +269,17 @@ describe('Query Operations', () => {
         { title: 'Book A', countryId: country1Result.data.id },
         { title: 'Book Z', countryId: country2Result.data.id },
         { title: 'Book A', countryId: country2Result.data.id }
-      ];
+      ]
 
       for (const bookData of booksToCreate) {
-        const doc = createJsonApiDocument('books', 
+        const doc = createJsonApiDocument('books',
           { title: bookData.title },
           { country: createRelationship(resourceIdentifier('countries', bookData.countryId)) }
-        );
+        )
         await basicApi.resources.books.post({
           inputRecord: doc,
           simplified: false
-        });
+        })
       }
 
       // Sort by country_id ascending, then title descending
@@ -288,68 +288,68 @@ describe('Query Operations', () => {
           sort: ['country', '-title']
         },
         simplified: false
-      });
+      })
 
       // We expect 8 books total (4 from beforeEach + 4 from this test)
-      assert.equal(result.data.length, 8);
-      
+      assert.equal(result.data.length, 8)
+
       // Filter to only the books we created in this test
-      const testBooks = result.data.filter(book => 
+      const testBooks = result.data.filter(book =>
         book.attributes.title === 'Book A' || book.attributes.title === 'Book Z'
-      );
-      
-      assert.equal(testBooks.length, 4);
-      
+      )
+
+      assert.equal(testBooks.length, 4)
+
       // Sort test books by country relationship for verification
       const sortedTestBooks = testBooks.sort((a, b) => {
-        const countryA = a.relationships.country.data.id;
-        const countryB = b.relationships.country.data.id;
+        const countryA = a.relationships.country.data.id
+        const countryB = b.relationships.country.data.id
         if (countryA !== countryB) {
-          return countryA.localeCompare(countryB);
+          return countryA.localeCompare(countryB)
         }
         // Within same country, sort by title descending
-        return b.attributes.title.localeCompare(a.attributes.title);
-      });
-      
+        return b.attributes.title.localeCompare(a.attributes.title)
+      })
+
       // Verify the books are from the correct countries and in correct order
-      assert.equal(sortedTestBooks[0].relationships.country.data.id, country1Result.data.id);
-      assert.equal(sortedTestBooks[1].relationships.country.data.id, country1Result.data.id);
-      assert.equal(sortedTestBooks[2].relationships.country.data.id, country2Result.data.id);
-      assert.equal(sortedTestBooks[3].relationships.country.data.id, country2Result.data.id);
-      
+      assert.equal(sortedTestBooks[0].relationships.country.data.id, country1Result.data.id)
+      assert.equal(sortedTestBooks[1].relationships.country.data.id, country1Result.data.id)
+      assert.equal(sortedTestBooks[2].relationships.country.data.id, country2Result.data.id)
+      assert.equal(sortedTestBooks[3].relationships.country.data.id, country2Result.data.id)
+
       // Within each country, should be sorted by title descending
-      assert.equal(sortedTestBooks[0].attributes.title, 'Book Z');
-      assert.equal(sortedTestBooks[1].attributes.title, 'Book A');
-      assert.equal(sortedTestBooks[2].attributes.title, 'Book Z');
-      assert.equal(sortedTestBooks[3].attributes.title, 'Book A');
-    });
-  });
+      assert.equal(sortedTestBooks[0].attributes.title, 'Book Z')
+      assert.equal(sortedTestBooks[1].attributes.title, 'Book A')
+      assert.equal(sortedTestBooks[2].attributes.title, 'Book Z')
+      assert.equal(sortedTestBooks[3].attributes.title, 'Book A')
+    })
+  })
 
   describe('Pagination', () => {
     beforeEach(async () => {
       await cleanTables(knex, [
         'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors'
-      ]);
+      ])
 
       // Create test data
-      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' });
+      const countryDoc = createJsonApiDocument('countries', { name: 'Test Country', code: 'TC' })
       const countryResult = await basicApi.resources.countries.post({
         inputRecord: countryDoc,
         simplified: false
-      });
+      })
 
       // Create 10 books
       for (let i = 1; i <= 10; i++) {
-        const doc = createJsonApiDocument('books', 
+        const doc = createJsonApiDocument('books',
           { title: `Book ${String(i).padStart(2, '0')}` },
           { country: createRelationship(resourceIdentifier('countries', countryResult.data.id)) }
-        );
+        )
         await basicApi.resources.books.post({
           inputRecord: doc,
           simplified: false
-        });
+        })
       }
-    });
+    })
 
     it('should paginate results', async () => {
       // Get first page
@@ -359,13 +359,13 @@ describe('Query Operations', () => {
           sort: ['title']
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(page1, true);
-      assert.equal(page1.data.length, 3, 'Should return 3 results for page 1');
-      
-      const page1Titles = page1.data.map(b => b.attributes.title);
-      assert.deepEqual(page1Titles, ['Book 01', 'Book 02', 'Book 03']);
+      validateJsonApiStructure(page1, true)
+      assert.equal(page1.data.length, 3, 'Should return 3 results for page 1')
+
+      const page1Titles = page1.data.map(b => b.attributes.title)
+      assert.deepEqual(page1Titles, ['Book 01', 'Book 02', 'Book 03'])
 
       // Get second page
       const page2 = await basicApi.resources.books.query({
@@ -374,19 +374,19 @@ describe('Query Operations', () => {
           sort: ['title']
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(page2, true)
+      assert.equal(page2.data.length, 3, 'Should return 3 results for page 2')
 
-      validateJsonApiStructure(page2, true);
-      assert.equal(page2.data.length, 3, 'Should return 3 results for page 2');
-      
-      const page2Titles = page2.data.map(b => b.attributes.title);
-      assert.deepEqual(page2Titles, ['Book 04', 'Book 05', 'Book 06']);
+      const page2Titles = page2.data.map(b => b.attributes.title)
+      assert.deepEqual(page2Titles, ['Book 04', 'Book 05', 'Book 06'])
 
       // Verify different results
-      const page1Ids = page1.data.map(b => b.id);
-      const page2Ids = page2.data.map(b => b.id);
-      assert.equal(page1Ids.some(id => page2Ids.includes(id)), false, 'Pages should have different results');
-    });
+      const page1Ids = page1.data.map(b => b.id)
+      const page2Ids = page2.data.map(b => b.id)
+      assert.equal(page1Ids.some(id => page2Ids.includes(id)), false, 'Pages should have different results')
+    })
 
     it('should handle last page with fewer results', async () => {
       const lastPage = await basicApi.resources.books.query({
@@ -395,12 +395,12 @@ describe('Query Operations', () => {
           sort: ['title']
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(lastPage, true);
-      assert.equal(lastPage.data.length, 1, 'Should return 1 result for last page');
-      assert.equal(lastPage.data[0].attributes.title, 'Book 10');
-    });
+      validateJsonApiStructure(lastPage, true)
+      assert.equal(lastPage.data.length, 1, 'Should return 1 result for last page')
+      assert.equal(lastPage.data[0].attributes.title, 'Book 10')
+    })
 
     it('should handle page beyond available data', async () => {
       const emptyPage = await basicApi.resources.books.query({
@@ -408,11 +408,11 @@ describe('Query Operations', () => {
           page: { number: 10, size: 5 }
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(emptyPage, true);
-      assert.equal(emptyPage.data.length, 0, 'Should return empty array for page beyond data');
-    });
+      validateJsonApiStructure(emptyPage, true)
+      assert.equal(emptyPage.data.length, 0, 'Should return empty array for page beyond data')
+    })
 
     it('should respect queryMaxLimit limit', async () => {
       // Assuming queryMaxLimit is 100 (from vars)
@@ -421,34 +421,34 @@ describe('Query Operations', () => {
           page: { number: 1, size: 200 } // Request more than max
         },
         simplified: false
-      });
+      })
 
-      validateJsonApiStructure(result, true);
-      assert(result.data.length <= 100, 'Should not exceed queryMaxLimit');
-    });
-  });
+      validateJsonApiStructure(result, true)
+      assert(result.data.length <= 100, 'Should not exceed queryMaxLimit')
+    })
+  })
 
   describe('Combined Query Features', () => {
     beforeEach(async () => {
       await cleanTables(knex, [
         'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books', 'basic_book_authors',
         'ext_countries', 'ext_publishers', 'ext_authors', 'ext_books', 'ext_book_authors'
-      ]);
+      ])
 
       // Create test data for extended API with more fields
-      const countries = [];
+      const countries = []
       for (const [name, code, pop] of [['USA', 'US', 300000000], ['UK', 'GB', 60000000], ['France', 'FR', 65000000]]) {
         const doc = createJsonApiDocument('countries', {
           name,
           code,
           population: pop,
           currency: code === 'US' ? 'USD' : code === 'GB' ? 'GBP' : 'EUR'
-        });
+        })
         const result = await extendedApi.resources.countries.post({
           inputRecord: doc,
           simplified: false
-        });
-        countries.push(result.data);
+        })
+        countries.push(result.data)
       }
 
       // Create books with prices
@@ -458,23 +458,23 @@ describe('Query Operations', () => {
         { title: 'Medium Book C', price: 19.99, countryId: countries[1].id, language: 'en' },
         { title: 'Cheap Book D', price: 12.99, countryId: countries[1].id, language: 'fr' },
         { title: 'Expensive Book E', price: 39.99, countryId: countries[2].id, language: 'fr' }
-      ];
+      ]
 
       for (const data of bookData) {
-        const doc = createJsonApiDocument('books', 
+        const doc = createJsonApiDocument('books',
           {
             title: data.title,
             price: data.price,
             language: data.language
           },
           { country: createRelationship(resourceIdentifier('countries', data.countryId)) }
-        );
+        )
         await extendedApi.resources.books.post({
           inputRecord: doc,
           simplified: false
-        });
+        })
       }
-    });
+    })
 
     it('should filter, sort, and paginate together', async () => {
       const result = await extendedApi.resources.books.query({
@@ -484,15 +484,15 @@ describe('Query Operations', () => {
           page: { number: 1, size: 2 }
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 2)
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 2);
-      
       // Should get the 2 most expensive English books
-      assert.equal(result.data[0].attributes.title, 'Expensive Book B');
-      assert.equal(result.data[1].attributes.title, 'Medium Book C');
-    });
+      assert.equal(result.data[0].attributes.title, 'Expensive Book B')
+      assert.equal(result.data[1].attributes.title, 'Medium Book C')
+    })
 
     it('should filter and include relationships', async () => {
       const result = await extendedApi.resources.books.query({
@@ -501,21 +501,21 @@ describe('Query Operations', () => {
           include: ['country']
         },
         simplified: false
-      });
+      })
+
+      validateJsonApiStructure(result, true)
+      assert.equal(result.data.length, 2, 'Should return 2 French books')
 
-      validateJsonApiStructure(result, true);
-      assert.equal(result.data.length, 2, 'Should return 2 French books');
-      
       // Verify includes
-      assert(result.included, 'Should have included data');
-      const includedCountries = result.included.filter(r => r.type === 'countries');
-      assert(includedCountries.length >= 1, 'Should include at least one country');
-      
+      assert(result.included, 'Should have included data')
+      const includedCountries = result.included.filter(r => r.type === 'countries')
+      assert(includedCountries.length >= 1, 'Should include at least one country')
+
       // Verify included countries have the expected fields
       for (const country of includedCountries) {
-        assert(country.attributes.name);
-        assert(country.attributes.currency);
+        assert(country.attributes.name)
+        assert(country.attributes.currency)
       }
-    });
-  });
-});
+    })
+  })
+})