@feathersjs/adapter-tests - npm Package Compare versions

Comparing version 5.0.0-pre.22 to 5.0.0-pre.23

CHANGELOG.md

@@ -6,2 +6,10 @@ # Change Log
 
+# [5.0.0-pre.23](https://github.com/feathersjs/feathers/compare/v5.0.0-pre.22...v5.0.0-pre.23) (2022-06-06)
+
+**Note:** Version bump only for package @feathersjs/adapter-tests
+
+
+
+
+
 # [5.0.0-pre.22](https://github.com/feathersjs/feathers/compare/v5.0.0-pre.21...v5.0.0-pre.22) (2022-05-24)
@@ -8,0 +16,0 @@

lib/index.js

@@ -42,3 +42,3 @@ "use strict";
             after(() => {
-                testNames.forEach(name => {
+                testNames.forEach((name) => {
                     if (!allTests.includes(name)) {
@@ -45,0 +45,0 @@ console.error(`WARNING: '${name}' test is not part of the test suite`);

lib/methods.js

@@ -142,8 +142,12 @@ "use strict";
                     service.options.paginate = {
-                        'default': defaultPaginate,
-                        'max': 100
+                        default: defaultPaginate,
+                        max: 100
                     };
                     const emptyItems = await service.find({ paginate: false });
                     assert_1.default.strictEqual(emptyItems.length, 0, 'no items before');
-                    const createdItems = await service.create(Array.from(Array(count)).map((_, i) => ({ name: `name-${i}`, age: 3, created: true })));
+                    const createdItems = await service.create(Array.from(Array(count)).map((_, i) => ({
+                        name: `name-${i}`,
+                        age: 3,
+                        created: true
+                    })));
                     assert_1.default.strictEqual(createdItems.length, count, `created ${count} items`);
@@ -154,7 +158,12 @@ const foundItems = await service.find({ paginate: false });
                     assert_1.default.strictEqual(foundPaginatedItems.data.length, defaultPaginate, 'found paginated items');
-                    const allItems = await service.remove(null, { query: { created: true } });
+                    const allItems = await service.remove(null, {
+                        query: { created: true }
+                    });
                     assert_1.default.strictEqual(allItems.length, count, `removed all ${count} items`);
                 }
                 finally {
-                    await service.remove(null, { query: { created: true }, paginate: false });
+                    await service.remove(null, {
+                        query: { created: true },
+                        paginate: false
+                    });
                     service.options.multi = multiBefore;
@@ -218,3 +227,5 @@ service.options.paginate = paginateBefore;
                 try {
-                    await service.update('568225fbfe21222432e836ff', { name: 'NotFound' });
+                    await service.update('568225fbfe21222432e836ff', {
+                        name: 'NotFound'
+                    });
                     throw new Error('Should never get here');
@@ -333,8 +344,12 @@ }
                     service.options.paginate = {
-                        'default': defaultPaginate,
-                        'max': 100
+                        default: defaultPaginate,
+                        max: 100
                     };
                     const emptyItems = await service.find({ paginate: false });
                     assert_1.default.strictEqual(emptyItems.length, 0, 'no items before');
-                    const createdItems = await service.create(Array.from(Array(count)).map((_, i) => ({ name: `name-${i}`, age: 3, created: true })));
+                    const createdItems = await service.create(Array.from(Array(count)).map((_, i) => ({
+                        name: `name-${i}`,
+                        age: 3,
+                        created: true
+                    })));
                     assert_1.default.strictEqual(createdItems.length, count, `created ${count} items`);
@@ -353,3 +368,3 @@ ids = createdItems.map((item) => item[idProp]);
                     if (ids) {
-                        await Promise.all(ids.map(id => service.remove(id)));
+                        await Promise.all(ids.map((id) => service.remove(id)));
                     }
@@ -414,3 +429,5 @@ }
                 try {
-                    await service.patch('568225fbfe21222432e836ff', { name: 'PatchDoug' });
+                    await service.patch('568225fbfe21222432e836ff', {
+                        name: 'PatchDoug'
+                    });
                     throw new Error('Should never get here');
@@ -506,3 +523,3 @@ }
         });
-        describe('doesn\'t call public methods internally', () => {
+        describe("doesn't call public methods internally", () => {
             let throwing;
@@ -509,0 +526,0 @@ before(() => {

lib/syntax.js

@@ -119,6 +119,3 @@ "use strict";
                     query: {
-                        $or: [
-                            { name: 'Alice' },
-                            { name: 'Bob' }
-                        ],
+                        $or: [{ name: 'Alice' }, { name: 'Bob' }],
                         $sort: { name: 1 }
@@ -125,0 +122,0 @@ }

package.json

 {
   "name": "@feathersjs/adapter-tests",
-  "version": "5.0.0-pre.22",
+  "version": "5.0.0-pre.23",
   "description": "Feathers shared database adapter test suite",
@@ -53,9 +53,9 @@ "homepage": "https://feathersjs.com",
     "@types/mocha": "^9.1.1",
-    "@types/node": "^17.0.31",
+    "@types/node": "^17.0.40",
     "mocha": "^10.0.0",
     "shx": "^0.3.4",
-    "ts-node": "^10.7.0",
-    "typescript": "^4.6.4"
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.3"
   },
-  "gitHead": "e452e02063e6d8943a9cae2315ab585bc4f82fb6"
+  "gitHead": "a60910bd730b88053ca6648337095f1ca1e3b39f"
 }

src/basic.ts

@@ -1,78 +0,74 @@
-import assert from 'assert';
-import { AdapterBasicTest } from './declarations';
+import assert from 'assert'
+import { AdapterBasicTest } from './declarations'
 
 export default (test: AdapterBasicTest, app: any, _errors: any, serviceName: string, idProp: string) => {
   describe('Basic Functionality', () => {
-    let service: any;
+    let service: any
 
     beforeEach(() => {
-      service = app.service(serviceName);
-    });
+      service = app.service(serviceName)
+    })
 
     it('.id', () => {
-      assert.strictEqual(service.id, idProp,
-        'id property is set to expected name'
-      );
-    });
+      assert.strictEqual(service.id, idProp, 'id property is set to expected name')
+    })
 
     test('.options', () => {
-      assert.ok(service.options, 'Options are available in service.options');
-    });
+      assert.ok(service.options, 'Options are available in service.options')
+    })
 
     test('.events', () => {
-      assert.ok(service.events.includes('testing'),
-        'service.events is set and includes "testing"'
-      );
-    });
+      assert.ok(service.events.includes('testing'), 'service.events is set and includes "testing"')
+    })
 
     describe('Raw Methods', () => {
       test('._get', () => {
-        assert.strictEqual(typeof service._get, 'function');
-      });
+        assert.strictEqual(typeof service._get, 'function')
+      })
 
       test('._find', () => {
-        assert.strictEqual(typeof service._find, 'function');
-      });
+        assert.strictEqual(typeof service._find, 'function')
+      })
 
       test('._create', () => {
-        assert.strictEqual(typeof service._create, 'function');
-      });
+        assert.strictEqual(typeof service._create, 'function')
+      })
 
       test('._update', () => {
-        assert.strictEqual(typeof service._update, 'function');
-      });
+        assert.strictEqual(typeof service._update, 'function')
+      })
 
       test('._patch', () => {
-        assert.strictEqual(typeof service._patch, 'function');
-      });
+        assert.strictEqual(typeof service._patch, 'function')
+      })
 
       test('._remove', () => {
-        assert.strictEqual(typeof service._remove, 'function');
-      });
+        assert.strictEqual(typeof service._remove, 'function')
+      })
 
       test('.$get', () => {
-        assert.strictEqual(typeof service.$get, 'function');
-      });
+        assert.strictEqual(typeof service.$get, 'function')
+      })
 
       test('.$find', () => {
-        assert.strictEqual(typeof service.$find, 'function');
-      });
+        assert.strictEqual(typeof service.$find, 'function')
+      })
 
       test('.$create', () => {
-        assert.strictEqual(typeof service.$create, 'function');
-      });
+        assert.strictEqual(typeof service.$create, 'function')
+      })
 
       test('.$update', () => {
-        assert.strictEqual(typeof service.$update, 'function');
-      });
+        assert.strictEqual(typeof service.$update, 'function')
+      })
 
       test('.$patch', () => {
-        assert.strictEqual(typeof service.$patch, 'function');
-      });
+        assert.strictEqual(typeof service.$patch, 'function')
+      })
 
       test('.$remove', () => {
-        assert.strictEqual(typeof service.$remove, 'function');
-      });
-    });
-  });
-};
+        assert.strictEqual(typeof service.$remove, 'function')
+      })
+    })
+  })
+}

