json-rest-api 1.0.13 → 1.0.15

package/tests/positioning-multifilter.test.js

@@ -1,9 +1,9 @@
-import { describe, it, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import knexLib from 'knex';
-import { cleanTables } from './helpers/test-utils.js';
-import { createPositioningApi } from './fixtures/api-configs.js';
-import { PositioningPlugin } from '../plugins/core/rest-api-positioning-plugin.js';
+import { describe, it, before, after, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import knexLib from 'knex'
+import { cleanTables } from './helpers/test-utils.js'
+import { createPositioningApi } from './fixtures/api-configs.js'
+import { PositioningPlugin } from '../plugins/core/rest-api-positioning-plugin.js'
 
 // Create Knex instance for tests
 const knex = knexLib({
@@ -12,43 +12,43 @@ const knex = knexLib({
     filename: ':memory:'
   },
   useNullAsDefault: true
-});
+})
 
 describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
-  let api;
+  let api
 
   before(async () => {
     // Initialize API
-    api = await createPositioningApi(knex);
-    
+    api = await createPositioningApi(knex)
+
     // Install positioning plugin with default configuration
     await api.use(PositioningPlugin, {
       field: 'position',
       filters: ['project', 'status'], // Default filters for most tests
       defaultPosition: 'last'
-    });
-  });
-  
+    })
+  })
+
   after(async () => {
-    await knex.destroy();
-  });
-  
+    await knex.destroy()
+  })
+
   beforeEach(async () => {
     await cleanTables(knex, [
       'positioning_categories',
       'positioning_tasks',
       'positioning_projects',
       'positioning_items'
-    ]);
-  });
+    ])
+  })
 
   describe('Multiple Filter Fields', () => {
     it('should maintain separate position sequences for each filter combination', async () => {
       // Plugin already installed with filters in before hook
 
       // Create projects
-      const project1 = await api.resources.projects.post({ name: 'Project 1' });
-      const project2 = await api.resources.projects.post({ name: 'Project 2' });
+      const project1 = await api.resources.projects.post({ name: 'Project 1' })
+      const project2 = await api.resources.projects.post({ name: 'Project 2' })
 
       // Create items in different filter combinations
       // Project 1, Active
@@ -56,46 +56,46 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         name: 'P1 Active 1',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       const p1Active2 = await api.resources.items.post({
         name: 'P1 Active 2',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       // Project 1, Archived
       const p1Archived1 = await api.resources.items.post({
         name: 'P1 Archived 1',
         project: project1.id,
         status: 'archived'
-      });
+      })
 
       const p1Archived2 = await api.resources.items.post({
         name: 'P1 Archived 2',
         project: project1.id,
         status: 'archived'
-      });
+      })
 
       // Project 2, Active
       const p2Active1 = await api.resources.items.post({
         name: 'P2 Active 1',
         project: project2.id,
         status: 'active'
-      });
+      })
 
       const p2Active2 = await api.resources.items.post({
         name: 'P2 Active 2',
         project: project2.id,
         status: 'active'
-      });
+      })
 
       // Project 2, Archived
       const p2Archived1 = await api.resources.items.post({
         name: 'P2 Archived 1',
         project: project2.id,
         status: 'archived'
-      });
+      })
 
       // Query each combination
       const { data: p1ActiveItems } = await api.resources.items.query({
@@ -103,71 +103,71 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project1.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p1ActiveItems.length, 2);
-      assert.equal(p1ActiveItems[0].name, 'P1 Active 1');
-      assert.equal(p1ActiveItems[1].name, 'P1 Active 2');
+      assert.equal(p1ActiveItems.length, 2)
+      assert.equal(p1ActiveItems[0].name, 'P1 Active 1')
+      assert.equal(p1ActiveItems[1].name, 'P1 Active 2')
 
       const { data: p1ArchivedItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: project1.id, status: 'archived' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p1ArchivedItems.length, 2);
-      assert.equal(p1ArchivedItems[0].name, 'P1 Archived 1');
-      assert.equal(p1ArchivedItems[1].name, 'P1 Archived 2');
+      assert.equal(p1ArchivedItems.length, 2)
+      assert.equal(p1ArchivedItems[0].name, 'P1 Archived 1')
+      assert.equal(p1ArchivedItems[1].name, 'P1 Archived 2')
 
       const { data: p2ActiveItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: project2.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p2ActiveItems.length, 2);
-      assert.equal(p2ActiveItems[0].name, 'P2 Active 1');
-      assert.equal(p2ActiveItems[1].name, 'P2 Active 2');
+      assert.equal(p2ActiveItems.length, 2)
+      assert.equal(p2ActiveItems[0].name, 'P2 Active 1')
+      assert.equal(p2ActiveItems[1].name, 'P2 Active 2')
 
       // Verify positions are independent across filter combinations
       // Items in different groups can have the same position
-      assert.equal(p1Active1.position, 'a0');
-      assert.equal(p1Archived1.position, 'a0');
-      assert.equal(p2Active1.position, 'a0');
-      assert.equal(p2Archived1.position, 'a0');
-    });
+      assert.equal(p1Active1.position, 'a0')
+      assert.equal(p1Archived1.position, 'a0')
+      assert.equal(p2Active1.position, 'a0')
+      assert.equal(p2Archived1.position, 'a0')
+    })
 
     it('should handle positioning with null values in multi-filter setup', async () => {
       // Plugin already installed with filters in before hook
 
-      const project = await api.resources.projects.post({ name: 'Project' });
+      const project = await api.resources.projects.post({ name: 'Project' })
 
       // Create items with various null combinations
       const item1 = await api.resources.items.post({
         name: 'Item 1',
         project: project.id,
         status: 'active'
-      });
+      })
 
       const item2 = await api.resources.items.post({
         name: 'Item 2',
         project: project.id,
         status: null // Null status
-      });
+      })
 
       const item3 = await api.resources.items.post({
         name: 'Item 3',
         project: null, // Null project
         status: 'active'
-      });
+      })
 
       const item4 = await api.resources.items.post({
         name: 'Item 4',
         project: null,
         status: null // Both null
-      });
+      })
 
       // Query different combinations
       const { data: projectActiveItems } = await api.resources.items.query({
@@ -175,61 +175,61 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: 'active' },
           sort: ['position']
         }
