@unchainedshop/api 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/api",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -9,8 +9,8 @@
     "build": "tsc -b",
     "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
+    "test": "tsx --test",
+    "test:watch": "tsx --test --watch"
   },
   "repository": {
     "type": "git",
@@ -37,8 +37,8 @@
     "connect-mongo": ">= 5.1.0 < 6",
     "express": ">= 5.0 < 6",
     "express-session": ">= 1.18 < 2",
-    "graphql-yoga": ">= 5.9 < 6.0",
     "fastify": ">= 5.2 < 6",
+    "graphql-yoga": ">= 5.9 < 6.0",
     "passport": ">= 0.7 < 1"
   },
   "peerDependenciesMeta": {
@@ -92,9 +92,8 @@
     "express": "^5.0.1",
     "express-session": "^1.18.1",
     "fastify": "^5.2.1",
-    "jest": "^29.7.0",
     "passport": "^0.7.0",
-    "ts-jest": "^29.2.5",
+    "tsx": "^4.19.2",
     "typescript": "^5.7.3"
   }
 }

package/tests/api-index.test.ts

@@ -1,4 +1,6 @@
 // Import the function to be tested.
+import { describe, it, mock } from 'node:test';
+import assert from 'node:assert';
 import { admin } from '../src/roles/admin.js';
 import { actions } from '../src/roles/index.js';
 import { checkAction, ensureActionExists, ensureIsFunction } from '../src/acl.js';
@@ -8,24 +10,28 @@ import { Roles } from '@unchainedshop/roles';
 describe('API', () => {
   describe('roles', () => {
     const role = {
-      allow: import.meta.jest.fn(),
+      allow: mock.fn(),
     };
 
     it('creates the admin role and grants permissions to all actions', () => {
       admin(role, actions);
       for (const actionName of Object.keys(actions)) {
-        expect(role.allow).toHaveBeenCalledWith(actions[actionName], expect.any(Function));
+        assert.equal(
+          role.allow.mock.calls.some((call) => call.arguments[0] === actions[actionName]),
+          true,
+          "action wasn't granted",
+        );
       }
     });
   });
 
   describe('ensureActionExists', () => {
     it('should throw a PermissionSystemError if the action is undefined', () => {
-      expect(() => ensureActionExists(undefined, {})).toThrow(PermissionSystemError);
+      assert.throws(() => ensureActionExists(undefined, {}), PermissionSystemError);
     });
 
     it('should not throw an error if the action is defined', () => {
-      expect(() => ensureActionExists('some action', {})).not.toThrow();
+      assert.doesNotThrow(() => ensureActionExists('some action', {}));
     });
   });
 
@@ -34,14 +40,14 @@ describe('API', () => {
       const action = 'some action';
       const options = { showKey: true };
       const key = 'some key';
-      expect(() => ensureIsFunction(null, action, options, key)).toThrow(PermissionSystemError);
+      assert.throws(() => ensureIsFunction(null, action, options, key), PermissionSystemError);
     });
 
     it('should not throw an error if the provided value is a function', () => {
       const action = 'some action';
       const options = { showKey: true };
       const key = 'some key';
-      expect(() =>
+      assert.doesNotThrow(() =>
         ensureIsFunction(
           () => {
             /**/
@@ -50,30 +56,31 @@ describe('API', () => {
           options,
           key,
         ),
-      ).not.toThrow();
+      );
     });
   });
 
   describe('checkAction', () => {
     it('should throw a NoPermissionError if the user does not have permission to perform the action', async () => {
-      Roles.userHasPermission = import.meta.jest.fn(async () => false);
+      Roles.userHasPermission = mock.fn(async () => false);
 
       const context = { userId: '123' };
       const action = 'some action';
       const args: any = [];
       const options = { key: 'some key' };
 
-      return expect(checkAction(context, action, args, options)).rejects.toThrow(NoPermissionError);
+      return assert.rejects(checkAction(context, action, args, options), NoPermissionError);
     });
 
     it('should not throw an error if the user has permission to perform the action', async () => {
-      Roles.userHasPermission = import.meta.jest.fn(async () => true);
+      Roles.userHasPermission = mock.fn(async () => true);
+
       const context = { userId: '123' };
       const action = 'some action';
       const args: any = {};
       const options = { key: 'some key' };
 
-      return expect(checkAction(context, action, args, options)).resolves.not.toThrow();
+      return assert.doesNotReject(checkAction(context, action, args, options));
     });
   });
 });

package/jest.config.js

@@ -1,17 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-export default {
-  preset: 'ts-jest/presets/default-esm', // or other ESM presets
-  testEnvironment: 'node',
-  extensionsToTreatAsEsm: ['.ts'],
-  transform: {
-    '^.+\\.tsx?$': [
-      'ts-jest',
-      {
-        useESM: true,
-      },
-    ],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-};