src/declarations.ts

@@ -1,90 +0,90 @@
-export type AdapterTest = (name: AdapterTestName, runner: any) => void;
+export type AdapterTest = (name: AdapterTestName, runner: any) => void
 
-export type AdapterBasicTest = (name: AdapterBasicTestName, runner: any) => void;
-export type AdapterMethodsTest = (name: AdapterMethodsTestName, runner: any) => void;
-export type AdapterSyntaxTest = (name: AdapterSyntaxTestName, runner: any) => void;
+export type AdapterBasicTest = (name: AdapterBasicTestName, runner: any) => void
+export type AdapterMethodsTest = (name: AdapterMethodsTestName, runner: any) => void
+export type AdapterSyntaxTest = (name: AdapterSyntaxTestName, runner: any) => void
 
-export type AdapterTestName = AdapterBasicTestName | AdapterMethodsTestName | AdapterSyntaxTestName;
+export type AdapterTestName = AdapterBasicTestName | AdapterMethodsTestName | AdapterSyntaxTestName
 
 export type AdapterBasicTestName =
-  '.id' |
-  '.options' |
-  '.events' |
-  '._get' |
-  '._find' |
-  '._create' |
-  '._update' |
-  '._patch' |
-  '._remove'|
-  '.$get' |
-  '.$find' |
-  '.$create' |
-  '.$update' |
-  '.$patch' |
-  '.$remove';
+  | '.id'
+  | '.options'
+  | '.events'
+  | '._get'
+  | '._find'
+  | '._create'
+  | '._update'
+  | '._patch'
+  | '._remove'
+  | '.$get'
+  | '.$find'
+  | '.$create'
+  | '.$update'
+  | '.$patch'
+  | '.$remove'
 
 export type AdapterMethodsTestName =
-  '.get' |
-  '.get + $select' |
-  '.get + id + query' |
-  '.get + NotFound' |
-  '.get + id + query id' |
-  '.find' |
-  '.remove' |
-  '.remove + $select' |
-  '.remove + id + query' |
-  '.remove + multi' |
-  '.remove + multi no pagination' |
-  '.remove + id + query id' |
-  '.update' |
-  '.update + $select' |
-  '.update + id + query' |
-  '.update + NotFound' |
-  '.update + query + NotFound' |
-  '.update + id + query id' |
-  '.patch' |
-  '.patch + $select' |
-  '.patch + id + query' |
-  '.patch multiple' |
-  '.patch multiple no pagination' |
-  '.patch multi query same' |
-  '.patch multi query changed' |
-  '.patch + NotFound' |
-  '.patch + query + NotFound' |
-  '.patch + id + query id' |
-  '.create' |
-  '.create + $select' |
-  '.create multi' |
-  'internal .find' |
-  'internal .get' |
-  'internal .create' |
-  'internal .update' |
-  'internal .patch' |
-  'internal .remove';
+  | '.get'
+  | '.get + $select'
+  | '.get + id + query'
+  | '.get + NotFound'
+  | '.get + id + query id'
+  | '.find'
+  | '.remove'
+  | '.remove + $select'
+  | '.remove + id + query'
+  | '.remove + multi'
+  | '.remove + multi no pagination'
+  | '.remove + id + query id'
+  | '.update'
+  | '.update + $select'
+  | '.update + id + query'
+  | '.update + NotFound'
+  | '.update + query + NotFound'
+  | '.update + id + query id'
+  | '.patch'
+  | '.patch + $select'
+  | '.patch + id + query'
+  | '.patch multiple'
+  | '.patch multiple no pagination'
+  | '.patch multi query same'
+  | '.patch multi query changed'
+  | '.patch + NotFound'
+  | '.patch + query + NotFound'
+  | '.patch + id + query id'
+  | '.create'
+  | '.create + $select'
+  | '.create multi'
+  | 'internal .find'
+  | 'internal .get'
+  | 'internal .create'
+  | 'internal .update'
+  | 'internal .patch'
+  | 'internal .remove'
 
 export type AdapterSyntaxTestName =
-  '.find + equal' |
-  '.find + equal multiple' |
-  '.find + $sort' |
-  '.find + $sort + string' |
-  '.find + $limit' |
-  '.find + $limit 0' |
-  '.find + $skip' |
-  '.find + $select' |
-  '.find + $or' |
-  '.find + $in' |
-  '.find + $nin' |
-  '.find + $lt' |
-  '.find + $lte' |
-  '.find + $gt' |
-  '.find + $gte' |
-  '.find + $ne' |
-  '.find + $gt + $lt + $sort' |
-  '.find + $or nested + $sort' |
-  'params.adapter + paginate' |
-  'params.adapter + multi' |
-  '.find + paginate' |
-  '.find + paginate + query' |
-  '.find + paginate + $limit + $skip' |
-  '.find + paginate + $limit 0' |
-  '.find + paginate + params';
+  | '.find + equal'
+  | '.find + equal multiple'
+  | '.find + $sort'
+  | '.find + $sort + string'
+  | '.find + $limit'
+  | '.find + $limit 0'
+  | '.find + $skip'
+  | '.find + $select'
+  | '.find + $or'
+  | '.find + $in'
+  | '.find + $nin'
+  | '.find + $lt'
+  | '.find + $lte'
+  | '.find + $gt'
+  | '.find + $gte'
+  | '.find + $ne'
+  | '.find + $gt + $lt + $sort'
+  | '.find + $or nested + $sort'
+  | 'params.adapter + paginate'
+  | 'params.adapter + multi'
+  | '.find + paginate'
+  | '.find + paginate + query'
+  | '.find + paginate + $limit + $skip'
+  | '.find + paginate + $limit 0'
+  | '.find + paginate + params'