-      });
-      assert.equal(projectActiveItems.length, 1);
-      assert.equal(projectActiveItems[0].name, 'Item 1');
+      })
+      assert.equal(projectActiveItems.length, 1)
+      assert.equal(projectActiveItems[0].name, 'Item 1')
 
       const { data: projectNullStatusItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: project.id, status: null },
           sort: ['position']
         }
-      });
-      assert.equal(projectNullStatusItems.length, 1);
-      assert.equal(projectNullStatusItems[0].name, 'Item 2');
+      })
+      assert.equal(projectNullStatusItems.length, 1)
+      assert.equal(projectNullStatusItems[0].name, 'Item 2')
 
       const { data: nullProjectActiveItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: null, status: 'active' },
           sort: ['position']
         }
-      });
-      assert.equal(nullProjectActiveItems.length, 1);
-      assert.equal(nullProjectActiveItems[0].name, 'Item 3');
+      })
+      assert.equal(nullProjectActiveItems.length, 1)
+      assert.equal(nullProjectActiveItems[0].name, 'Item 3')
 
       const { data: bothNullItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: null, status: null },
           sort: ['position']
         }
-      });
-      assert.equal(bothNullItems.length, 1);
-      assert.equal(bothNullItems[0].name, 'Item 4');
-    });
+      })
+      assert.equal(bothNullItems.length, 1)
+      assert.equal(bothNullItems[0].name, 'Item 4')
+    })
 
     it('should handle beforeId correctly with multi-filter positioning', async () => {
       // Plugin already installed with filters in before hook
 
-      const project = await api.resources.projects.post({ name: 'Project' });
+      const project = await api.resources.projects.post({ name: 'Project' })
 
       // Create initial items
       const item1 = await api.resources.items.post({
         name: 'Item 1',
         project: project.id,
         status: 'active'
-      });
+      })
 
       const item2 = await api.resources.items.post({
         name: 'Item 2',
         project: project.id,
         status: 'active'
-      });
+      })
 
       const item3 = await api.resources.items.post({
         name: 'Item 3',
         project: project.id,
         status: 'active'
-      });
+      })
 
       // Create item in different filter group with beforeId from first group
       const item4 = await api.resources.items.post({
@@ -237,7 +237,7 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         project: project.id,
         status: 'archived',
         beforeId: item2.id // This should be ignored since it's in a different filter group
-      });
+      })
 
       // Item 4 should be first in its filter group
       const { data: archivedItems } = await api.resources.items.query({
@@ -245,11 +245,11 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: 'archived' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(archivedItems.length, 1);
-      assert.equal(archivedItems[0].name, 'Item 4');
-      assert.equal(archivedItems[0].position, 'a0'); // First in its group
+      assert.equal(archivedItems.length, 1)
+      assert.equal(archivedItems[0].name, 'Item 4')
+      assert.equal(archivedItems[0].position, 'a0') // First in its group
 
       // Now position an item before another in the same filter group
       const item5 = await api.resources.items.post({
@@ -257,59 +257,59 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         project: project.id,
         status: 'active',
         beforeId: item2.id
-      });
+      })
 
       const { data: activeItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: project.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(activeItems.length, 4);
-      const item5Index = activeItems.findIndex(i => i.name === 'Item 5');
-      const item2Index = activeItems.findIndex(i => i.name === 'Item 2');
-      assert(item5Index < item2Index, 'Item 5 should be before Item 2');
-    });
+      assert.equal(activeItems.length, 4)
+      const item5Index = activeItems.findIndex(i => i.name === 'Item 5')
+      const item2Index = activeItems.findIndex(i => i.name === 'Item 2')
+      assert(item5Index < item2Index, 'Item 5 should be before Item 2')
+    })
 
     it('should handle updates that change filter values', async () => {
       // Plugin already installed with filters in before hook
 
-      const project1 = await api.resources.projects.post({ name: 'Project 1' });
-      const project2 = await api.resources.projects.post({ name: 'Project 2' });
+      const project1 = await api.resources.projects.post({ name: 'Project 1' })
+      const project2 = await api.resources.projects.post({ name: 'Project 2' })
 
       // Create items in project 1
       const item1 = await api.resources.items.post({
         name: 'Item 1',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       const item2 = await api.resources.items.post({
         name: 'Item 2',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       const item3 = await api.resources.items.post({
         name: 'Item 3',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       // Create items in project 2
       const item4 = await api.resources.items.post({
         name: 'Item 4',
         project: project2.id,
         status: 'active'
-      });
+      })
 
       // Move item2 to project 2, positioning it before item4
       await api.resources.items.patch({
         id: item2.id,
         project: project2.id,
         beforeId: item4.id
-      });
+      })
 
       // Verify project 1 now has 2 items
       const { data: p1Items } = await api.resources.items.query({
@@ -317,11 +317,11 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project1.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p1Items.length, 2);
-      assert.equal(p1Items[0].name, 'Item 1');
-      assert.equal(p1Items[1].name, 'Item 3');
+      assert.equal(p1Items.length, 2)
+      assert.equal(p1Items[0].name, 'Item 1')
+      assert.equal(p1Items[1].name, 'Item 3')
 
       // Verify project 2 has items in correct order
       const { data: p2Items } = await api.resources.items.query({
@@ -329,17 +329,17 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project2.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p2Items.length, 2);
-      assert.equal(p2Items[0].name, 'Item 2');
-      assert.equal(p2Items[1].name, 'Item 4');
+      assert.equal(p2Items.length, 2)
+      assert.equal(p2Items[0].name, 'Item 2')
+      assert.equal(p2Items[1].name, 'Item 4')
 
       // Change status of item3 to archived
       await api.resources.items.patch({
         id: item3.id,
         status: 'archived'
-      });
+      })
 
       // Verify it's now in a different filter group
       const { data: p1ActiveItems } = await api.resources.items.query({
@@ -347,25 +347,25 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project1.id, status: 'active' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p1ActiveItems.length, 1);
-      assert.equal(p1ActiveItems[0].name, 'Item 1');
+      assert.equal(p1ActiveItems.length, 1)
+      assert.equal(p1ActiveItems[0].name, 'Item 1')
 
       const { data: p1ArchivedItems } = await api.resources.items.query({
         queryParams: {
           filters: { project: project1.id, status: 'archived' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(p1ArchivedItems.length, 1);
-      assert.equal(p1ArchivedItems[0].name, 'Item 3');
+      assert.equal(p1ArchivedItems.length, 1)
+      assert.equal(p1ArchivedItems[0].name, 'Item 3')
       // Position should be maintained when moving to new filter group
       // (the plugin doesn't know where to position it in the new group)
-      assert(p1ArchivedItems[0].position); // Just verify it has a position
-    });
-  });
+      assert(p1ArchivedItems[0].position) // Just verify it has a position
+    })
+  })
 
   describe('Complex Multi-Filter Scenarios', () => {
     it('should handle three or more filter fields', async () => {
@@ -373,7 +373,7 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
       const multiApi = await createPositioningApi(knex, {
         apiName: 'multi-filter-three',
         tablePrefix: 'mf3'
-      });
+      })
 
       // Priority field is already in the items schema
 
@@ -381,14 +381,14 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         field: 'position',
         filters: ['project', 'status', 'priority'],
         defaultPosition: 'last'
-      });
+      })
 
