nodejs-quickstart-structure 2.0.1 → 2.1.0

package/templates/common/auth/ts/middleware/authMiddleware.spec.ts.ejs

@@ -0,0 +1,128 @@
+<%_ if (architecture === 'Clean Architecture') { _%>
+import { authMiddleware } from '@/infrastructure/webserver/middleware/authMiddleware';
+import { JwtService } from '@/infrastructure/auth/jwtService';
+<%_ } else { _%>
+import { authMiddleware } from '@/middleware/authMiddleware';
+import { JwtService } from '@/services/jwtService';
+<%_ } _%>
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { Request, Response, NextFunction } from 'express';
+
+<%_ if (architecture === 'Clean Architecture') { _%>
+jest.mock('@/infrastructure/auth/jwtService');
+<%_ } else { _%>
+jest.mock('@/services/jwtService');
+<%_ } _%>
+
+<%_ if (caching !== 'None') { _%>
+<%_ const cachePath = (architecture === "MVC") ? (caching === "Redis" ? "@/config/redisClient" : "@/config/memoryCache") : (caching === "Redis" ? "@/infrastructure/caching/redisClient" : "@/infrastructure/caching/memoryCache"); _%>
+jest.mock('<%= cachePath %>', () => ({
+  __esModule: true,
+  default: {
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+  }
+}), { virtual: true });
+import cacheService from '<%= cachePath %>';
+<%_ } _%>
+
+describe('AuthMiddleware', () => {
+  let mockRequest: any;
+  let mockResponse: any;
+  const nextFunction: NextFunction = jest.fn();
+
+  beforeEach(() => {
+    mockRequest = {
+      headers: {}
+    };
+    mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn()
+    };
+    jest.clearAllMocks();
+  });
+
+  it('should return 401 if no authorization header is provided', async () => {
+    await authMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.UNAUTHORIZED);
+    expect(mockResponse.json).toHaveBeenCalledWith({ message: 'No token provided' });
+    expect(nextFunction).not.toHaveBeenCalled();
+  });
+
+  it('should return 401 if token is invalid', async () => {
+    mockRequest.headers.authorization = 'Bearer invalid-token';
+    (JwtService.verifyToken as jest.Mock).mockReturnValue(null);
+
+    await authMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.UNAUTHORIZED);
+    expect(mockResponse.json).toHaveBeenCalledWith({ message: 'Invalid or expired token' });
+    expect(nextFunction).not.toHaveBeenCalled();
+  });
+
+  it('should return 401 if token is blacklisted', async () => {
+    const payload = { id: 1, email: 'test@example.com', jti: 'blacklisted-jti' };
+    mockRequest.headers.authorization = 'Bearer valid-token';
+    (JwtService.verifyToken as jest.Mock).mockReturnValue(payload);
+    
+    // Mock the blacklist check
+    <% if (caching !== 'None') { %>
+    (cacheService.get as jest.Mock).mockResolvedValue(true);
+    <% } else { %>
+    JwtService.blacklistedTokens.set('blacklisted-jti', Date.now() + 10000);
+    <% } %>
+
+    await authMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.UNAUTHORIZED);
+    expect(mockResponse.json).toHaveBeenCalledWith({ message: 'Token revoked' });
+    expect(nextFunction).not.toHaveBeenCalled();
+  });
+
+  it('should return 401 if session is expired (sid not in activeTokens)', async () => {
+    const payload = { id: 1, email: 'test@example.com', jti: 'valid-jti', sid: 'expired-sid' };
+    mockRequest.headers.authorization = 'Bearer valid-token';
+    (JwtService.verifyToken as jest.Mock).mockReturnValue(payload);
+    
+    <% if (caching !== 'None') { %>
+    (cacheService.get as jest.Mock).mockImplementation((key: string) => {
+      if (key.startsWith('blacklist:')) return Promise.resolve(false);
+      if (key === 'refresh_tokens:1') return Promise.resolve(['other-sid']);
+      return Promise.resolve(null);
+    });
+    <% } else { %>
+    JwtService.blacklistedTokens.delete('valid-jti');
+    JwtService.activeRefreshTokens.set('1', ['other-sid']);
+    <% } %>
+
+    await authMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.UNAUTHORIZED);
+    expect(mockResponse.json).toHaveBeenCalledWith({ message: 'Session expired' });
+    expect(nextFunction).not.toHaveBeenCalled();
+  });
+
+  it('should call next() and set req.user if token is valid, not blacklisted and session is active', async () => {
+    const payload = { id: 1, email: 'test@example.com', jti: 'valid-jti', sid: 'active-sid' };
+    mockRequest.headers.authorization = 'Bearer valid-token';
+    (JwtService.verifyToken as jest.Mock).mockReturnValue(payload);
+    
+    <% if (caching !== 'None') { %>
+    (cacheService.get as jest.Mock).mockImplementation((key: string) => {
+      if (key.startsWith('blacklist:')) return Promise.resolve(false);
+      if (key === 'refresh_tokens:1') return Promise.resolve(['active-sid']);
+      return Promise.resolve(null);
+    });
+    <% } else { %>
+    JwtService.blacklistedTokens.delete('valid-jti');
+    JwtService.activeRefreshTokens.set('1', ['active-sid']);
+    <% } %>
+
+    await authMiddleware(mockRequest as Request, mockResponse as Response, nextFunction);
+
+    expect(mockRequest.user).toEqual(payload);
+    expect(nextFunction).toHaveBeenCalled();
+  });
+});