src/index.ts

 /* eslint-disable no-console */
-import basicTests from './basic';
-import { AdapterTestName } from './declarations';
-import methodTests from './methods';
-import syntaxTests from './syntax';
+import basicTests from './basic'
+import { AdapterTestName } from './declarations'
+import methodTests from './methods'
+import syntaxTests from './syntax'
 
@@ -10,47 +10,49 @@ const adapterTests = (testNames: AdapterTestName[]) => {
     if (!serviceName) {
-      throw new Error('You must pass a service name');
+      throw new Error('You must pass a service name')
     }
 
-    const skippedTests: AdapterTestName[] = [];
-    const allTests: AdapterTestName[] = [];
+    const skippedTests: AdapterTestName[] = []
+    const allTests: AdapterTestName[] = []
 
     const test = (name: AdapterTestName, runner: any) => {
-      const skip = !testNames.includes(name);
-      const its = skip ? it.skip : it;
+      const skip = !testNames.includes(name)
+      const its = skip ? it.skip : it
 
       if (skip) {
-        skippedTests.push(name);
+        skippedTests.push(name)
       }
 
-      allTests.push(name);
+      allTests.push(name)
 
-      its(name, runner);
-    };
+      its(name, runner)
+    }
 
     describe(`Adapter tests for '${serviceName}' service with '${idProp}' id property`, () => {
       after(() => {
-        testNames.forEach(name => {
+        testNames.forEach((name) => {
           if (!allTests.includes(name)) {
-            console.error(`WARNING: '${name}' test is not part of the test suite`);
+            console.error(`WARNING: '${name}' test is not part of the test suite`)
           }
-        });
+        })
         if (skippedTests.length) {
-          console.log(`\nSkipped the following ${skippedTests.length} Feathers adapter test(s) out of ${allTests.length} total:`);
-          console.log(JSON.stringify(skippedTests, null, '  '));
+          console.log(
+            `\nSkipped the following ${skippedTests.length} Feathers adapter test(s) out of ${allTests.length} total:`
+          )
+          console.log(JSON.stringify(skippedTests, null, '  '))
         }
-      });
+      })
 
-      basicTests(test, app, errors, serviceName, idProp);
-      methodTests(test, app, errors, serviceName, idProp);
-      syntaxTests(test, app, errors, serviceName, idProp);
-    });
-  };
-};
+      basicTests(test, app, errors, serviceName, idProp)
+      methodTests(test, app, errors, serviceName, idProp)
+      syntaxTests(test, app, errors, serviceName, idProp)
+    })
+  }
+}
 
 export * from './declarations'
 
-export default adapterTests;
+export default adapterTests
 
 if (typeof module !== 'undefined') {
-  module.exports = Object.assign(adapterTests, module.exports);
+  module.exports = Object.assign(adapterTests, module.exports)
 }

src/methods.ts

@@ -1,45 +0,41 @@
-import assert from 'assert';
-import { AdapterMethodsTest } from './declarations';
+import assert from 'assert'
+import { AdapterMethodsTest } from './declarations'
 
 export default (test: AdapterMethodsTest, app: any, _errors: any, serviceName: string, idProp: string) => {
   describe(' Methods', () => {
-    let doug: any;
-    let service: any;
+    let doug: any
+    let service: any
 
     beforeEach(async () => {
-      service = app.service(serviceName);
+      service = app.service(serviceName)
       doug = await app.service(serviceName).create({
         name: 'Doug',
         age: 32
-      });
-    });
+      })
+    })
 
     afterEach(async () => {
       try {
-        await app.service(serviceName).remove(doug[idProp]);
+        await app.service(serviceName).remove(doug[idProp])
       } catch (error: any) {}
-    });
+    })
 
     describe('get', () => {
       test('.get', async () => {
-        const data = await service.get(doug[idProp]);
+        const data = await service.get(doug[idProp])
 
-        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(),
-          `${idProp} id matches`
-        );
-        assert.strictEqual(data.name, 'Doug', 'data.name matches');
-        assert.strictEqual(data.age, 32, 'data.age matches');
-      });
+        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(), `${idProp} id matches`)
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.strictEqual(data.age, 32, 'data.age matches')
+      })
 
       test('.get + $select', async () => {
         const data = await service.get(doug[idProp], {
-          query: { $select: [ 'name' ] }
-        });
+          query: { $select: ['name'] }
+        })
 
-        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(),
-          `${idProp} id property matches`
-        );
-        assert.strictEqual(data.name, 'Doug', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
-      });
+        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(), `${idProp} id property matches`)
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
 
@@ -50,21 +46,17 @@ test('.get + id + query', async () => {
             query: { name: 'Tester' }
-          });
-          throw new Error('Should never get here');
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
-      });
+      })
 
       test('.get + NotFound', async () => {
         try {
-          await service.get('568225fbfe21222432e836ff');
-          throw new Error('Should never get here');
+          await service.get('568225fbfe21222432e836ff')
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Error is a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Error is a NotFound Feathers error')
         }
-      });
+      })
 
@@ -75,3 +67,3 @@ test('.get + id + query id', async () => {
           age: 12
-        });
+        })
 
@@ -81,38 +73,36 @@ try {
             query: { [idProp]: alice[idProp] }
-          });
-          throw new Error('Should never get here');
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
 
-        await service.remove(alice[idProp]);
-      });
-    });
+        await service.remove(alice[idProp])
+      })
+    })
 
     describe('find', () => {
       test('.find', async () => {
-        const data = await service.find();
+        const data = await service.find()
 
-        assert.ok(Array.isArray(data), 'Data is an array');
-        assert.strictEqual(data.length, 1, 'Got one entry');
-      });
-    });
+        assert.ok(Array.isArray(data), 'Data is an array')
+        assert.strictEqual(data.length, 1, 'Got one entry')
+      })
+    })
 
     describe('remove', () => {
       test('.remove', async () => {
-        const data = await service.remove(doug[idProp]);
+        const data = await service.remove(doug[idProp])
 
-        assert.strictEqual(data.name, 'Doug', 'data.name matches');
-      });
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+      })
 
       test('.remove + $select', async () => {
         const data = await service.remove(doug[idProp], {
-          query: { $select: [ 'name' ] }
-        });
+          query: { $select: ['name'] }
+        })
 
-        assert.strictEqual(data.name, 'Doug', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
-      });
+        assert.strictEqual(data.name, 'Doug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
 
@@ -123,24 +113,24 @@ test('.remove + id + query', async () => {
             query: { name: 'Tester' }
-          });
-          throw new Error('Should never get here');
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
-      });
+      })
 
       test('.remove + multi', async () => {
         try {
-          await service.remove(null);
-          throw new Error('Should never get here');
+          await service.remove(null)
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'MethodNotAllowed',
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
             'Removing multiple without option set throws MethodNotAllowed'
-          );
+          )
         }
 
