nestjs-paginate 4.2.2 → 4.4.0

package/lib/paginate.spec.js

@@ -27,17 +27,17 @@ describe('paginate', () => {
         catToyRepo = connection.getRepository(cat_toy_entity_1.CatToyEntity);
         catHomeRepo = connection.getRepository(cat_home_entity_1.CatHomeEntity);
         cats = await catRepo.save([
-            catRepo.create({ name: 'Milo', color: 'brown', age: 6 }),
-            catRepo.create({ name: 'Garfield', color: 'ginger', age: 5 }),
-            catRepo.create({ name: 'Shadow', color: 'black', age: 4 }),
-            catRepo.create({ name: 'George', color: 'white', age: 3 }),
-            catRepo.create({ name: 'Leche', color: 'white', age: null }),
+            catRepo.create({ name: 'Milo', color: 'brown', age: 6, size: { height: 25, width: 10, length: 40 } }),
+            catRepo.create({ name: 'Garfield', color: 'ginger', age: 5, size: { height: 30, width: 15, length: 45 } }),
+            catRepo.create({ name: 'Shadow', color: 'black', age: 4, size: { height: 25, width: 10, length: 50 } }),
+            catRepo.create({ name: 'George', color: 'white', age: 3, size: { height: 35, width: 12, length: 40 } }),
+            catRepo.create({ name: 'Leche', color: 'white', age: null, size: { height: 10, width: 5, length: 15 } }),
         ]);
         catToys = await catToyRepo.save([
-            catToyRepo.create({ name: 'Fuzzy Thing', cat: cats[0] }),
-            catToyRepo.create({ name: 'Stuffed Mouse', cat: cats[0] }),
-            catToyRepo.create({ name: 'Mouse', cat: cats[0] }),
-            catToyRepo.create({ name: 'String', cat: cats[1] }),
+            catToyRepo.create({ name: 'Fuzzy Thing', cat: cats[0], size: { height: 10, width: 10, length: 10 } }),
+            catToyRepo.create({ name: 'Stuffed Mouse', cat: cats[0], size: { height: 5, width: 5, length: 12 } }),
+            catToyRepo.create({ name: 'Mouse', cat: cats[0], size: { height: 6, width: 4, length: 13 } }),
+            catToyRepo.create({ name: 'String', cat: cats[1], size: { height: 1, width: 1, length: 50 } }),
         ]);
         catHomes = await catHomeRepo.save([
             catHomeRepo.create({ name: 'Box', cat: cats[0] }),
@@ -130,6 +130,58 @@ describe('paginate', () => {
         expect(links.next).toBe('?page=3&limit=2&sortBy=id:ASC');
         expect(links.last).toBe('?page=3&limit=2&sortBy=id:ASC');
     });
+    it('should return a relative path', async () => {
+        const config = {
+            sortableColumns: ['id'],
+            relativePath: true,
+        };
+        const query = {
+            path: 'http://localhost/cats',
+            page: 2,
+            limit: 2,
+        };
+        const { links } = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(links.first).toBe('/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.previous).toBe('/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.current).toBe('/cats?page=2&limit=2&sortBy=id:ASC');
+        expect(links.next).toBe('/cats?page=3&limit=2&sortBy=id:ASC');
+        expect(links.last).toBe('/cats?page=3&limit=2&sortBy=id:ASC');
+    });
+    it('should return an absolute path', async () => {
+        const config = {
+            sortableColumns: ['id'],
+            relativePath: false,
+        };
+        const query = {
+            path: 'http://localhost/cats',
+            page: 2,
+            limit: 2,
+        };
+        const { links } = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(links.first).toBe('http://localhost/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.previous).toBe('http://localhost/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.current).toBe('http://localhost/cats?page=2&limit=2&sortBy=id:ASC');
+        expect(links.next).toBe('http://localhost/cats?page=3&limit=2&sortBy=id:ASC');
+        expect(links.last).toBe('http://localhost/cats?page=3&limit=2&sortBy=id:ASC');
+    });
+    it('should return an absolute path with new origin', async () => {
+        const config = {
+            sortableColumns: ['id'],
+            relativePath: false,
+            origin: 'http://cats.example',
+        };
+        const query = {
+            path: 'http://localhost/cats',
+            page: 2,
+            limit: 2,
+        };
+        const { links } = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(links.first).toBe('http://cats.example/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.previous).toBe('http://cats.example/cats?page=1&limit=2&sortBy=id:ASC');
+        expect(links.current).toBe('http://cats.example/cats?page=2&limit=2&sortBy=id:ASC');
+        expect(links.next).toBe('http://cats.example/cats?page=3&limit=2&sortBy=id:ASC');
+        expect(links.last).toBe('http://cats.example/cats?page=3&limit=2&sortBy=id:ASC');
+    });
     it('should return only current link if zero results', async () => {
         const config = {
             sortableColumns: ['id'],
@@ -472,7 +524,7 @@ describe('paginate', () => {
             relations: ['cat'],
             sortableColumns: ['id', 'name'],
             filterableColumns: {
-                createdAt: [paginate_1.FilterOperator.BTW],
+                'cat.age': [paginate_1.FilterOperator.BTW],
             },
         };
         const query = {
@@ -485,9 +537,381 @@ describe('paginate', () => {
         expect(result.meta.filter).toStrictEqual({
             'cat.age': '$btw:6,10',
         });
-        expect(result.data).toStrictEqual([catHomes[0], catHomes[1]]);
+        expect(result.data).toStrictEqual([catHomes[0]]);
         expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.cat.age=$btw:6,10');
     });
+    it('should return result based on sort on embedded entity', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['name'],
+        };
+        const query = {
+            path: '',
+            sortBy: [
+                ['size.height', 'ASC'],
+                ['size.length', 'ASC'],
+            ],
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const orderedCats = [cats[4], cats[0], cats[2], cats[1], cats[3]];
+        expect(result.data).toStrictEqual(orderedCats);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=size.height:ASC&sortBy=size.length:ASC');
+    });
+    it('should return result based on sort on embedded entity when other relations loaded', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['name'],
+            relations: ['home', 'toys'],
+        };
+        const query = {
+            path: '',
+            sortBy: [
+                ['size.height', 'DESC'],
+                ['size.length', 'DESC'],
+            ],
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const copyCats = cats.map((cat) => {
+            const copy = (0, lodash_1.clone)(cat);
+            copy.home = null;
+            copy.toys = [];
+            return copy;
+        });
+        const copyHomes = catHomes.map((home) => {
+            const copy = (0, lodash_1.clone)(home);
+            delete copy.cat;
+            return copy;
+        });
+        copyCats[0].home = copyHomes[0];
+        copyCats[1].home = copyHomes[1];
+        const copyToys = catToys.map((toy) => {
+            const copy = (0, lodash_1.clone)(toy);
+            delete copy.cat;
+            return copy;
+        });
+        copyCats[0].toys = [copyToys[0], copyToys[1], copyToys[2]];
+        copyCats[1].toys = [copyToys[3]];
+        const orderedCats = [copyCats[3], copyCats[1], copyCats[2], copyCats[0], copyCats[4]];
+        expect(result.data).toStrictEqual(orderedCats);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=size.height:DESC&sortBy=size.length:DESC');
+    });
+    it('should return result based on sort on embedded entity on one-to-many relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'toys.size.height', 'toys.size.length', 'toys.size.width'],
+            searchableColumns: ['name'],
+            relations: ['toys'],
+        };
+        const query = {
+            path: '',
+            sortBy: [
+                ['id', 'DESC'],
+                ['toys.size.height', 'ASC'],
+                ['toys.size.length', 'ASC'],
+            ],
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const toy0 = (0, lodash_1.clone)(catToys[0]);
+        delete toy0.cat;
+        const toy1 = (0, lodash_1.clone)(catToys[1]);
+        delete toy1.cat;
+        const toy2 = (0, lodash_1.clone)(catToys[2]);
+        delete toy2.cat;
+        const toy3 = (0, lodash_1.clone)(catToys[3]);
+        delete toy3.cat;
+        const orderedCats = [
+            Object.assign((0, lodash_1.clone)(cats[4]), { toys: [] }),
+            Object.assign((0, lodash_1.clone)(cats[3]), { toys: [] }),
+            Object.assign((0, lodash_1.clone)(cats[2]), { toys: [] }),
+            Object.assign((0, lodash_1.clone)(cats[1]), { toys: [toy3] }),
+            Object.assign((0, lodash_1.clone)(cats[0]), { toys: [toy1, toy2, toy0] }),
+        ];
+        expect(result.data).toStrictEqual(orderedCats);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:DESC&sortBy=toys.size.height:ASC&sortBy=toys.size.length:ASC');
+    });
+    it('should return result based on sort on embedded entity on many-to-one relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'cat.size.height', 'cat.size.length', 'cat.size.width'],
+            searchableColumns: ['name'],
+            relations: ['cat'],
+        };
+        const query = {
+            path: '',
+            sortBy: [
+                ['cat.size.height', 'DESC'],
+                ['cat.size.length', 'DESC'],
+                ['name', 'ASC'],
+            ],
+        };
+        const result = await (0, paginate_1.paginate)(query, catToyRepo, config);
+        const orderedToys = [catToys[3], catToys[0], catToys[2], catToys[1]];
+        expect(result.data).toStrictEqual(orderedToys);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=cat.size.height:DESC&sortBy=cat.size.length:DESC&sortBy=name:ASC');
+    });
+    it('should return result based on sort on embedded entity on one-to-one relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'cat.size.height', 'cat.size.length', 'cat.size.width'],
+            searchableColumns: ['name'],
+            relations: ['cat'],
+        };
+        const query = {
+            path: '',
+            sortBy: [['cat.size.height', 'DESC']],
+        };
+        const result = await (0, paginate_1.paginate)(query, catHomeRepo, config);
+        const orderedHomes = [catHomes[1], catHomes[0]];
+        expect(result.data).toStrictEqual(orderedHomes);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=cat.size.height:DESC');
+    });
+    it('should return result based on search on embedded entity', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['size.height'],
+        };
+        const query = {
+            path: '',
+            search: '10',
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(result.data).toStrictEqual([cats[4]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&search=10');
+    });
+    it('should return result based on search term on embedded entity when other relations loaded', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['size.height'],
+            relations: ['home', 'toys'],
+        };
+        const query = {
+            path: '',
+            search: '10',
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(result.meta.search).toStrictEqual('10');
+        const copyCat = (0, lodash_1.clone)(cats[4]);
+        copyCat.home = null;
+        copyCat.toys = [];
+        expect(result.data).toStrictEqual([copyCat]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&search=10');
+    });
+    it('should return result based on search term on embedded entity on many-to-one relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'cat.size.height', 'cat.size.length', 'cat.size.width'],
+            searchableColumns: ['cat.size.height'],
+            relations: ['cat'],
+        };
+        const query = {
+            path: '',
+            search: '30',
+        };
+        const result = await (0, paginate_1.paginate)(query, catToyRepo, config);
+        expect(result.meta.search).toStrictEqual('30');
+        expect(result.data).toStrictEqual([catToys[3]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&search=30');
+    });
+    it('should return result based on search term on embedded entity on one-to-many relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'toys.size.height', 'toys.size.length', 'toys.size.width'],
+            searchableColumns: ['toys.size.height'],
+            relations: ['toys'],
+        };
+        const query = {
+            path: '',
+            search: '1',
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const toy0 = (0, lodash_1.clone)(catToys[0]);
+        delete toy0.cat;
+        const toy3 = (0, lodash_1.clone)(catToys[3]);
+        delete toy3.cat;
+        expect(result.data).toStrictEqual([
+            Object.assign((0, lodash_1.clone)(cats[0]), { toys: [toy0] }),
+            Object.assign((0, lodash_1.clone)(cats[1]), { toys: [toy3] }),
+        ]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&search=1');
+    });
+    it('should return result based on search term on embedded entity on one-to-one relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'cat.size.height', 'cat.size.length', 'cat.size.width'],
+            searchableColumns: ['cat.size.height'],
+            relations: ['cat'],
+        };
+        const query = {
+            path: '',
+            search: '30',
+        };
+        const result = await (0, paginate_1.paginate)(query, catHomeRepo, config);
+        expect(result.data).toStrictEqual([catHomes[1]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&search=30');
+    });
+    it('should return result based on sort and search on embedded many-to-one relation', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'cat.size.height', 'cat.size.length', 'cat.size.width'],
+            searchableColumns: ['cat.size.width'],
+            relations: ['cat'],
+        };
+        const query = {
+            path: '',
+            search: '1',
+            sortBy: [['cat.size.height', 'DESC']],
+        };
+        const result = await (0, paginate_1.paginate)(query, catToyRepo, config);
+        expect(result.meta.search).toStrictEqual('1');
+        expect(result.data).toStrictEqual([catToys[3], catToys[0], catToys[1], catToys[2]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=cat.size.height:DESC&search=1');
+    });
+    it('should return result based on filter on embedded entity', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['size.height'],
+            filterableColumns: {
+                'size.height': [paginate_1.FilterOperator.NOT],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'size.height': '$not:25',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        expect(result.data).toStrictEqual([cats[1], cats[3], cats[4]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.size.height=$not:25');
+    });
+    it('should return result based on filter on embedded entity when other relations loaded', async () => {
+        const config = {
+            sortableColumns: ['id', 'name', 'size.height', 'size.length', 'size.width'],
+            searchableColumns: ['size.height'],
+            filterableColumns: {
+                'size.height': [paginate_1.FilterOperator.NOT],
+            },
+            relations: ['home'],
+        };
+        const query = {
+            path: '',
+            filter: {
+                'size.height': '$not:25',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const home = (0, lodash_1.clone)(catHomes[1]);
+        delete home.cat;
+        const copyCats = [
+            Object.assign((0, lodash_1.clone)(cats[1]), { home: home }),
+            Object.assign((0, lodash_1.clone)(cats[3]), { home: null }),
+            Object.assign((0, lodash_1.clone)(cats[4]), { home: null }),
+        ];
+        expect(result.data).toStrictEqual(copyCats);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.size.height=$not:25');
+    });
+    it('should return result based on filter on embedded on many-to-one relation', async () => {
+        const config = {
+            relations: ['cat'],
+            sortableColumns: ['id', 'name'],
+            filterableColumns: {
+                'cat.size.height': [paginate_1.FilterOperator.NOT],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'cat.size.height': '$not:25',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catToyRepo, config);
+        expect(result.meta.filter).toStrictEqual({
+            'cat.size.height': '$not:25',
+        });
+        expect(result.data).toStrictEqual([catToys[3]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.cat.size.height=$not:25');
+    });
+    it('should return result based on filter on embedded on one-to-many relation', async () => {
+        const config = {
+            relations: ['toys'],
+            sortableColumns: ['id', 'name'],
+            filterableColumns: {
+                'toys.size.height': [paginate_1.FilterOperator.EQ],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'toys.size.height': '$eq:1',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catRepo, config);
+        const cat2 = (0, lodash_1.clone)(cats[1]);
+        const catToys3 = (0, lodash_1.clone)(catToys[3]);
+        delete catToys3.cat;
+        cat2.toys = [catToys3];
+        expect(result.meta.filter).toStrictEqual({
+            'toys.size.height': '$eq:1',
+        });
+        expect(result.data).toStrictEqual([cat2]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.toys.size.height=$eq:1');
+    });
+    it('should return result based on filter on embedded on one-to-one relation', async () => {
+        const config = {
+            relations: ['cat'],
+            sortableColumns: ['id', 'name'],
+            filterableColumns: {
+                'cat.size.height': [paginate_1.FilterOperator.EQ],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'cat.size.height': '$eq:30',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catHomeRepo, config);
+        expect(result.meta.filter).toStrictEqual({
+            'cat.size.height': '$eq:30',
+        });
+        expect(result.data).toStrictEqual([catHomes[1]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.cat.size.height=$eq:30');
+    });
+    it('should return result based on $in filter on embedded on one-to-one relation', async () => {
+        const config = {
+            relations: ['cat'],
+            sortableColumns: ['id', 'name'],
+            filterableColumns: {
+                'cat.size.height': [paginate_1.FilterOperator.IN],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'cat.size.height': '$in:10,30,35',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catHomeRepo, config);
+        expect(result.meta.filter).toStrictEqual({
+            'cat.size.height': '$in:10,30,35',
+        });
+        expect(result.data).toStrictEqual([catHomes[1]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.cat.size.height=$in:10,30,35');
+    });
+    it('should return result based on $btw filter on embedded on one-to-one relation', async () => {
+        const config = {
+            relations: ['cat'],
+            sortableColumns: ['id', 'name'],
+            filterableColumns: {
+                'cat.size.height': [paginate_1.FilterOperator.BTW],
+            },
+        };
+        const query = {
+            path: '',
+            filter: {
+                'cat.size.height': '$btw:18,33',
+            },
+        };
+        const result = await (0, paginate_1.paginate)(query, catHomeRepo, config);
+        expect(result.meta.filter).toStrictEqual({
+            'cat.size.height': '$btw:18,33',
+        });
+        expect(result.data).toStrictEqual([catHomes[0], catHomes[1]]);
+        expect(result.links.current).toBe('?page=1&limit=20&sortBy=id:ASC&filter.cat.size.height=$btw:18,33');
+    });
     it('should return result based on where array and filter', async () => {
         const config = {
             sortableColumns: ['id'],