package/templates/common/auth/ts/middleware/authMiddleware.ts.ejs

@@ -0,0 +1,59 @@
+import { Request, Response, NextFunction } from 'express';
+<% if (architecture === 'MVC') { %>
+import { JwtService, JwtPayload } from '@/services/jwtService';
+<% if (caching !== 'None') { -%>
+import cacheService from '<% if (caching === "Redis") { %>@/config/redisClient<% } else { %>@/config/memoryCache<% } %>';
+<% } -%>
+<% } else { %>
+import { JwtService, JwtPayload } from '@/infrastructure/auth/jwtService';
+<% if (caching !== 'None') { -%>
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+<% } -%>
+<% } %>
+import { HTTP_STATUS } from '@/utils/httpCodes';
+
+interface CustomRequest extends Request {
+  user?: JwtPayload;
+}
+
+export const authMiddleware = async (req: CustomRequest, res: Response, next: NextFunction) => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'No token provided' });
+  }
+
+  const token = authHeader.split(' ')[1];
+  const decoded = JwtService.verifyToken(token);
+
+  if (!decoded) {
+    return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'Invalid or expired token' });
+  }
+
+  if (decoded.jti) {
+    <%_ if (caching !== 'None') { -%>
+    const isBlacklisted = await cacheService.get(`blacklist:${decoded.jti}`);
+    if (isBlacklisted) {
+      return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'Token revoked' });
+    }<%_ } else { -%>
+    const expiryDate = JwtService.blacklistedTokens.get(decoded.jti);
+    if (expiryDate && Date.now() < expiryDate) {
+      return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'Token revoked' });
+    }<% } %>
+  }
+
+  if (decoded.sid) {
+    <%_ if (caching !== 'None') { -%>
+    const activeTokens = await cacheService.get<string[]>(`refresh_tokens:${decoded.id}`) || [];
+    if (!activeTokens.includes(decoded.sid)) {
+      return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'Session expired' });
+    }<%_ } else { -%>
+    const activeTokens = JwtService.activeRefreshTokens.get(String(decoded.id)) || [];
+    if (!activeTokens.includes(decoded.sid)) {
+      return res.status(HTTP_STATUS.UNAUTHORIZED).json({ message: 'Session expired' });
+    }<% } %>
+  }
+
+  req.user = decoded;
+  next();
+};

package/templates/common/auth/ts/routes/authRoutes.ts.ejs