-      const project = await multiApi.resources.projects.post({ name: 'Project' });
+      const project = await multiApi.resources.projects.post({ name: 'Project' })
 
       // Create items in different combinations
-      const items = [];
-      const statuses = ['active', 'pending', 'archived'];
-      const priorities = ['high', 'medium', 'low'];
+      const items = []
+      const statuses = ['active', 'pending', 'archived']
+      const priorities = ['high', 'medium', 'low']
 
       for (const status of statuses) {
         for (const priority of priorities) {
@@ -397,8 +397,8 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
             project: project.id,
             status,
             priority
-          });
-          items.push(item);
+          })
+          items.push(item)
         }
       }
 
@@ -407,83 +407,83 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         for (const priority of priorities) {
           const { data: filtered } = await multiApi.resources.items.query({
             queryParams: {
-              filters: { 
-                project: project.id, 
-                status: status,
-                priority: priority 
+              filters: {
+                project: project.id,
+                status,
+                priority
               },
               sort: ['position']
             }
-          });
+          })
 
-          assert.equal(filtered.length, 1);
-          assert.equal(filtered[0].name, `Item ${status}-${priority}`);
-          assert.equal(filtered[0].position, 'a0'); // Each is first in its group
+          assert.equal(filtered.length, 1)
+          assert.equal(filtered[0].name, `Item ${status}-${priority}`)
+          assert.equal(filtered[0].position, 'a0') // Each is first in its group
         }
       }
 
       // Add more items to one combination