-        service.options.multi = [ 'remove' ];
+        service.options.multi = ['remove']
 
-        await service.create({ name: 'Dave', age: 29, created: true });
+        await service.create({ name: 'Dave', age: 29, created: true })
         await service.create({
@@ -150,60 +140,69 @@ name: 'David',
           created: true
-        });
+        })
 
         const data = await service.remove(null, {
           query: { created: true }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
+        assert.strictEqual(data.length, 2)
 
-        const names = data.map((person: any) => person.name);
+        const names = data.map((person: any) => person.name)
 
-        assert.ok(names.includes('Dave'), 'Dave removed');
-        assert.ok(names.includes('David'), 'David removed');
-      });
+        assert.ok(names.includes('Dave'), 'Dave removed')
+        assert.ok(names.includes('David'), 'David removed')
+      })
 
       test('.remove + multi no pagination', async () => {
         try {
-          await service.remove(doug[idProp]);
+          await service.remove(doug[idProp])
         } catch (error: any) {}
 
-        const count = 14;
-        const defaultPaginate = 10;
+        const count = 14
+        const defaultPaginate = 10
 
-        assert.ok(count > defaultPaginate, 'count is bigger than default pagination');
+        assert.ok(count > defaultPaginate, 'count is bigger than default pagination')
 
-        const multiBefore = service.options.multi;
-        const paginateBefore = service.options.paginate;
+        const multiBefore = service.options.multi
+        const paginateBefore = service.options.paginate
 
         try {
-          service.options.multi = true;
+          service.options.multi = true
           service.options.paginate = {
-            'default': defaultPaginate,
-            'max': 100
-          };
+            default: defaultPaginate,
+            max: 100
+          }
 
-          const emptyItems = await service.find({ paginate: false });
+          const emptyItems = await service.find({ paginate: false })
           assert.strictEqual(emptyItems.length, 0, 'no items before')
 
           const createdItems = await service.create(
-            Array.from(Array(count)).map((_, i) => ({ name: `name-${i}`, age: 3, created: true }))
-          );
-          assert.strictEqual(createdItems.length, count, `created ${count} items`);
+            Array.from(Array(count)).map((_, i) => ({
+              name: `name-${i}`,
+              age: 3,
+              created: true
+            }))
+          )
+          assert.strictEqual(createdItems.length, count, `created ${count} items`)
 
-          const foundItems = await service.find({ paginate: false });
-          assert.strictEqual(foundItems.length, count, `created ${count} items`);
+          const foundItems = await service.find({ paginate: false })
+          assert.strictEqual(foundItems.length, count, `created ${count} items`)
 
-          const foundPaginatedItems = await service.find({});
-          assert.strictEqual(foundPaginatedItems.data.length, defaultPaginate, 'found paginated items');
+          const foundPaginatedItems = await service.find({})
+          assert.strictEqual(foundPaginatedItems.data.length, defaultPaginate, 'found paginated items')
 
-          const allItems = await service.remove(null, { query: { created: true } });
+          const allItems = await service.remove(null, {
+            query: { created: true }
+          })
 
-          assert.strictEqual(allItems.length, count, `removed all ${ count } items`);
+          assert.strictEqual(allItems.length, count, `removed all ${count} items`)
         } finally {
-          await service.remove(null, { query: { created: true }, paginate: false });
+          await service.remove(null, {
+            query: { created: true },
+            paginate: false
+          })
 
-          service.options.multi = multiBefore;
-          service.options.paginate = paginateBefore;
+          service.options.multi = multiBefore
+          service.options.paginate = paginateBefore
         }
-      });
+      })
 
@@ -214,3 +213,3 @@ test('.remove + id + query id', async () => {
           age: 12
-        });
+        })
 
@@ -220,30 +219,24 @@ try {
             query: { [idProp]: alice[idProp] }
-          });
-          throw new Error('Should never get here');
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
 
-        await service.remove(alice[idProp]);
-      });
-    });
+        await service.remove(alice[idProp])
+      })
+    })
 
     describe('update', () => {
       test('.update', async () => {
-        const originalData = { [idProp]: doug[idProp], name: 'Dougler' };
-        const originalCopy = Object.assign({}, originalData);
+        const originalData = { [idProp]: doug[idProp], name: 'Dougler' }
+        const originalCopy = Object.assign({}, originalData)
 
-        const data = await service.update(doug[idProp], originalData);
+        const data = await service.update(doug[idProp], originalData)
 
-        assert.deepStrictEqual(originalData, originalCopy,
-          'data was not modified'
-        );
-        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(),
-          `${idProp} id matches`
-        );
-        assert.strictEqual(data.name, 'Dougler', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
-      });
+        assert.deepStrictEqual(originalData, originalCopy, 'data was not modified')
+        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(), `${idProp} id matches`)
+        assert.strictEqual(data.name, 'Dougler', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
 
@@ -255,54 +248,50 @@ test('.update + $select', async () => {
           age: 10
-        };
+        }
 
         const data = await service.update(doug[idProp], originalData, {
-          query: { $select: [ 'name' ] }
-        });
+          query: { $select: ['name'] }
+        })
 
-        assert.strictEqual(data.name, 'Dougler', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
-      });
+        assert.strictEqual(data.name, 'Dougler', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
 
       test('.update + id + query', async () => {
         try {
-          await service.update(doug[idProp], {
-            name: 'Dougler'
-          }, {
-            query: { name: 'Tester' }
-          });
-          throw new Error('Should never get here');
+          await service.update(
+            doug[idProp],
+            {
+              name: 'Dougler'
+            },
+            {
+              query: { name: 'Tester' }
+            }
+          )
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
-      });
+      })
 
       test('.update + NotFound', async () => {
         try {
-          await service.update('568225fbfe21222432e836ff', { name: 'NotFound' });
-          throw new Error('Should never get here');
+          await service.update('568225fbfe21222432e836ff', {
+            name: 'NotFound'
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Error is a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Error is a NotFound Feathers error')
         }
-      });
+      })
 
       test('.update + query + NotFound', async () => {
-        const dave = await service.create({ name: 'Dave' });
+        const dave = await service.create({ name: 'Dave' })
         try {
-          await service.update(
-            dave[idProp],
-            { name: 'UpdatedDave' },
-            { query:  { name: 'NotDave' } }
-          );
-          throw new Error('Should never get here');
+          await service.update(dave[idProp], { name: 'UpdatedDave' }, { query: { name: 'NotDave' } })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Error is a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Error is a NotFound Feathers error')
         }
-        await service.remove(dave[idProp]);
-      });
+        await service.remove(dave[idProp])
+      })
 