@@ -0,0 +1,20 @@
+import { Router } from 'express';
+<%_ if (architecture === 'MVC') { -%>
+import { AuthController } from '@/controllers/authController';
+<%_ } else { -%>
+import { AuthController } from '@/interfaces/controllers/auth/authController';
+<%_ } -%>
+<%_ if (architecture === 'MVC') { -%>
+import { authMiddleware } from '@/middleware/authMiddleware';
+<%_ } else { -%>
+import { authMiddleware } from '@/infrastructure/webserver/middleware/authMiddleware';
+<%_ } -%>
+
+const router = Router();
+const authController = new AuthController();
+
+router.post('/login', (req, res, next) => authController.login(req, res, next));
+router.post('/refresh', (req, res, next) => authController.refresh(req, res, next));
+router.post('/logout', authMiddleware, (req, res, next) => authController.logout(req, res, next));
+
+export default router;

package/templates/common/auth/ts/services/jwtService.spec.ts.ejs

@@ -0,0 +1,89 @@
+<% if (architecture === 'Clean Architecture') { -%>
+import { JwtService } from '@/infrastructure/auth/jwtService';
+<% } else { -%>
+import { JwtService } from '@/services/jwtService';
+<% } -%>
+import jwt from 'jsonwebtoken';
+
+jest.mock('jsonwebtoken');
+jest.mock('@/config/env', () => ({
+  env: {
+    JWT_SECRET: 'test-secret',
+    JWT_REFRESH_SECRET: 'test-refresh-secret',
+    JWT_EXPIRES_IN: '15m'
+  }
+}));
+
+describe('JwtService', () => {
+  const secret = 'test-secret';
+  const refreshSecret = 'test-refresh-secret';
+  const payload = { id: 1, email: 'test@example.com' };
+  const token = 'mock-token';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('generateToken', () => {
+    it('should generate a token with standard expiration and jti', () => {
+      (jwt.sign as jest.Mock).mockReturnValue(token);
+
+      const result = JwtService.generateToken(payload);
+
+      expect(jwt.sign).toHaveBeenCalledWith(
+        expect.objectContaining({ ...payload, jti: expect.any(String) }),
+        secret,
+        { expiresIn: '15m' }
+      );
+      expect(result).toBe(token);
+    });
+  });
+
+  describe('generateRefreshToken', () => {
+    it('should generate a refresh token with refresh secret and jti', () => {
+      (jwt.sign as jest.Mock).mockReturnValue(token);
+
+      const result = JwtService.generateRefreshToken(payload);
+
+      expect(jwt.sign).toHaveBeenCalledWith(
+        expect.objectContaining({ ...payload, jti: expect.any(String) }),
+        refreshSecret,
+        { expiresIn: '7d' }
+      );
+      expect(result).toBe(token);
+    });
+  });
+
+  describe('verifyToken', () => {
+    it('should return decoded payload for a valid token', () => {
+      (jwt.verify as jest.Mock).mockReturnValue(payload);
+
+      const result = JwtService.verifyToken(token);
+
+      expect(jwt.verify).toHaveBeenCalledWith(token, secret);
+      expect(result).toEqual(payload);
+    });
+  });
+
+  describe('verifyRefreshToken', () => {
+    it('should return decoded payload for a valid refresh token', () => {
+      (jwt.verify as jest.Mock).mockReturnValue(payload);
+
+      const result = JwtService.verifyRefreshToken(token);
+
+      expect(jwt.verify).toHaveBeenCalledWith(token, refreshSecret);
+      expect(result).toEqual(payload);
+    });
+  });
+
+  describe('decodeToken', () => {
+    it('should return decoded payload without verification', () => {
+      (jwt.decode as jest.Mock).mockReturnValue(payload);
+
+      const result = JwtService.decodeToken(token);
+
+      expect(jwt.decode).toHaveBeenCalledWith(token);
+      expect(result).toEqual(payload);
+    });
+  });
+});

package/templates/common/auth/ts/services/jwtService.ts.ejs