-      const moreItems = [];
+      const moreItems = []
       for (let i = 2; i <= 5; i++) {
         const item = await multiApi.resources.items.post({
           name: `Item active-high ${i}`,
           project: project.id,
           status: 'active',
           priority: 'high'
-        });
-        moreItems.push(item);
+        })
+        moreItems.push(item)
       }
 
       // Verify the active-high combination now has 5 items
       const { data: activeHighItems } = await multiApi.resources.items.query({
         queryParams: {
-          filters: { 
-            project: project.id, 
+          filters: {
+            project: project.id,
             status: 'active',
-            priority: 'high' 
+            priority: 'high'
           },
           sort: ['position']
         }
-      });
+      })
+
+      assert.equal(activeHighItems.length, 5)
 
-      assert.equal(activeHighItems.length, 5);
-      
       // Verify they're in order
       for (let i = 1; i < activeHighItems.length; i++) {
-        assert(activeHighItems[i-1].position < activeHighItems[i].position);
+        assert(activeHighItems[i - 1].position < activeHighItems[i].position)
       }
-    });
+    })
 
     it('should handle partial filter queries correctly', async () => {
       // Plugin already installed with filters in before hook
 
-      const project1 = await api.resources.projects.post({ name: 'Project 1' });
-      const project2 = await api.resources.projects.post({ name: 'Project 2' });
+      const project1 = await api.resources.projects.post({ name: 'Project 1' })
+      const project2 = await api.resources.projects.post({ name: 'Project 2' })
 
       // Create items
       await api.resources.items.post({
         name: 'P1 Active 1',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       await api.resources.items.post({
         name: 'P1 Active 2',
         project: project1.id,
         status: 'active'
-      });
+      })
 
       await api.resources.items.post({
         name: 'P1 Archived',
         project: project1.id,
         status: 'archived'
-      });
+      })
 
       await api.resources.items.post({
         name: 'P2 Active',
         project: project2.id,
         status: 'active'
-      });
+      })
 
       // Query with only one filter (should return items from multiple position groups)
       const { data: activeItems } = await api.resources.items.query({
@@ -491,36 +491,36 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { status: 'active' },
           sort: ['position']
         }
-      });
+      })
+
+      assert.equal(activeItems.length, 3)
 
