feathers-adapter-vitest 0.0.2

package/dist/syntax.js

@@ -0,0 +1,354 @@
+import assert from 'node:assert';
+import { describe, beforeEach, afterEach } from 'vitest';
+export default (test, app, _errors, serviceName, idProp) => {
+    describe('Query Syntax', () => {
+        let bob;
+        let alice;
+        let doug;
+        let service;
+        beforeEach(async () => {
+            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]);
+        });
+        test('.find + equal', async () => {
+            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');
+        });
+        test('.find + equal multiple', async () => {
+            const data = await service.find({
+                query: { name: 'Alice', age: 20 },
+            });
+            assert.strictEqual(data.length, 0);
+        });
+        describe('special filters', () => {
+            test('.find + $sort', async () => {
+                let data = await service.find({
+                    query: {
+                        $sort: { name: 1 },
+                    },
+                });
+                assert.strictEqual(data.length, 3);
+                assert.strictEqual(data[0].name, 'Alice');
+                assert.strictEqual(data[1].name, 'Bob');
+                assert.strictEqual(data[2].name, 'Doug');
+                data = await service.find({
+                    query: {
+                        $sort: { name: -1 },
+                    },
+                });
+                assert.strictEqual(data.length, 3);
+                assert.strictEqual(data[0].name, 'Doug');
+                assert.strictEqual(data[1].name, 'Bob');
+                assert.strictEqual(data[2].name, 'Alice');
+            });
+            test('.find + $sort + string', async () => {
+                const data = await service.find({
+                    query: {
+                        $sort: { name: '1' },
+                    },
+                });
+                assert.strictEqual(data.length, 3);
+                assert.strictEqual(data[0].name, 'Alice');
+                assert.strictEqual(data[1].name, 'Bob');
+                assert.strictEqual(data[2].name, 'Doug');
+            });
+            test('.find + $limit', async () => {
+                const data = await service.find({
+                    query: {
+                        $limit: 2,
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+            });
+            test('.find + $limit 0', async () => {
+                const data = await service.find({
+                    query: {
+                        $limit: 0,
+                    },
+                });
+                assert.strictEqual(data.length, 0);
+            });
+            test('.find + $skip', async () => {
+                const data = await service.find({
+                    query: {
+                        $sort: { name: 1 },
+                        $skip: 1,
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+                assert.strictEqual(data[0].name, 'Bob');
+                assert.strictEqual(data[1].name, 'Doug');
+            });
+            test('.find + $select', async () => {
+                const data = await service.find({
+                    query: {
+                        name: 'Alice',
+                        $select: ['name'],
+                    },
+                });
+                assert.strictEqual(data.length, 1);
+                assert.ok(idProp in data[0], 'data has id');
+                assert.strictEqual(data[0].name, 'Alice');
+                assert.strictEqual(data[0].age, undefined);
+            });
+            test('.find + $or', async () => {
+                const data = await service.find({
+                    query: {
+                        $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');
+            });
+            test('.find + $in', async () => {
+                const data = await service.find({
+                    query: {
+                        name: {
+                            $in: ['Alice', 'Bob'],
+                        },
+                        $sort: { name: 1 },
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+                assert.strictEqual(data[0].name, 'Alice');
+                assert.strictEqual(data[1].name, 'Bob');
+            });
+            test('.find + $nin', async () => {
+                const data = await service.find({
+                    query: {
+                        name: {
+                            $nin: ['Alice', 'Bob'],
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 1);
+                assert.strictEqual(data[0].name, 'Doug');
+            });
+            test('.find + $lt', async () => {
+                const data = await service.find({
+                    query: {
+                        age: {
+                            $lt: 30,
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+            });
+            test('.find + $lte', async () => {
+                const data = await service.find({
+                    query: {
+                        age: {
+                            $lte: 25,
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+            });
+            test('.find + $gt', async () => {
+                const data = await service.find({
+                    query: {
+                        age: {
+                            $gt: 30,
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 1);
+            });
+            test('.find + $gte', async () => {
+                const data = await service.find({
+                    query: {
+                        age: {
+                            $gte: 25,
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+            });
+            test('.find + $ne', async () => {
+                const data = await service.find({
+                    query: {
+                        age: {
+                            $ne: 25,
+                        },
+                    },
+                });
+                assert.strictEqual(data.length, 2);
+            });
+        });
+        test('.find + $gt + $lt + $sort', async () => {
+            const params = {
+                query: {
+                    age: {
+                        $gt: 18,
+                        $lt: 30,
+                    },
+                    $sort: { name: 1 },
+                },
+            };
+            const data = await service.find(params);
+            assert.strictEqual(data.length, 2);
+            assert.strictEqual(data[0].name, 'Alice');
+            assert.strictEqual(data[1].name, 'Bob');
+        });
+        test('.find + $or nested + $sort', async () => {
+            const params = {
+                query: {
+                    $or: [
+                        { name: 'Doug' },
+                        {
+                            age: {
+                                $gte: 18,
+                                $lt: 25,
+                            },
+                        },
+                    ],
+                    $sort: { name: 1 },
+                },
+            };
+            const data = await service.find(params);
+            assert.strictEqual(data.length, 2);
+            assert.strictEqual(data[0].name, 'Alice');
+            assert.strictEqual(data[1].name, 'Doug');
+        });
+        test('.find + $and', async () => {
+            const params = {
+                query: {
+                    $and: [{ age: 19 }],
+                    $sort: { name: 1 },
+                },
+            };
+            const data = await service.find(params);
+            assert.strictEqual(data.length, 1);
+            assert.strictEqual(data[0].name, 'Alice');
+        });
+        test('.find + $and + $or', async () => {
+            const params = {
+                query: {
+                    $and: [{ $or: [{ name: 'Alice' }] }],
+                    $sort: { name: 1 },
+                },
+            };
+            const data = await service.find(params);
+            assert.strictEqual(data.length, 1);
+            assert.strictEqual(data[0].name, 'Alice');
+        });
+        describe('params.adapter', () => {
+            test('params.adapter + paginate', async () => {
+                const page = await service.find({
+                    adapter: {
+                        paginate: { default: 3 },
+                    },
+                });
+                assert.strictEqual(page.limit, 3);
+                assert.strictEqual(page.skip, 0);
+            });
+            test('params.adapter + multi', async () => {
+                const items = [
+                    {
+                        name: 'Garald',
+                        age: 200,
+                    },
+                    {
+                        name: 'Harald',
+                        age: 24,
+                    },
+                ];
+                const multiParams = {
+                    adapter: {
+                        multi: ['create'],
+                    },
+                };
+                const users = await service.create(items, multiParams);
+                assert.strictEqual(users.length, 2);
+                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',
+                });
+            });
+        });
+        describe('paginate', function () {
+            beforeEach(() => {
+                service.options.paginate = {
+                    default: 1,
+                    max: 2,
+                };
+            });
+            afterEach(() => {
+                service.options.paginate = {};
+            });
+            test('.find + paginate', async () => {
+                const page = await service.find({
+                    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');
+            });
+            test('.find + paginate + query', async () => {
+                const page = await service.find({
+                    query: {
+                        $sort: { name: -1 },
+                        name: 'Doug',
+                    },
+                });
+                assert.strictEqual(page.total, 1);
+                assert.strictEqual(page.limit, 1);
+                assert.strictEqual(page.skip, 0);
+                assert.strictEqual(page.data[0].name, 'Doug');
+            });
+            test('.find + paginate + $limit + $skip', async () => {
+                const params = {
+                    query: {
+                        $skip: 1,
+                        $limit: 4,
+                        $sort: { name: -1 },
+                    },
+                };
+                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');
+            });
+            test('.find + paginate + $limit 0', async () => {
+                const page = await service.find({
+                    query: { $limit: 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 } });
+                assert.strictEqual(page.limit, 3);
+                assert.strictEqual(page.skip, 0);
+                const results = await service.find({ paginate: false });
+                assert.ok(Array.isArray(results));
+                assert.strictEqual(results.length, 3);
+            });
+        });
+    });
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "feathers-adapter-vitest",
+  "version": "0.0.2",
+  "description": "Feathers shared database adapter test suite with vitest",
+  "homepage": "https://feathersjs.com",
+  "keywords": [
+    "feathers"
+  ],
+  "license": "MIT",
+  "author": "Feathers Community",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/feathers-community/feathers-adapter-vitest.git"
+  },
+  "bugs": {
+    "url": "https://github.com/feathers-community/feathers-adapter-vitest/issues"
+  },
+  "type": "module",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/feathers"
+  },
+  "engines": {
+    "node": ">= 22"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "src/**",
+    "dist/**"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@feathersjs/feathers": "^5.0.35"
+  },
+  "devDependencies": {
+    "@feathers-community/eslint-config": "^0.0.8",
+    "@tsconfig/node22": "^22.0.2",
+    "@types/node": "^24.3.1",
+    "eslint": "^9.35.0",
+    "shx": "^0.4.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint",
+    "test": "vitest run"
+  }
+}

package/src/basic.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert'
+import { describe, beforeEach, it } from 'vitest'
+import type { AdapterBasicTest } from './declarations.js'
+import type { Application } from '@feathersjs/feathers'
+
+type BasicTestOptions = {
+  app: Application
+  test: AdapterBasicTest
+  serviceName: string
+  idProp: string
+}
+
+export default (options: BasicTestOptions) => {
+  const { test, app, serviceName, idProp } = options
+
+  describe('Basic Functionality', () => {
+    let service: any
+
+    beforeEach(() => {
+      service = app.service(serviceName)
+    })
+
+    it('.id', () => {
+      assert.strictEqual(
+        service.id,
+        idProp,
+        'id property is set to expected name',
+      )
+    })
+
+    test('.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"',
+      )
+    })
+
+    describe('Raw Methods', () => {
+      test('._get', () => {
+        assert.strictEqual(typeof service._get, 'function')
+      })
+
+      test('._find', () => {
+        assert.strictEqual(typeof service._find, 'function')
+      })
+
+      test('._create', () => {
+        assert.strictEqual(typeof service._create, 'function')
+      })
+
+      test('._update', () => {
+        assert.strictEqual(typeof service._update, 'function')
+      })
+
+      test('._patch', () => {
+        assert.strictEqual(typeof service._patch, 'function')
+      })
+
+      test('._remove', () => {
+        assert.strictEqual(typeof service._remove, 'function')
+      })
+    })
+  })
+}

package/src/declarations.ts

@@ -0,0 +1,104 @@
+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 AdapterTestName =
+  | AdapterBasicTestName
+  | AdapterMethodsTestName
+  | AdapterSyntaxTestName
+
+export type AdapterTestMap = Record<AdapterTestName, boolean>
+
+export type AdapterBasicTestName =
+  | '.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'
+  | '.create ignores query'
+  | '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'
+  | '.find + $and'
+  | '.find + $and + $or'
+  | 'params.adapter + paginate'
+  | 'params.adapter + multi'
+  | '.find + paginate'
+  | '.find + paginate + query'
+  | '.find + paginate + $limit + $skip'
+  | '.find + paginate + $limit 0'
+  | '.find + paginate + params'

package/src/index.ts

@@ -0,0 +1,54 @@
+import type { Application } from '@feathersjs/feathers'
+import basicTests from './basic.js'
+import type { AdapterTestMap, AdapterTestName } from './declarations.js'
+import methodTests from './methods.js'
+import syntaxTests from './syntax.js'
+import { describe, it, afterAll } from 'vitest'
+
+export type TestSuiteOptions = {
+  app: Application
+  serviceName: string
+  /**
+   * @default 'id'
+   */
+  idProp?: string
+}
+
+export const defineTestSuite = (testMap?: AdapterTestMap) => {
+  return (options: TestSuiteOptions) => {
+    const { app, serviceName, idProp = 'id' } = options
+
+    const skippedTests: AdapterTestName[] = []
+    const allTests: AdapterTestName[] = []
+
+    const test = (name: AdapterTestName, runner: any) => {
+      const skip = testMap ? !testMap[name] : false
+      const its = skip ? it.skip : it
+
+      if (skip) {
+        skippedTests.push(name)
+      }
+
+      allTests.push(name)
+
+      its(name, runner)
+    }
+
+    describe(`Adapter tests for '${serviceName}' service with '${idProp}' id property`, () => {
+      afterAll(() => {
+        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, '  '))
+        }
+      })
+
+      basicTests({ test, app, serviceName, idProp })
+      methodTests({ test, app, serviceName, idProp })
+      syntaxTests({ test, app, serviceName, idProp })
+    })
+  }
+}
+
+export * from './declarations.js'