@@ -0,0 +1,60 @@
+import jwt from 'jsonwebtoken';
+import crypto from 'crypto';
+import { env } from '@/config/env';
+
+export interface JwtPayload {
+  id: string | number;
+  email: string;
+  jti?: string;
+  sid?: string;
+  exp?: number;
+}
+
+export class JwtService {
+  private static readonly SECRET = env.JWT_SECRET || 'your-secret-key';
+  private static readonly REFRESH_SECRET = env.JWT_REFRESH_SECRET || 'your-refresh-secret-key';
+  private static readonly EXPIRES_IN = env.JWT_EXPIRES_IN || '15m'; // Access tokens should be short-lived
+  private static readonly REFRESH_EXPIRES_IN = env.JWT_REFRESH_EXPIRES_IN || '7d';
+
+  static generateToken(payload: Partial<JwtPayload>, expiresIn?: string): string {
+    const jti = crypto.randomUUID();
+    return jwt.sign({ ...payload, jti }, this.SECRET, { 
+      expiresIn: expiresIn || this.EXPIRES_IN 
+    } as jwt.SignOptions);
+  }
+
+  static generateRefreshToken(payload: Partial<JwtPayload>, expiresIn?: string): string {
+    const jti = crypto.randomUUID();
+    return jwt.sign({ ...payload, jti }, this.REFRESH_SECRET, { 
+      expiresIn: expiresIn || this.REFRESH_EXPIRES_IN 
+    } as jwt.SignOptions);
+  }
+
+  static verifyToken(token: string): JwtPayload | null {
+    try {
+      return jwt.verify(token, this.SECRET) as JwtPayload;
+    } catch {
+      return null;
+    }
+  }
+
+  static verifyRefreshToken(token: string): JwtPayload | null {
+    try {
+      return jwt.verify(token, this.REFRESH_SECRET) as JwtPayload;
+    } catch {
+      return null;
+    }
+  }
+
+  static decodeToken(token: string): JwtPayload | null {
+    try {
+      return jwt.decode(token) as JwtPayload;
+    } catch {
+      return null;
+    }
+  }
+
+  // Fallback in-memory storage if caching = 'None'
+  static activeRefreshTokens = new Map<string, string[]>();
+  static blacklistedTokens = new Map<string, number>();
+}

package/templates/common/caching/clean/js/CreateUser.js.ejs

@@ -1,9 +1,12 @@
 const User = require('../domain/models/User');