-      assert.equal(activeItems.length, 3);
-      
       // Items from different projects might have same position
-      const p1ActiveItems = activeItems.filter(i => i.name.startsWith('P1'));
-      const p2ActiveItems = activeItems.filter(i => i.name.startsWith('P2'));
-      
-      assert.equal(p1ActiveItems.length, 2);
-      assert.equal(p2ActiveItems.length, 1);
-      
+      const p1ActiveItems = activeItems.filter(i => i.name.startsWith('P1'))
+      const p2ActiveItems = activeItems.filter(i => i.name.startsWith('P2'))
+
+      assert.equal(p1ActiveItems.length, 2)
+      assert.equal(p2ActiveItems.length, 1)
+
       // Within same project, positions should be unique and ordered
-      assert(p1ActiveItems[0].position < p1ActiveItems[1].position);
-    });
+      assert(p1ActiveItems[0].position < p1ActiveItems[1].position)
+    })
 
     it('should handle filter changes during bulk operations', async () => {
       // Plugin already installed with filters in before hook
 
-      const project1 = await api.resources.projects.post({ name: 'Project 1' });
-      const project2 = await api.resources.projects.post({ name: 'Project 2' });
+      const project1 = await api.resources.projects.post({ name: 'Project 1' })
+      const project2 = await api.resources.projects.post({ name: 'Project 2' })
 
       // Create multiple items
-      const items = [];
+      const items = []
       for (let i = 1; i <= 10; i++) {
         const item = await api.resources.items.post({
           name: `Item ${i}`,
           project: project1.id,
           status: 'active'
-        });
-        items.push(item);
+        })
+        items.push(item)
       }
 
       // Move multiple items to different filter groups concurrently
@@ -529,20 +529,20 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
         api.resources.items.patch({ id: items[0].id, status: 'archived' }),
         api.resources.items.patch({ id: items[1].id, status: 'archived' }),
         api.resources.items.patch({ id: items[2].id, status: 'archived' }),
-        
+
         // Move to project 2
         api.resources.items.patch({ id: items[3].id, project: project2.id }),
         api.resources.items.patch({ id: items[4].id, project: project2.id }),
-        
+
         // Move to project 2 and archived
-        api.resources.items.patch({ 
-          id: items[5].id, 
-          project: project2.id, 
-          status: 'archived' 
+        api.resources.items.patch({
+          id: items[5].id,
+          project: project2.id,
+          status: 'archived'
         })
-      ];
+      ]
 
-      await Promise.all(updates);
+      await Promise.all(updates)
 
       // Verify distributions
       const { data: p1Active } = await api.resources.items.query({
@@ -550,73 +550,73 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project1.id, status: 'active' },
           sort: ['position']
         }
-      });
-      assert.equal(p1Active.length, 4); // 10 - 3 archived - 3 moved to p2
+      })
+      assert.equal(p1Active.length, 4) // 10 - 3 archived - 3 moved to p2
 
       const { data: p1Archived } = await api.resources.items.query({
         queryParams: {
           filters: { project: project1.id, status: 'archived' },
           sort: ['position']
         }
-      });
-      assert.equal(p1Archived.length, 3);
+      })
+      assert.equal(p1Archived.length, 3)
 
       const { data: p2Active } = await api.resources.items.query({
         queryParams: {
           filters: { project: project2.id, status: 'active' },
           sort: ['position']
         }
-      });
-      assert.equal(p2Active.length, 2);
+      })
+      assert.equal(p2Active.length, 2)
 
       const { data: p2Archived } = await api.resources.items.query({
         queryParams: {
           filters: { project: project2.id, status: 'archived' },
           sort: ['position']
         }
-      });
-      assert.equal(p2Archived.length, 1);
+      })
+      assert.equal(p2Archived.length, 1)
 
       // Verify all groups have proper positioning
