Fix Mongoose 9 pre-save hook incompatibility causing all integration tests to fail

.github/workflows/test.yml

@@ -0,0 +1,42 @@
+name: Tests
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: ["**"]
+
+jobs:
+  test:
+    name: Node.js ${{ matrix.node-version }} / MongoDB ${{ matrix.mongodb-version }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x, 22.x]
+        mongodb-version: ["6.0", "7.0", "8.0"]
+
+    permissions:
+      contents: read
+
+    services:
+      mongodb:
+        image: mongo:${{ matrix.mongodb-version }}
+        ports:
+          - 27017:27017
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests (unit + integration)
+        run: npm test

Makefile

@@ -1,6 +1,5 @@
 test:
 	@./node_modules/.bin/mocha --reporter spec
-	@./node_modules/.bin/jshint
 
 
 .PHONY: test

lib/basic.js

@@ -12,9 +12,6 @@ module.exports = function (schema, options) {
             return model.findOne(queryParameters);
         };
     const schemaFields = {};
-    if (!schema.path(options.usernameField)) {
-        schemaFields[options.usernameField] = {type: String, unique: options.usernameUnique};
-    }
     if (!schema.path(options.usernameField)) {
         schemaFields[options.usernameField] = {
             type: String,
@@ -37,15 +34,15 @@ module.exports = function (schema, options) {
             full_name += this['first_name'] + " ";
         if (this['last_name'])
             full_name += this['last_name'];
-        return full_name;
+        return full_name.trim();
     };
 
 
-    schema.pre("save", function (next) {
-        if (this.isNew) {
-            this.username= this.username.toLowerCase();
+    schema.pre("save", function () {
+        var usernameField = options.usernameField;
+        if (this.isNew && usernameField && typeof this[usernameField] === 'string') {
+            this[usernameField] = this[usernameField].toLowerCase();
         }
-        return next();
     });
 
 

lib/email.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const uuidv4 = require('uuid/v4');
+const { v4: uuidv4 } = require('uuid');
 
 
 module.exports = function (schema) {
@@ -46,15 +46,15 @@ module.exports = function (schema) {
         });
     };
 
-    schema.methods.setPrimaryEmail = function (email) {
+    schema.methods.setPrimaryEmail = async function (email) {
         var currentPrimaryEmail = this['email'];
         var newPrimaryEmail = this.getEmail(email);
 
         if (!newPrimaryEmail) throw new Error('Email does not exist');
 
-        if (currentPrimaryEmail !== newPrimaryEmail) {
+        if (currentPrimaryEmail !== email) {
             this['email'] = email;
-            this.save();
+            await this.save();
         }
         return newPrimaryEmail;
     };
@@ -69,20 +69,18 @@ module.exports = function (schema) {
             return false;
         }
     };
-    schema.methods.sendVerificationToken = function (email, callback) {
+
+    schema.methods.sendVerificationToken = async function (email) {
         var email_doc = (typeof email === 'string' ? this.getEmail(email) : email);
         if (!email_doc) {
-            return callback(email, null);
+            throw new Error('Email not found');
         }
-        if(email_doc.verified === true){
-            return callback(null, null);
+        if (email_doc.verified === true) {
+            return null;
         }
         if (email_doc.token === undefined) {
-            return callback(email, null);
+            throw new Error('Token not available');
         }
-
-
-        return callback(email_doc.address, email_doc.token);
+        return {address: email_doc.address, token: email_doc.token};
     };
 };
-

lib/verify.js

@@ -9,24 +9,22 @@ module.exports = function (model) {
     }
     const User = model;
 
-    return function (req, res, next) {
-        User.findOne({'emails.token': req.params.token}, 'emails', function (err, user) {
-            if (err) {
-                next(err);
-                return;
-            }
+    return async function (req, res, next) {
+        try {
+            const user = await User.findOne({'emails.token': req.params.token}, 'emails');
             if (user === null) {
-                next(new Error('Token invalid'));
-                return;
+                return next(new Error('Invalid token'));
             }
             var email = user.emails.find(function (email) {
                 return email['token'] === req.params.token;
             });
 
             email.token = undefined;
             email.verified = true;
-            user.save();
-            next();
-        });
+            await user.save();
+            return next();
+        } catch (err) {
+            return next(err);
+        }
     };
 };