-<%_ if (caching === 'Redis') { -%>
+<% if (auth.includes('JWT')) { -%>
+const bcrypt = require('bcryptjs');
+<% } -%>
+<% if (caching === 'Redis') { -%>
 const cacheService = require('../infrastructure/caching/redisClient');
-<%_ } else if (caching === 'Memory Cache') { -%>
+<% } else if (caching === 'Memory Cache') { -%>
 const cacheService = require('../infrastructure/caching/memoryCache');
-<%_ } -%>
+<% } -%>
 const logger = require('../infrastructure/log/logger');
 
 class CreateUser {
@@ -11,8 +14,14 @@ class CreateUser {
         this.userRepository = userRepository;
     }
 
-    async execute(name, email) {
-        const user = new User(null, name, email);
+    async execute(name, email, password) {
+        let finalPassword = password;
+        <% if (auth.includes('JWT')) { -%>
+        if (password) {
+            finalPassword = await bcrypt.hash(password, 10);
+        }
+        <% } -%>
+        const user = new User(null, name, email, finalPassword);
         const savedUser = await this.userRepository.save(user);
 
         try {

package/templates/common/caching/clean/js/DeleteUser.js.ejs

@@ -15,7 +15,8 @@ class DeleteUser {
 
         try {
             await cacheService.del('users:all');
-            logger.info('Invalidated users:all cache');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user:${id} and all users`);
         } catch (error) {
              logger.error('Cache error (del):', error);
         }

package/templates/common/caching/clean/js/GetUserById.js.ejs

@@ -0,0 +1,39 @@
+<%_ if (caching === 'Redis') { -%>
+const cacheService = require('../infrastructure/caching/redisClient');
+<%_ } else if (caching === 'Memory Cache') { -%>
+const cacheService = require('../infrastructure/caching/memoryCache');
+<%_ } -%>
+const logger = require('../infrastructure/log/logger');
+
+class GetUserById {
+  constructor(userRepository) {
+    this.userRepository = userRepository;
+  }
+
+  async execute(id) {
+    const cacheKey = `user:${id}`;
+    try {
+      const cachedUser = await cacheService.get(cacheKey);
+      if (cachedUser) {
+        logger.info(`Serving user ${id} from cache`);
+        return cachedUser;
+      }
+    } catch (error) {
+      logger.error('Cache error (get):', error);
+    }
+
+    const user = await this.userRepository.findById(id);
+
+    if (user) {
+      try {
+        await cacheService.set(cacheKey, user, 3600); // Cache for 1 hour
+      } catch (error) {
+        logger.error('Cache error (set):', error);
+      }
+    }
+
+    return user;
+  }
+}
+
+module.exports = GetUserById;

package/templates/common/caching/clean/js/UpdateUser.js.ejs

@@ -15,7 +15,8 @@ class UpdateUser {
 
         try {
             await cacheService.del('users:all');
-            logger.info('Invalidated users:all cache');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user:${id} and all users`);
         } catch (error) {
             logger.error('Cache error (del):', error);
         }

package/templates/common/caching/clean/ts/createUser.ts.ejs

@@ -1,18 +1,26 @@
 import { User } from '@/domain/user';
-
 import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-<%_ if (caching === 'Redis') { -%>
+<% if (auth.includes('JWT')) { -%>
+import bcrypt from 'bcryptjs';
+<% } -%>
+<% if (caching === 'Redis') { -%>
 import cacheService from '@/infrastructure/caching/redisClient';
-<%_ } else if (caching === 'Memory Cache') { -%>
+<% } else if (caching === 'Memory Cache') { -%>
 import cacheService from '@/infrastructure/caching/memoryCache';
-<%_ } -%>
+<% } -%>
 import logger from '@/infrastructure/log/logger';
 
 export default class CreateUser {
     constructor(private userRepository: UserRepository) {}
 
-    async execute(name: string, email: string) {
-        const user = new User(null, name, email);
+    async execute(name: string, email: string, password?: string) {
+        let finalPassword = password;
+<% if (auth.includes('JWT')) { -%>
+        if (password) {
+            finalPassword = await bcrypt.hash(password, 10);
+        }
+<% } -%>
+        const user = new User(null, name, email, finalPassword);
         const savedUser = await this.userRepository.save(user);
 
         try {

package/templates/common/caching/clean/ts/deleteUser.ts.ejs

@@ -14,7 +14,8 @@ export default class DeleteUser {
 
         try {
             await cacheService.del('users:all');
-            logger.info('Invalidated users:all cache');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user:${id} and all users`);
         } catch (error) {
             logger.error('Cache error (del):', error);
         }

package/templates/common/caching/clean/ts/getUserById.ts.ejs

@@ -0,0 +1,32 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import cacheService from '<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>';
+import logger from '@/infrastructure/log/logger';
+
+export default class GetUserById {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(id: string | number) {
+        const cacheKey = `user:${id}`;
+        try {
+            const cachedUser = await cacheService.get(cacheKey);
+            if (cachedUser) {
+                logger.info(`Serving user ${id} from cache`);
+                return cachedUser;
+            }
+        } catch (error) {
+            logger.error('Cache error (get):', error);
+        }
+
+        const user = await this.userRepository.findById(id);
+
+        if (user) {
+            try {
+                await cacheService.set(cacheKey, user, 3600); // Cache for 1 hour
+            } catch (error) {
+                logger.error('Cache error (set):', error);
+            }
+        }
+
+        return user;
+    }
+}

package/templates/common/caching/clean/ts/updateUser.ts.ejs

@@ -14,7 +14,8 @@ export default class UpdateUser {
 
         try {
             await cacheService.del('users:all');
-            logger.info('Invalidated users:all cache');
+            await cacheService.del(`user:${id}`);
+            logger.info(`Invalidated cache for user:${id} and all users`);
         } catch (error) {
             logger.error('Cache error (del):', error);
         }

package/templates/common/database/js/models/User.js.ejs

@@ -6,12 +6,18 @@ class UserModel {
     return this.mockData;
   }
 
+  static async findOne(query) {
+    return this.mockData.find((u) => {
+      return Object.entries(query).every(([key, value]) => u[key] === value);
+    });
+  }
+
   static async findAll() {
     return this.mockData;
   }
 
   static async create(data) {
-    const { id, ...rest } = data;
+    const { id: _, ...rest } = data;
     const newUser = { id: String(this.mockData.length + 1), ...rest };
     this.mockData.push(newUser);
     return newUser;
@@ -62,6 +68,12 @@ User.init(
       allowNull: false,
       unique: true,
     },
+    <% if (auth.includes('JWT')) { %>
+    password: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    <% } %>
     deletedAt: {
       type: DataTypes.DATE,
       allowNull: true,
@@ -75,5 +87,6 @@ User.init(
   }
 );
 
+
 module.exports = User;
 <% } -%>

package/templates/common/database/js/models/User.js.mongoose.ejs

@@ -10,6 +10,12 @@ const UserSchema = new mongoose.Schema({
         required: true,
         unique: true
     },
+    <% if (auth.includes('JWT')) { %>
+    password: {
+        type: String,
+        required: true
+    },
+    <% } %>
     createdAt: {
         type: Date,
         default: Date.now
@@ -20,4 +26,5 @@ const UserSchema = new mongoose.Schema({
     }
 });
 
+
 module.exports = mongoose.model('User', UserSchema);

package/templates/common/database/js/models/User.spec.js.ejs

@@ -73,15 +73,27 @@ describe('User Model', () => {
         expect(await User.find()).toBeDefined();
         expect(await User.findAll()).toBeDefined();
         
+        // Test findOne
+        const oneUser = await User.findOne({ email: data.email });
+        expect(oneUser.email).toBe(data.email);
+        
         const found = await User.findByPk(user.id);
         expect(found.id).toBe(user.id);
         
         const updated = await User.update(user.id, { name: 'New Name' });
         expect(updated.name).toBe('New Name');
         
+        // Test update non-existent
+        const nonExistentUpdate = await User.update('999', { name: 'Fail' });
+        expect(nonExistentUpdate).toBeUndefined();
+
         const deleted = await User.destroy(user.id);
         expect(deleted).toBe(true);
         expect(await User.findByPk(user.id)).toBeUndefined();
+
+        // Test destroy non-existent
+        const notDeleted = await User.destroy('999');
+        expect(notDeleted).toBe(false);
         <% } else { %>
         User.create.mockResolvedValue({ id: 1, ...data });
         User.findAll.mockResolvedValue([{ id: 1, ...data }]);

package/templates/common/database/ts/models/User.spec.ts.ejs

@@ -40,6 +40,11 @@ jest.mock('@/infrastructure/database/database', () => ({}));
 describe('User Model', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        <% if (database === 'None') { %>
+        const UserPath = '<% if (architecture === "MVC") { %>@/models/User<% } else { %>@/infrastructure/database/models/User<% } %>';
+        const User = require(UserPath).default;
+        User.mockData = [];
+        <% } %>
     });
 
     it('should be defined and initialized', () => {
@@ -78,6 +83,11 @@ describe('User Model', () => {
         expect(found).toEqual(user);
         expect(await User.findByPk('invalid')).toBeUndefined();
         
+        // findOne
+        const foundOne = await User.findOne({ email: data.email });
+        expect(foundOne).toEqual(user);
+        expect(await User.findOne({ email: 'nonexistent' })).toBeUndefined();
+        
         // update
         const updated = await User.update(user.id, { name: 'Updated' });
         expect(updated.name).toBe('Updated');