nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/clean-architecture/ts/src/infrastructure/log/logger.spec.ts.ejs

@@ -1,63 +1,63 @@
-jest.mock('winston-daily-rotate-file');
-jest.mock('winston', () => {
-    const mockLogger = {
-        add: jest.fn(),
-        info: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn()
-    };
-    const format = {
-        combine: jest.fn(),
-        timestamp: jest.fn(),
-        json: jest.fn(),
-        simple: jest.fn()
-    };
-    const transports = {
-        Console: jest.fn(),
-        DailyRotateFile: jest.fn()
-    };
-    return {
-        format,
-        transports,
-        createLogger: jest.fn().mockReturnValue(mockLogger)
-    };
-});
-
-<% if (architecture === 'MVC') { -%>
-import logger from '@/utils/logger';
-<% } else { -%>
-import logger from '@/infrastructure/log/logger';
-<% } -%>
-
-describe('Logger', () => {
-    it('should export a logger instance', () => {
-        expect(logger).toBeDefined();
-    });
-
-    it('should have info method', () => {
-        expect(typeof logger.info).toBe('function');
-    });
-
-    it('should have error method', () => {
-        expect(typeof logger.error).toBe('function');
-    });
-
-    it('should call info', () => {
-        logger.info('test message');
-        expect(logger.info).toHaveBeenCalledWith('test message');
-    });
-
-    it('should call error', () => {
-        logger.error('test error');
-        expect(logger.error).toHaveBeenCalledWith('test error');
-    });
-
-    it('should use JSON format in production environment', () => {
-        const winston = require('winston');
-        jest.resetModules();
-        process.env.NODE_ENV = 'production';
-        require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
-        expect(winston.format.json).toHaveBeenCalled();
-        process.env.NODE_ENV = 'test';
-    });
-});
+jest.mock('winston-daily-rotate-file');
+jest.mock('winston', () => {
+    const mockLogger = {
+        add: jest.fn(),
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    };
+    const format = {
+        combine: jest.fn(),
+        timestamp: jest.fn(),
+        json: jest.fn(),
+        simple: jest.fn()
+    };
+    const transports = {
+        Console: jest.fn(),
+        DailyRotateFile: jest.fn()
+    };
+    return {
+        format,
+        transports,
+        createLogger: jest.fn().mockReturnValue(mockLogger)
+    };
+});
+
+<% if (architecture === 'MVC') { -%>
+import logger from '@/utils/logger';
+<% } else { -%>
+import logger from '@/infrastructure/log/logger';
+<% } -%>
+
+describe('Logger', () => {
+    it('should export a logger instance', () => {
+        expect(logger).toBeDefined();
+    });
+
+    it('should have info method', () => {
+        expect(typeof logger.info).toBe('function');
+    });
+
+    it('should have error method', () => {
+        expect(typeof logger.error).toBe('function');
+    });
+
+    it('should call info', () => {
+        logger.info('test message');
+        expect(logger.info).toHaveBeenCalledWith('test message');
+    });
+
+    it('should call error', () => {
+        logger.error('test error');
+        expect(logger.error).toHaveBeenCalledWith('test error');
+    });
+
+    it('should use JSON format in production environment', () => {
+        const winston = require('winston');
+        jest.resetModules();
+        process.env.NODE_ENV = 'production';
+        require('<% if (architecture === "MVC") { %>@/utils/logger<% } else { %>@/infrastructure/log/logger<% } %>');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

package/templates/clean-architecture/ts/src/infrastructure/log/logger.ts

@@ -1,36 +1,36 @@
-import winston from 'winston';
-import 'winston-daily-rotate-file';
-
-const logger = winston.createLogger({
-  level: 'info',
-  format: winston.format.combine(
-    winston.format.timestamp(),
-    winston.format.json()
-  ),
-  defaultMeta: { service: 'user-service' },
-  transports: [
-    new winston.transports.DailyRotateFile({
-      filename: 'logs/error-%DATE%.log',
-      datePattern: 'YYYY-MM-DD',
-      zippedArchive: true,
-      maxSize: '20m',
-      maxFiles: '14d',
-      level: 'error',
-    }),
-    new winston.transports.DailyRotateFile({
-      filename: 'logs/combined-%DATE%.log',
-      datePattern: 'YYYY-MM-DD',
-      zippedArchive: true,
-      maxSize: '20m',
-      maxFiles: '14d',
-    }),
-  ],
-});
-
-logger.add(new winston.transports.Console({
-  format: process.env.NODE_ENV !== 'production'
-    ? winston.format.simple()
-    : winston.format.json(),
-}));
-
-export default logger;
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/error-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+      level: 'error',
+    }),
+    new winston.transports.DailyRotateFile({
+      filename: 'logs/combined-%DATE%.log',
+      datePattern: 'YYYY-MM-DD',
+      zippedArchive: true,
+      maxSize: '20m',
+      maxFiles: '14d',
+    }),
+  ],
+});
+
+logger.add(new winston.transports.Console({
+  format: process.env.NODE_ENV !== 'production'
+    ? winston.format.simple()
+    : winston.format.json(),
+}));
+
+export default logger;

package/templates/clean-architecture/ts/src/infrastructure/repositories/UserRepository.spec.ts.ejs

