json-rest-api 1.0.13 → 1.0.15

package/tests/include-depth-validation.test.js

@@ -1,8 +1,8 @@
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import knexLib from 'knex';
-import { createBasicApi, createLimitedDepthApi } from './fixtures/api-configs.js';
-import { cleanTables } from './helpers/test-utils.js';
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { createBasicApi, createLimitedDepthApi } from './fixtures/api-configs.js'
+import { cleanTables } from './helpers/test-utils.js'
 
 // Create Knex instance for tests
 const knex = knexLib({
@@ -11,10 +11,10 @@ const knex = knexLib({
     filename: ':memory:'
   },
   useNullAsDefault: true
-});
+})
 
 describe('Include Depth Validation', () => {
-  let api;
+  let api
 
   before(async () => {
     // Initialize API with custom includeDepthLimit
@@ -22,13 +22,13 @@ describe('Include Depth Validation', () => {
       'rest-api': {
         includeDepthLimit: 3 // Default is 3, but being explicit
       }
-    });
+    })
 
     // Set up test data with nested relationships
     // Country -> Publisher -> Author -> Book
     await cleanTables(knex, [
       'basic_countries', 'basic_publishers', 'basic_authors', 'basic_books'
-    ]);
+    ])
 
     const country = await api.resources.countries.post({
       inputRecord: {
@@ -37,7 +37,7 @@ describe('Include Depth Validation', () => {
           attributes: { name: 'USA', code: 'US' }
         }
       }
-    });
+    })
 
     const publisher = await api.resources.publishers.post({
       inputRecord: {
@@ -49,7 +49,7 @@ describe('Include Depth Validation', () => {
           }
         }
       }
-    });
+    })
 
     const author = await api.resources.authors.post({
       inputRecord: {
@@ -61,7 +61,7 @@ describe('Include Depth Validation', () => {
           }
         }
       }
-    });
+    })
 
     await api.resources.books.post({
       inputRecord: {
@@ -74,137 +74,137 @@ describe('Include Depth Validation', () => {
           }
         }
       }
-    });
-  });
+    })
+  })
 
   after(async () => {
-    await knex.destroy();
-  });
+    await knex.destroy()
+  })
 
   describe('Query endpoint validation', () => {
     it('should allow includes within depth limit', async () => {
       // Depth 1
       const depth1 = await api.resources.publishers.query({
         queryParams: { include: ['country'] }
-      });
-      assert(depth1.data.length > 0, 'Should return publishers');
-      assert(depth1.included, 'Should have included resources');
+      })
+      assert(depth1.data.length > 0, 'Should return publishers')
+      assert(depth1.included, 'Should have included resources')
 
       // Depth 2
       const depth2 = await api.resources.authors.query({
         queryParams: { include: ['publisher.country'] }
-      });
-      assert(depth2.data.length > 0, 'Should return authors');
+      })
+      assert(depth2.data.length > 0, 'Should return authors')
       // The included array may or may not be present depending on whether relationships exist
 
       // Depth 3 (at limit)
       const depth3 = await api.resources.books.query({
         queryParams: { include: ['publisher.country.publishers'] }
-      });
-      assert(depth3.data.length > 0, 'Should return books');
+      })
+      assert(depth3.data.length > 0, 'Should return books')
       // Note: The included array might be present even if some relationships don't have data