@@ -313,73 +302,75 @@ test('.update + id + query id', async () => {
           age: 12
-        });
+        })
 
         try {
-          await service.update(doug[idProp], {
-            name: 'Dougler',
-            age: 33
-          }, {
-            query: { [idProp]: alice[idProp] }
-          });
-          throw new Error('Should never get here');
+          await service.update(
+            doug[idProp],
+            {
+              name: 'Dougler',
+              age: 33
+            },
+            {
+              query: { [idProp]: alice[idProp] }
+            }
+          )
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
 
-        await service.remove(alice[idProp]);
-      });
-    });
+        await service.remove(alice[idProp])
+      })
+    })
 
     describe('patch', () => {
       test('.patch', async () => {
-        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' };
-        const originalCopy = Object.assign({}, originalData);
+        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' }
+        const originalCopy = Object.assign({}, originalData)
 
-        const data = await service.patch(doug[idProp], originalData);
+        const data = await service.patch(doug[idProp], originalData)
 
-        assert.deepStrictEqual(originalData, originalCopy,
-          'original data was not modified'
-        );
-        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(),
-          `${idProp} id matches`
-        );
-        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches');
-        assert.strictEqual(data.age, 32, 'data.age matches');
-      });
+        assert.deepStrictEqual(originalData, originalCopy, 'original data was not modified')
+        assert.strictEqual(data[idProp].toString(), doug[idProp].toString(), `${idProp} id matches`)
+        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches')
+        assert.strictEqual(data.age, 32, 'data.age matches')
+      })
 
       test('.patch + $select', async () => {
-        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' };
+        const originalData = { [idProp]: doug[idProp], name: 'PatchDoug' }
 
         const data = await service.patch(doug[idProp], originalData, {
-          query: { $select: [ 'name' ] }
-        });
+          query: { $select: ['name'] }
+        })
 
-        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
-      });
+        assert.strictEqual(data.name, 'PatchDoug', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
+      })
 
       test('.patch + id + query', async () => {
         try {
-          await service.patch(doug[idProp], {
-            name: 'id patched doug'
-          }, {
-            query: { name: 'Tester' }
-          });
-          throw new Error('Should never get here');
+          await service.patch(
+            doug[idProp],
+            {
+              name: 'id patched doug'
+            },
+            {
+              query: { name: 'Tester' }
+            }
+          )
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
-      });
+      })
 
       test('.patch multiple', async () => {
         try {
-          await service.patch(null, {});
-          throw new Error('Should never get here');
+          await service.patch(null, {})
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'MethodNotAllowed',
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
             'Removing multiple without option set throws MethodNotAllowed'
-          );
+          )
         }
@@ -389,3 +380,3 @@
           query: { created: true }
-        };
+        }
         const dave = await service.create({
@@ -395,3 +386,3 @@ name: 'Dave',
           created: true
-        });
+        })
         const david = await service.create({
@@ -401,53 +392,61 @@ name: 'David',
           created: true
-        });
+        })
 
-        service.options.multi = [ 'patch' ];
+        service.options.multi = ['patch']
 
-        const data = await service.patch(null, {
-          age: 2
-        }, params);
+        const data = await service.patch(
+          null,
+          {
+            age: 2
+          },
+          params
+        )
 
-        assert.strictEqual(data.length, 2, 'returned two entries');
-        assert.strictEqual(data[0].age, 2, 'First entry age was updated');
-        assert.strictEqual(data[1].age, 2, 'Second entry age was updated');
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
 
-        await service.remove(dave[idProp]);
-        await service.remove(david[idProp]);
-      });
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
+      })
 
       test('.patch multiple no pagination', async () => {
         try {
-          await service.remove(doug[idProp]);
+          await service.remove(doug[idProp])
         } catch (error: any) {}
 
-        const count = 14;
-        const defaultPaginate = 10;
+        const count = 14
+        const defaultPaginate = 10
 
-        assert.ok(count > defaultPaginate, 'count is bigger than default pagination');
+        assert.ok(count > defaultPaginate, 'count is bigger than default pagination')
 
-        const multiBefore = service.options.multi;
-        const paginateBefore = service.options.paginate;
+        const multiBefore = service.options.multi
+        const paginateBefore = service.options.paginate
 
-        let ids: any[];
+        let ids: any[]
 
         try {
-          service.options.multi = true;
+          service.options.multi = true
           service.options.paginate = {
-            'default': defaultPaginate,
-            'max': 100
-          };
+            default: defaultPaginate,
+            max: 100
+          }
 
-          const emptyItems = await service.find({ paginate: false });
+          const emptyItems = await service.find({ paginate: false })
           assert.strictEqual(emptyItems.length, 0, 'no items before')
 
           const createdItems = await service.create(
-            Array.from(Array(count)).map((_, i) => ({ name: `name-${i}`, age: 3, created: true }))
-          );
-          assert.strictEqual(createdItems.length, count, `created ${count} items`);
-          ids = createdItems.map((item: any) => item[idProp]);
+            Array.from(Array(count)).map((_, i) => ({
+              name: `name-${i}`,
+              age: 3,
+              created: true
+            }))
+          )
+          assert.strictEqual(createdItems.length, count, `created ${count} items`)
+          ids = createdItems.map((item: any) => item[idProp])
 
-          const foundItems = await service.find({ paginate: false });
-          assert.strictEqual(foundItems.length, count, `created ${count} items`);
+          const foundItems = await service.find({ paginate: false })
+          assert.strictEqual(foundItems.length, count, `created ${count} items`)
 
-          const foundPaginatedItems = await service.find({});
+          const foundPaginatedItems = await service.find({})
           assert.strictEqual(foundPaginatedItems.data.length, defaultPaginate, 'found paginated data')
@@ -457,23 +456,21 @@
 
-          assert.strictEqual(allItems.length, count, `patched all ${ count } items`);
+          assert.strictEqual(allItems.length, count, `patched all ${count} items`)
         } finally {
-          service.options.multi = multiBefore;
-          service.options.paginate = paginateBefore;
+          service.options.multi = multiBefore
+          service.options.paginate = paginateBefore
           if (ids) {
-            await Promise.all(
-              ids.map(id => service.remove(id))
-            )
+            await Promise.all(ids.map((id) => service.remove(id)))
           }
         }
-      });
+      })
 
       test('.patch multi query same', async () => {
-        const service = app.service(serviceName);
-        const multiBefore = service.options.multi;
+        const service = app.service(serviceName)
+        const multiBefore = service.options.multi
 
-        service.options.multi = true;
+        service.options.multi = true
 
         const params = {
           query: { age: { $lt: 10 } }
-        };
+        }
         const dave = await service.create({
@@ -483,3 +480,3 @@ name: 'Dave',
           created: true
-        });
+        })
         const david = await service.create({
@@ -489,27 +486,31 @@ name: 'David',
           created: true
-        });
+        })
 
-        const data = await service.patch(null, {
-          age: 2
-        }, params);
+        const data = await service.patch(
+          null,
+          {
+            age: 2
+          },
+          params
+        )
 
-        assert.strictEqual(data.length, 2, 'returned two entries');
-        assert.strictEqual(data[0].age, 2, 'First entry age was updated');
-        assert.strictEqual(data[1].age, 2, 'Second entry age was updated');
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
 