-      const allGroups = [p1Active, p1Archived, p2Active, p2Archived];
+      const allGroups = [p1Active, p1Archived, p2Active, p2Archived]
       for (const group of allGroups) {
         if (group.length > 0) {
           // All items should have positions and be properly ordered
           for (let i = 0; i < group.length; i++) {
-            assert(group[i].position, `Item ${i} should have a position`);
+            assert(group[i].position, `Item ${i} should have a position`)
             if (i > 0) {
-              assert(group[i-1].position < group[i].position, `Items should be ordered`);
+              assert(group[i - 1].position < group[i].position, 'Items should be ordered')
             }
           }
         }
       }
-    });
-  });
+    })
+  })
 
   describe('Edge Cases with Multi-Filter', () => {
     it('should handle empty string vs null in filters', async () => {
       // Plugin already installed with filters in before hook
 
-      const project = await api.resources.projects.post({ name: 'Project' });
+      const project = await api.resources.projects.post({ name: 'Project' })
 
       // Create items with various empty/null combinations
       const item1 = await api.resources.items.post({
         name: 'Item 1',
         project: project.id,
         status: '' // Empty string
-      });
+      })
 
       const item2 = await api.resources.items.post({
         name: 'Item 2',
         project: project.id,
         status: null // Null
-      });
+      })
 
       const item3 = await api.resources.items.post({
         name: 'Item 3',
         project: project.id,
         status: 'active'
-      });
+      })
 
       // Query with empty string filter
       const { data: emptyStatusItems } = await api.resources.items.query({
@@ -624,10 +624,10 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: '' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(emptyStatusItems.length, 1);
-      assert.equal(emptyStatusItems[0].name, 'Item 1');
+      assert.equal(emptyStatusItems.length, 1)
+      assert.equal(emptyStatusItems[0].name, 'Item 1')
 
       // Query with null filter
       const { data: nullStatusItems } = await api.resources.items.query({
@@ -635,40 +635,40 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: null },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(nullStatusItems.length, 1);
-      assert.equal(nullStatusItems[0].name, 'Item 2');
+      assert.equal(nullStatusItems.length, 1)
+      assert.equal(nullStatusItems[0].name, 'Item 2')
 
       // Verify they're in different position groups
-      assert.equal(item1.position, 'a0');
-      assert.equal(item2.position, 'a0');
-      assert.equal(item3.position, 'a0');
-    });
+      assert.equal(item1.position, 'a0')
+      assert.equal(item2.position, 'a0')
+      assert.equal(item3.position, 'a0')
+    })
 
     it('should handle numeric vs string filter values', async () => {
       // Plugin already installed with filters in before hook
 
-      const project = await api.resources.projects.post({ name: 'Project' });
+      const project = await api.resources.projects.post({ name: 'Project' })
 
       // Create items with numeric-like status values
       const item1 = await api.resources.items.post({
         name: 'Item 1',
         project: project.id,
         status: '1'
-      });
+      })
 
       const item2 = await api.resources.items.post({
         name: 'Item 2',
         project: project.id,
         status: '01' // Different string representation
-      });
+      })
 
       const item3 = await api.resources.items.post({
         name: 'Item 3',
         project: project.id,
         status: '1'
-      });
+      })
 
       // Query with string '1'
       const { data: status1Items } = await api.resources.items.query({
@@ -676,12 +676,12 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: '1' },
           sort: ['position']
         }
-      });
+      })
 
-      assert.equal(status1Items.length, 2);
-      assert.equal(status1Items[0].name, 'Item 1');
-      assert.equal(status1Items[1].name, 'Item 3');
-      assert(status1Items[0].position < status1Items[1].position);
+      assert.equal(status1Items.length, 2)
+      assert.equal(status1Items[0].name, 'Item 1')
+      assert.equal(status1Items[1].name, 'Item 3')
+      assert(status1Items[0].position < status1Items[1].position)
 
       // Query with string '01'
       const { data: status01Items } = await api.resources.items.query({
@@ -689,11 +689,11 @@ describe('Multi-Filter Positioning Tests', { timeout: 30000 }, () => {
           filters: { project: project.id, status: '01' },
           sort: ['position']
         }
-      });
-
-      assert.equal(status01Items.length, 1);
-      assert.equal(status01Items[0].name, 'Item 2');
-      assert.equal(status01Items[0].position, 'a0');
-    });
-  });
-});
+      })
+
+      assert.equal(status01Items.length, 1)
+      assert.equal(status01Items[0].name, 'Item 2')
+      assert.equal(status01Items[0].position, 'a0')
+    })
+  })
+})