-    });
+    })
 
     it('should reject includes exceeding depth limit', async () => {
       await assert.rejects(
         async () => {
           await api.resources.books.query({
             queryParams: { include: ['publisher.country.publishers.books'] }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /Include path.*exceeds maximum depth of 3/
         },
         'Should reject depth 4'
-      );
+      )
 
       await assert.rejects(
         async () => {
           await api.resources.books.query({
             queryParams: { include: ['publisher.country.publishers.books.authors'] }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /Include path.*exceeds maximum depth of 3/
         },
         'Should reject depth 5'
-      );
-    });
+      )
+    })
 
     it('should validate each include path independently', async () => {
       await assert.rejects(
         async () => {
           await api.resources.books.query({
-            queryParams: { 
+            queryParams: {
               include: [
                 'publisher',  // Valid (depth 1)
                 'publisher.country',  // Valid (depth 2)
                 'publisher.country.publishers.books'  // Invalid (depth 4)
-              ] 
+              ]
             }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /publisher\.country\.publishers\.books.*exceeds maximum depth of 3/
         },
         'Should reject when any path exceeds limit'
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('Get endpoint validation', () => {
     it('should allow includes within depth limit', async () => {
-      const books = await api.resources.books.query();
-      const bookId = books.data[0].id;
+      const books = await api.resources.books.query()
+      const bookId = books.data[0].id
 
       // Depth 1
       const depth1 = await api.resources.books.get({
         id: bookId,
         queryParams: { include: ['publisher'] }
-      });
-      assert(depth1.data.id === bookId, 'Should return correct book');
-      assert(depth1.included, 'Should have included resources');
+      })
+      assert(depth1.data.id === bookId, 'Should return correct book')
+      assert(depth1.included, 'Should have included resources')
 
       // Depth 3 (at limit)
       const depth3 = await api.resources.books.get({
         id: bookId,
         queryParams: { include: ['publisher.country.publishers'] }
-      });
-      assert(depth3.data.id === bookId, 'Should return correct book');
-    });
+      })
+      assert(depth3.data.id === bookId, 'Should return correct book')
+    })
 
     it('should reject includes exceeding depth limit', async () => {
-      const books = await api.resources.books.query();
-      const bookId = books.data[0].id;
+      const books = await api.resources.books.query()
+      const bookId = books.data[0].id
 
       await assert.rejects(
         async () => {
           await api.resources.books.get({
             id: bookId,
             queryParams: { include: ['publisher.country.publishers.books'] }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /Include path.*exceeds maximum depth of 3/
         },
         'Should reject depth 4 on GET'
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('Custom depth limits', () => {
     it('should respect custom includeDepthLimit configuration', async () => {
       // Create API with depth limit of 2 and different table names
-      const limitedApi = await createLimitedDepthApi(knex);
+      const limitedApi = await createLimitedDepthApi(knex)
 
       // Set up test data for limited API
       await cleanTables(knex, [
         'limited_countries', 'limited_publishers', 'limited_authors', 'limited_books', 'limited_book_authors'
-      ]);
+      ])
 
       const country = await limitedApi.resources.countries.post({
         inputRecord: {
@@ -213,7 +213,7 @@ describe('Include Depth Validation', () => {
             attributes: { name: 'Limited Country', code: 'LC' }
           }
         }
-      });
+      })
 
       const publisher = await limitedApi.resources.publishers.post({
         inputRecord: {
@@ -225,7 +225,7 @@ describe('Include Depth Validation', () => {
             }
           }
         }
-      });
+      })
 
       const author = await limitedApi.resources.authors.post({
         inputRecord: {
@@ -237,38 +237,38 @@ describe('Include Depth Validation', () => {
             }
           }
         }
-      });
+      })
 
       // Depth 2 should work
       const depth2 = await limitedApi.resources.authors.query({
         queryParams: { include: ['publisher.country'] }
-      });
-      assert(depth2.data.length > 0, 'Should return authors');
+      })
+      assert(depth2.data.length > 0, 'Should return authors')
 
       // Depth 3 should fail
       await assert.rejects(
         async () => {
           await limitedApi.resources.books.query({
             queryParams: { include: ['publisher.country.publishers'] }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /Include path.*exceeds maximum depth of 2/
         },
         'Should reject depth 3 with custom limit of 2'
-      );
-    });
-  });
+      )
+    })
+  })
 
   describe('Edge cases', () => {
     it('should handle empty include arrays', async () => {
       const result = await api.resources.books.query({
         queryParams: { include: [] }
-      });
-      assert(result.data.length > 0, 'Should return books');
-      assert(!result.included, 'Should not have included resources');
-    });
+      })
+      assert(result.data.length > 0, 'Should return books')
+      assert(!result.included, 'Should not have included resources')
+    })
 
     it('should handle single-level paths correctly', async () => {
       const country = await api.resources.countries.post({
@@ -278,7 +278,7 @@ describe('Include Depth Validation', () => {
             attributes: { name: 'Single Level Country', code: `S${Date.now().toString().slice(-2)}` }
           }
         }
-      });
+      })
 
       const publisher = await api.resources.publishers.post({
         inputRecord: {
@@ -290,7 +290,7 @@ describe('Include Depth Validation', () => {
             }
           }
         }
-      });
+      })
 
       await api.resources.books.post({
         inputRecord: {
@@ -303,14 +303,14 @@ describe('Include Depth Validation', () => {
             }
           }
         }
-      });
+      })
 
       const result = await api.resources.books.query({
         queryParams: { include: ['publisher'] }
-      });
-      assert(result.data.length > 0, 'Should return books');
-      assert(result.included, 'Should have included resources');
-    });
+      })
+      assert(result.data.length > 0, 'Should return books')
+      assert(result.included, 'Should have included resources')
+    })
 
     it('should count depth correctly with dots in path', async () => {
       // "a.b.c" = depth 3
@@ -318,14 +318,14 @@ describe('Include Depth Validation', () => {
         async () => {
           await api.resources.books.query({
             queryParams: { include: ['a.b.c.d'] }
-          });
+          })
         },
         {
           name: 'RestApiValidationError',
           message: /Include path 'a\.b\.c\.d' exceeds maximum depth of 3/
         },
         'Should count dots correctly'
-      );
-    });
-  });
-});
+      )
+    })
+  })
+})