-        await service.remove(dave[idProp]);
-        await service.remove(david[idProp]);
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
 
-        service.options.multi = multiBefore;
-      });
+        service.options.multi = multiBefore
+      })
 
       test('.patch multi query changed', async () => {
-        const service = app.service(serviceName);
-        const multiBefore = service.options.multi;
+        const service = app.service(serviceName)
+        const multiBefore = service.options.multi
 
-        service.options.multi = true;
+        service.options.multi = true
 
         const params = {
           query: { age: 10 }
-        };
+        }
         const dave = await service.create({
@@ -519,3 +520,3 @@ name: 'Dave',
           created: true
-        });
+        })
         const david = await service.create({
@@ -525,45 +526,43 @@ name: 'David',
           created: true
-        });
+        })
 
-        const data = await service.patch(null, {
-          age: 2
-        }, params);
+        const data = await service.patch(
+          null,
+          {
+            age: 2
+          },
+          params
+        )
 
-        assert.strictEqual(data.length, 2, 'returned two entries');
-        assert.strictEqual(data[0].age, 2, 'First entry age was updated');
-        assert.strictEqual(data[1].age, 2, 'Second entry age was updated');
+        assert.strictEqual(data.length, 2, 'returned two entries')
+        assert.strictEqual(data[0].age, 2, 'First entry age was updated')
+        assert.strictEqual(data[1].age, 2, 'Second entry age was updated')
 
-        await service.remove(dave[idProp]);
-        await service.remove(david[idProp]);
+        await service.remove(dave[idProp])
+        await service.remove(david[idProp])
 
-        service.options.multi = multiBefore;
-      });
+        service.options.multi = multiBefore
+      })
 
       test('.patch + NotFound', async () => {
         try {
-          await service.patch('568225fbfe21222432e836ff', { name: 'PatchDoug' });
-          throw new Error('Should never get here');
+          await service.patch('568225fbfe21222432e836ff', {
+            name: 'PatchDoug'
+          })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Error is a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Error is a NotFound Feathers error')
         }
-      });
+      })
 
       test('.patch + query + NotFound', async () => {
-        const dave = await service.create({ name: 'Dave' });
+        const dave = await service.create({ name: 'Dave' })
         try {
-          await service.patch(
-            dave[idProp],
-            { name: 'PatchedDave' },
-            { query:  { name: 'NotDave' } }
-          );
-          throw new Error('Should never get here');
+          await service.patch(dave[idProp], { name: 'PatchedDave' }, { query: { name: 'NotDave' } })
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Error is a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Error is a NotFound Feathers error')
         }
-        await service.remove(dave[idProp]);
-      });
+        await service.remove(dave[idProp])
+      })
 
@@ -574,20 +573,22 @@ test('.patch + id + query id', async () => {
           age: 12
-        });
+        })
 
         try {
-          await service.patch(doug[idProp], {
-            age: 33
-          }, {
-            query: { [idProp]: alice[idProp] }
-          });
-          throw new Error('Should never get here');
+          await service.patch(
+            doug[idProp],
+            {
+              age: 33
+            },
+            {
+              query: { [idProp]: alice[idProp] }
+            }
+          )
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'NotFound',
-            'Got a NotFound Feathers error'
-          );
+          assert.strictEqual(error.name, 'NotFound', 'Got a NotFound Feathers error')
         }
 
-        await service.remove(alice[idProp]);
-      });
-    });
+        await service.remove(alice[idProp])
+      })
+    })
 
@@ -599,15 +600,13 @@ describe('create', () => {
           age: 40
-        };
-        const originalCopy = Object.assign({}, originalData);
+        }
+        const originalCopy = Object.assign({}, originalData)
 
-        const data = await service.create(originalData);
+        const data = await service.create(originalData)
 
-        assert.deepStrictEqual(originalData, originalCopy,
-          'original data was not modified'
-        );
-        assert.ok(data instanceof Object, 'data is an object');
-        assert.strictEqual(data.name, 'Bill', 'data.name matches');
+        assert.deepStrictEqual(originalData, originalCopy, 'original data was not modified')
+        assert.ok(data instanceof Object, 'data is an object')
+        assert.strictEqual(data.name, 'Bill', 'data.name matches')
 
-        await service.remove(data[idProp]);
-      });
+        await service.remove(data[idProp])
+      })
 
@@ -618,22 +617,24 @@ test('.create + $select', async () => {
           age: 23
-        };
+        }
 
         const data = await service.create(originalData, {
-          query: { $select: [ 'name' ] }
-        });
+          query: { $select: ['name'] }
+        })
 
-        assert.strictEqual(data.name, 'William', 'data.name matches');
-        assert.ok(!data.age, 'data.age is falsy');
+        assert.strictEqual(data.name, 'William', 'data.name matches')
+        assert.ok(!data.age, 'data.age is falsy')
 
-        await service.remove(data[idProp]);
-      });
+        await service.remove(data[idProp])
+      })
 
       test('.create multi', async () => {
         try {
-          await service.create([], {});
-          throw new Error('Should never get here');
+          await service.create([], {})
+          throw new Error('Should never get here')
         } catch (error: any) {
-          assert.strictEqual(error.name, 'MethodNotAllowed',
+          assert.strictEqual(
+            error.name,
+            'MethodNotAllowed',
             'Removing multiple without option set throws MethodNotAllowed'
-          );
+          )
         }
@@ -650,54 +651,52 @@
           }
-        ];
+        ]
 
-        service.options.multi = [ 'create', 'patch' ];
+        service.options.multi = ['create', 'patch']
 
-        const data = await service.create(items);
+        const data = await service.create(items)
 
-        assert.ok(Array.isArray(data), 'data is an array');
-        assert.ok(typeof data[0][idProp] !== 'undefined', 'id is set');
-        assert.strictEqual(data[0].name, 'Gerald', 'first name matches');
-        assert.ok(typeof data[1][idProp] !== 'undefined', 'id is set');
-        assert.strictEqual(data[1].name, 'Herald', 'second name macthes');
+        assert.ok(Array.isArray(data), 'data is an array')
+        assert.ok(typeof data[0][idProp] !== 'undefined', 'id is set')
+        assert.strictEqual(data[0].name, 'Gerald', 'first name matches')
+        assert.ok(typeof data[1][idProp] !== 'undefined', 'id is set')
+        assert.strictEqual(data[1].name, 'Herald', 'second name macthes')
 
-        await service.remove(data[0][idProp]);
-        await service.remove(data[1][idProp]);
-      });
-    });
+        await service.remove(data[0][idProp])
+        await service.remove(data[1][idProp])
+      })
+    })
 