@@ -1,85 +1,175 @@
-import { UserRepository } from '@/infrastructure/repositories/UserRepository';
-import UserModel from '@/infrastructure/database/models/User';
-
-// Mock DB Model Database Layer
-jest.mock('@/infrastructure/database/models/User');
-
-describe('UserRepository', () => {
-    let userRepository: UserRepository;
-
-    beforeEach(() => {
-        userRepository = new UserRepository();
-        jest.clearAllMocks();
-    });
-
-    describe('save', () => {
-        it('should save and return a newly created user (Happy Path)', async () => {
-            // Arrange
-            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
-<%_ if (database === 'MongoDB') { -%>
-            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
-            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } else if (database === 'None') { -%>
-            (UserModel.create as jest.Mock).mockResolvedValue(payload);
-<%_ } else { -%>
-            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
-            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
-<%_ } -%>
-
-            // Act
-            const result = await userRepository.save(payload);
-
-            // Assert
-<%_ if (database === 'None') { -%>
-            expect(result.name).toEqual(payload.name)
-<%_ } else { -%>
-            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
-            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
-<%_ } -%>
-        });
-
-        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
-<%_ if (database === 'None') { -%>
-            // Mocks do not naturally fail 
-<%_ } else { -%>
-            // Arrange
-            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
-            const error = new Error('DB Connection Refused');
-            (UserModel.create as jest.Mock).mockRejectedValue(error);
-
-            // Act & Assert
-            await expect(userRepository.save(payload)).rejects.toThrow(error);
-<%_ } -%>
-        });
-    });
-
-    describe('getUsers', () => {
-        it('should return a list of mapped UserEntities (Happy Path)', async () => {
-            // Arrange
-<%_ if (database === 'MongoDB') { -%>
-            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
-            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
-<%_ } else if (database === 'None') { -%>
-            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
-            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
-<%_ } else { -%>
-            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
-            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
-<%_ } -%>
-
-            // Act
-            const result = await userRepository.getUsers();
-
-            // Assert
-            expect(result).toHaveLength(1);
-            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
-<%_ if (database !== 'None') { -%>
-<%_ if (database === 'MongoDB') { -%>
-            expect(UserModel.find).toHaveBeenCalled();
-<%_ } else { -%>
-            expect(UserModel.findAll).toHaveBeenCalled();
-<%_ } -%>
-<%_ } -%>
-        });
-    });
-});
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import UserModel from '@/infrastructure/database/models/User';
+
+// Mock DB Model Database Layer
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository: UserRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            // Arrange
+            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.create as jest.Mock).mockResolvedValue(payload);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.save(payload);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(payload.name)
+<%_ } else { -%>
+            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
+            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // Mocks do not naturally fail 
+<%_ } else { -%>
+            // Arrange
+            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
+            const error = new Error('DB Connection Refused');
+            (UserModel.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+            await expect(userRepository.save(payload)).rejects.toThrow(error);
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+            // Arrange
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } else if (database === 'None') { -%>
+            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
+<%_ } else { -%>
+            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.getUsers();
+
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.find).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+    });
+
+    describe('update', () => {
+        it('should update and return the user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+            const data = { name: 'Updated' };
+            const expectedUser = { id: '1', name: 'Updated', email: 'test@example.com' };
+
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'Updated', email: 'test@example.com' };
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'Updated', email: 'test@example.com', update: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, data);
+
+            // Assert
+            expect(result?.name).toEqual(data.name);
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.findByIdAndUpdate).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findByPk).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+
+        it('should return null when user not found (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, { name: 'Fail' });
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(true);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', destroy: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(true);
+        });
+
+        it('should return false when user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(false);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+});

package/templates/clean-architecture/ts/src/infrastructure/repositories/userRepository.ts.ejs

@@ -0,0 +1,74 @@
+import { User as UserEntity } from '@/domain/user';
+import UserModel from '@/infrastructure/database/models/User';
+
+export class UserRepository {
+    async save(user: UserEntity): Promise<UserEntity> {
+<%_ if (database === 'MongoDB') { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
+<%_ } else if (database === 'None') { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<%_ } else { -%>
+        const newUser = await UserModel.create({ name: user.name, email: user.email });
+        return { id: newUser.id, name: newUser.name, email: newUser.email };
+<%_ } -%>
+    }
+
+    async getUsers(): Promise<UserEntity[]> {
+<%_ if (database === 'MongoDB') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user._id.toString(),
+            name: user.name,
+            email: user.email
+        }));
+<%_ } else if (database === 'None') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email
+        }));
+<%_ } else { -%>
+        const users = await UserModel.findAll();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email
+        }));
+<%_ } -%>
+    }
+
+    async update(id: number | string, data: Partial<UserEntity>): Promise<UserEntity | null> {
+<%_ if (database === 'MongoDB') { -%>
+        const user = await UserModel.findByIdAndUpdate(id, data, { new: true });
+        if (!user) return null;
+        return { id: user._id.toString(), name: user.name, email: user.email };
+<%_ } else if (database === 'None') { -%>
+        const { id: _, ...updateData } = data;
+        const user = await UserModel.update(id, updateData as Parameters<typeof UserModel.update>[1]);
+        if (!user) return null;
+        return { id: user.id, name: user.name, email: user.email };
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return null;
+        await user.update(data);
+        return { id: user.id || 0, name: user.name, email: user.email };
+<%_ } -%>
+    }
+
+    async delete(id: number | string): Promise<boolean> {
+<%_ if (database === 'MongoDB') { -%>
+        const result = await UserModel.findByIdAndDelete(id);
+        return !!result;
+<%_ } else if (database === 'None') { -%>
+        return await UserModel.destroy(id);
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return false;
+        await user.destroy();
+        return true;
+<%_ } -%>
+    }
+}