-    describe('doesn\'t call public methods internally', () => {
-      let throwing: any;
+    describe("doesn't call public methods internally", () => {
+      let throwing: any
 
       before(() => {
         throwing = Object.assign(Object.create(app.service(serviceName)), {
-          get store () {
-            return app.service(serviceName).store;
+          get store() {
+            return app.service(serviceName).store
           },
 
-          find () {
-            throw new Error('find method called');
+          find() {
+            throw new Error('find method called')
           },
-          get () {
-            throw new Error('get method called');
+          get() {
+            throw new Error('get method called')
           },
-          create () {
-            throw new Error('create method called');
+          create() {
+            throw new Error('create method called')
           },
-          update () {
-            throw new Error('update method called');
+          update() {
+            throw new Error('update method called')
           },
-          patch () {
-            throw new Error('patch method called');
+          patch() {
+            throw new Error('patch method called')
           },
-          remove () {
-            throw new Error('remove method called');
+          remove() {
+            throw new Error('remove method called')
           }
-        });
-      });
+        })
+      })
 
-      test('internal .find', () => app.service(serviceName).find.call(throwing));
+      test('internal .find', () => app.service(serviceName).find.call(throwing))
 
-      test('internal .get', () =>
-        service.get.call(throwing, doug[idProp])
-      );
+      test('internal .get', () => service.get.call(throwing, doug[idProp]))
 
@@ -708,6 +707,6 @@ test('internal .create', async () => {
           age: 25
-        });
+        })
 
-        await service.remove(bob[idProp]);
-      });
+        await service.remove(bob[idProp])
+      })
 
@@ -717,4 +716,3 @@ test('internal .update', () =>
           name: 'Dougler'
-        })
-      );
+        }))
 
@@ -724,10 +722,7 @@ test('internal .patch', () =>
           name: 'PatchDoug'
-        })
-      );
+        }))
 
-      test('internal .remove', () =>
-        service.remove.call(throwing, doug[idProp])
-      );
-    });
-  });
-};
+      test('internal .remove', () => service.remove.call(throwing, doug[idProp]))
+    })
+  })
+}

src/syntax.ts

@@ -1,41 +0,41 @@
-import assert from 'assert';
-import { AdapterSyntaxTest } from './declarations';
+import assert from 'assert'
+import { AdapterSyntaxTest } from './declarations'
 
 export default (test: AdapterSyntaxTest, app: any, _errors: any, serviceName: string, idProp: string) => {
   describe('Query Syntax', () => {
-    let bob: any;
-    let alice: any;
-    let doug: any;
-    let service: any;
+    let bob: any
+    let alice: any
+    let doug: any
+    let service: any
 
     beforeEach(async () => {
-      service = app.service(serviceName);
+      service = app.service(serviceName)
       bob = await app.service(serviceName).create({
         name: 'Bob',
         age: 25
-      });
+      })
       doug = await app.service(serviceName).create({
         name: 'Doug',
         age: 32
-      });
+      })
       alice = await app.service(serviceName).create({
         name: 'Alice',
         age: 19
-      });
-    });
+      })
+    })
 
     afterEach(async () => {
-      await service.remove(bob[idProp]);
-      await service.remove(alice[idProp]);
-      await service.remove(doug[idProp]);
-    });
+      await service.remove(bob[idProp])
+      await service.remove(alice[idProp])
+      await service.remove(doug[idProp])
+    })
 
     test('.find + equal', async () => {
-      const params = { query: { name: 'Alice' } };
-      const data = await service.find(params);
+      const params = { query: { name: 'Alice' } }
+      const data = await service.find(params)
 
-      assert.ok(Array.isArray(data));
-      assert.strictEqual(data.length, 1);
-      assert.strictEqual(data[0].name, 'Alice');
-    });
+      assert.ok(Array.isArray(data))
+      assert.strictEqual(data.length, 1)
+      assert.strictEqual(data[0].name, 'Alice')
+    })
 
@@ -45,6 +45,6 @@ test('.find + equal multiple', async () => {
         query: { name: 'Alice', age: 20 }
-      });
+      })
 
-      assert.strictEqual(data.length, 0);
-    });
+      assert.strictEqual(data.length, 0)
+    })
 
@@ -57,8 +57,8 @@ describe('special filters', () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 3);
-        assert.strictEqual(data[0].name, 'Alice');
-        assert.strictEqual(data[1].name, 'Bob');
-        assert.strictEqual(data[2].name, 'Doug');
+        assert.strictEqual(data.length, 3)
+        assert.strictEqual(data[0].name, 'Alice')
+        assert.strictEqual(data[1].name, 'Bob')
+        assert.strictEqual(data[2].name, 'Doug')
 
@@ -69,9 +69,9 @@ data = await service.find({
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 3);
-        assert.strictEqual(data[0].name, 'Doug');
-        assert.strictEqual(data[1].name, 'Bob');
-        assert.strictEqual(data[2].name, 'Alice');
-      });
+        assert.strictEqual(data.length, 3)
+        assert.strictEqual(data[0].name, 'Doug')
+        assert.strictEqual(data[1].name, 'Bob')
+        assert.strictEqual(data[2].name, 'Alice')
+      })
 
@@ -83,9 +83,9 @@ test('.find + $sort + string', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 3);
-        assert.strictEqual(data[0].name, 'Alice');
-        assert.strictEqual(data[1].name, 'Bob');
-        assert.strictEqual(data[2].name, 'Doug');
-      });
+        assert.strictEqual(data.length, 3)
+        assert.strictEqual(data[0].name, 'Alice')
+        assert.strictEqual(data[1].name, 'Bob')
+        assert.strictEqual(data[2].name, 'Doug')
+      })
 
@@ -97,6 +97,6 @@ test('.find + $limit', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-      });
+        assert.strictEqual(data.length, 2)
+      })
 
@@ -108,6 +108,6 @@ test('.find + $limit 0', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 0);
-      });
+        assert.strictEqual(data.length, 0)
+      })
 
@@ -120,8 +120,8 @@ test('.find + $skip', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-        assert.strictEqual(data[0].name, 'Bob');
-        assert.strictEqual(data[1].name, 'Doug');
-      });
+        assert.strictEqual(data.length, 2)
+        assert.strictEqual(data[0].name, 'Bob')
+        assert.strictEqual(data[1].name, 'Doug')
+      })
 
@@ -134,8 +134,8 @@ test('.find + $select', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 1);
-        assert.strictEqual(data[0].name, 'Alice');
-        assert.strictEqual(data[0].age, undefined);
-      });
+        assert.strictEqual(data.length, 1)
+        assert.strictEqual(data[0].name, 'Alice')
+        assert.strictEqual(data[0].age, undefined)
+      })
 
@@ -145,14 +145,11 @@ test('.find + $or', async () => {
           query: {
-            $or: [
-              { name: 'Alice' },
-              { name: 'Bob' }
-            ],
+            $or: [{ name: 'Alice' }, { name: 'Bob' }],
             $sort: { name: 1 }
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-        assert.strictEqual(data[0].name, 'Alice');
-        assert.strictEqual(data[1].name, 'Bob');
-      });
+        assert.strictEqual(data.length, 2)
+        assert.strictEqual(data[0].name, 'Alice')
+        assert.strictEqual(data[1].name, 'Bob')
+      })
 
@@ -167,8 +164,8 @@ test('.find + $in', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-        assert.strictEqual(data[0].name, 'Alice');
-        assert.strictEqual(data[1].name, 'Bob');
-      });
+        assert.strictEqual(data.length, 2)
+        assert.strictEqual(data[0].name, 'Alice')
+        assert.strictEqual(data[1].name, 'Bob')
+      })
 
@@ -179,10 +176,10 @@ test('.find + $nin', async () => {
             name: {
-              $nin: [ 'Alice', 'Bob' ]
+              $nin: ['Alice', 'Bob']
             }
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 1);
-        assert.strictEqual(data[0].name, 'Doug');
-      });
+        assert.strictEqual(data.length, 1)
+        assert.strictEqual(data[0].name, 'Doug')
+      })
 
@@ -196,6 +193,6 @@ test('.find + $lt', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-      });
+        assert.strictEqual(data.length, 2)
+      })
 
@@ -209,6 +206,6 @@ test('.find + $lte', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-      });
+        assert.strictEqual(data.length, 2)
+      })
 
@@ -222,6 +219,6 @@ test('.find + $gt', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 1);
-      });
+        assert.strictEqual(data.length, 1)
+      })
 
@@ -235,6 +232,6 @@ test('.find + $gte', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-      });
+        assert.strictEqual(data.length, 2)
+      })
 
@@ -248,7 +245,7 @@ test('.find + $ne', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(data.length, 2);
-      });
-    });
+        assert.strictEqual(data.length, 2)
+      })
+    })
 
@@ -264,10 +261,10 @@ test('.find + $gt + $lt + $sort', async () => {
         }
-      };
+      }
 
-      const data = await service.find(params);
+      const data = await service.find(params)
 
-      assert.strictEqual(data.length, 2);
-      assert.strictEqual(data[0].name, 'Alice');
-      assert.strictEqual(data[1].name, 'Bob');
-    });
+      assert.strictEqual(data.length, 2)
+      assert.strictEqual(data[0].name, 'Alice')
+      assert.strictEqual(data[1].name, 'Bob')
+    })
 
@@ -288,10 +285,10 @@ test('.find + $or nested + $sort', async () => {
         }
-      };
+      }
 
-      const data = await service.find(params);
+      const data = await service.find(params)
 
-      assert.strictEqual(data.length, 2);
-      assert.strictEqual(data[0].name, 'Alice');
-      assert.strictEqual(data[1].name, 'Doug');
-    });
+      assert.strictEqual(data.length, 2)
+      assert.strictEqual(data[0].name, 'Alice')
+      assert.strictEqual(data[1].name, 'Doug')
+    })
 
@@ -304,7 +301,7 @@ describe('params.adapter', () => {
           }
-        });
+        })
 
-        assert.strictEqual(page.limit, 3);
-        assert.strictEqual(page.skip, 0);
-      });
+        assert.strictEqual(page.limit, 3)
+        assert.strictEqual(page.skip, 0)
+      })
 
@@ -321,3 +318,3 @@ test('params.adapter + multi', async () => {
           }
-        ];
+        ]
         const multiParams = {
@@ -327,14 +324,14 @@ adapter: {
           }
-        };
-        const users = await service.create(items, multiParams);
+        }
+        const users = await service.create(items, multiParams)
 
-        assert.strictEqual(users.length, 2);
+        assert.strictEqual(users.length, 2)
 
-        await service.remove(users[0][idProp]);
-        await service.remove(users[1][idProp]);
+        await service.remove(users[0][idProp])
+        await service.remove(users[1][idProp])
         await assert.rejects(() => service.patch(null, { age: 2 }, multiParams), {
           message: 'Can not patch multiple entries'
-        });
-      });
-    });
+        })
+      })
+    })
 
@@ -346,8 +343,8 @@ describe('paginate', function () {
           max: 2
-        };
-      });
+        }
+      })
 
       afterEach(() => {
-        service.options.paginate = {};
-      });
+        service.options.paginate = {}
+      })
 
@@ -357,9 +354,9 @@ test('.find + paginate', async () => {
           query: { $sort: { name: -1 } }
-        });
+        })
 
-        assert.strictEqual(page.total, 3);
-        assert.strictEqual(page.limit, 1);
-        assert.strictEqual(page.skip, 0);
-        assert.strictEqual(page.data[0].name, 'Doug');
-      });
+        assert.strictEqual(page.total, 3)
+        assert.strictEqual(page.limit, 1)
+        assert.strictEqual(page.skip, 0)
+        assert.strictEqual(page.data[0].name, 'Doug')
+      })
 
@@ -372,9 +369,9 @@ test('.find + paginate + query', async () => {
           }
-        });
+        })
 
-        assert.strictEqual(page.total, 1);
-        assert.strictEqual(page.limit, 1);
-        assert.strictEqual(page.skip, 0);
-        assert.strictEqual(page.data[0].name, 'Doug');
-      });
+        assert.strictEqual(page.total, 1)
+        assert.strictEqual(page.limit, 1)
+        assert.strictEqual(page.skip, 0)
+        assert.strictEqual(page.data[0].name, 'Doug')
+      })
 
@@ -388,12 +385,12 @@ test('.find + paginate + $limit + $skip', async () => {
           }
-        };
+        }
 
-        const page = await service.find(params);
+        const page = await service.find(params)
 
-        assert.strictEqual(page.total, 3);
-        assert.strictEqual(page.limit, 2);
-        assert.strictEqual(page.skip, 1);
-        assert.strictEqual(page.data[0].name, 'Bob');
-        assert.strictEqual(page.data[1].name, 'Alice');
-      });
+        assert.strictEqual(page.total, 3)
+        assert.strictEqual(page.limit, 2)
+        assert.strictEqual(page.skip, 1)
+        assert.strictEqual(page.data[0].name, 'Bob')
+        assert.strictEqual(page.data[1].name, 'Alice')
+      })
 
@@ -403,21 +400,21 @@ test('.find + paginate + $limit 0', async () => {
           query: { $limit: 0 }
-        });
+        })
 
-        assert.strictEqual(page.total, 3);
-        assert.strictEqual(page.data.length, 0);
-      });
+        assert.strictEqual(page.total, 3)
+        assert.strictEqual(page.data.length, 0)
+      })
 
       test('.find + paginate + params', async () => {
-        const page = await service.find({ paginate: { default: 3 } });
+        const page = await service.find({ paginate: { default: 3 } })
 
-        assert.strictEqual(page.limit, 3);
-        assert.strictEqual(page.skip, 0);
+        assert.strictEqual(page.limit, 3)
+        assert.strictEqual(page.skip, 0)
 
-        const results = await service.find({ paginate: false });
+        const results = await service.find({ paginate: false })
 
-        assert.ok(Array.isArray(results));
-        assert.strictEqual(results.length, 3);
-      });
-    });
-  });
-};
+        assert.ok(Array.isArray(results))
+        assert.strictEqual(results.length, 3)
+      })
+    })
+  })
+}

No alert changes

Improved metrics

Lines of code

2148

increased by0.23%

Worsened metrics

Total package byte prevSize

139830

decreased by-0.03%

No dependency changes