nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/clean-architecture/js/src/infrastructure/config/env.js.ejs

@@ -1,47 +1,47 @@
-const { z } = require('zod');
-const logger = require('../log/logger');
-
-if (process.env.NODE_ENV !== 'production') {
-  require('dotenv').config();
-}
-
-const envSchema = z.object({
-  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
-  PORT: z.string().transform(Number).default('3000'),
-<%_ if (database !== 'None') { -%>
-  DB_HOST: z.string(),
-<%_ if (database === 'MySQL') { -%>
-  DB_USER: z.string(),
-  DB_PASSWORD: z.string(),
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } else if (database === 'PostgreSQL') { -%>
-  DB_USER: z.string(),
-  DB_PASSWORD: z.string(),
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } else if (database === 'MongoDB') { -%>
-  DB_NAME: z.string(),
-  DB_PORT: z.string().transform(Number),
-<%_ } -%>
-<%_ } -%>
-<%_ if (caching === 'Redis') { -%>
-  REDIS_HOST: z.string(),
-  REDIS_PORT: z.string().transform(Number),
-  REDIS_PASSWORD: z.string().optional(),
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-  KAFKA_BROKER: z.string(),
-<%_ } -%>
-});
-
-const _env = envSchema.safeParse(process.env);
-
-if (!_env.success) {
-  logger.error('❌ Invalid environment variables:', _env.error.format());
-  process.exit(1);
-}
-
-const env = _env.data;
-
-module.exports = { env };
+const { z } = require('zod');
+const logger = require('../log/logger');
+
+if (process.env.NODE_ENV !== 'production') {
+  require('dotenv').config();
+}
+
+const envSchema = z.object({
+  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
+  PORT: z.string().transform(Number).default('3000'),
+<%_ if (database !== 'None') { -%>
+  DB_HOST: z.string(),
+<%_ if (database === 'MySQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'PostgreSQL') { -%>
+  DB_USER: z.string(),
+  DB_PASSWORD: z.string(),
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } else if (database === 'MongoDB') { -%>
+  DB_NAME: z.string(),
+  DB_PORT: z.string().transform(Number),
+<%_ } -%>
+<%_ } -%>
+<%_ if (caching === 'Redis') { -%>
+  REDIS_HOST: z.string(),
+  REDIS_PORT: z.string().transform(Number),
+  REDIS_PASSWORD: z.string().optional(),
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+  KAFKA_BROKER: z.string(),
+<%_ } -%>
+});
+
+const _env = envSchema.safeParse(process.env);
+
+if (!_env.success) {
+  logger.error('❌ Invalid environment variables:', _env.error.format());
+  process.exit(1);
+}
+
+const env = _env.data;
+
+module.exports = { env };

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

@@ -1,36 +1,36 @@
-const winston = require('winston');
-require('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(),
-}));
-
-module.exports = logger;
+const winston = require('winston');
+require('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(),
+}));
+
+module.exports = logger;

package/templates/clean-architecture/js/src/infrastructure/log/logger.spec.js.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') { -%>
-const logger = require('@/utils/logger');
-<% } else { -%>
-const logger = require('@/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('@/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') { -%>
+const logger = require('@/utils/logger');
+<% } else { -%>
+const logger = require('@/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('@/infrastructure/log/logger');
+        expect(winston.format.json).toHaveBeenCalled();
+        process.env.NODE_ENV = 'test';
+    });
+});

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

@@ -1,39 +1,69 @@
-const UserModel = require('../database/models/User');
-
-class UserRepository {
-  async save(user) {
-<%_ if (database === 'None') { -%>
-    const newUser = await UserModel.create(user);
-    return newUser;
-<%_ } else { -%>
-    const newUser = await UserModel.create({ name: user.name, email: user.email });
-<%_ if (database === 'MongoDB') { -%>
-    return { ...user, id: newUser._id.toString() };
-<%_ } else { -%>
-    return { ...user, id: newUser.id };
-<%_ } -%>
-<%_ } -%>
-  }
-
-  async getUsers() {
-<%_ if (database === 'None') { -%>
-    return await UserModel.find();
-<%_ } else if (database === 'MongoDB') { -%>
-    const users = await UserModel.find();
-    return users.map(user => ({
-        id: user._id.toString(),
-        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
-    }));
-<%_ } -%>
-  }
-}
-
-module.exports = UserRepository;
+const UserModel = require('../database/models/User');
+
+class UserRepository {
+  async save(user) {
+<%_ if (database === 'None') { -%>
+    const newUser = await UserModel.create(user);
+    return newUser;
+<%_ } else { -%>
+    const newUser = await UserModel.create({ name: user.name, email: user.email });
+<%_ if (database === 'MongoDB') { -%>
+    return { ...user, id: newUser._id.toString() };
+<%_ } else { -%>
+    return { ...user, id: newUser.id };
+<%_ } -%>
+<%_ } -%>
+  }
+
+  async getUsers() {
+<%_ if (database === 'None') { -%>
+    return await UserModel.find();
+<%_ } else if (database === 'MongoDB') { -%>
+    const users = await UserModel.find();
+    return users.map(user => ({
+        id: user._id.toString(),
+        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, data) {
+<%_ 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 user = await UserModel.update(id, data);
+    return user;
+<%_ } 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) {
+<%_ 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;
+<%_ } -%>
+  }
+}
+
+module.exports = UserRepository;

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

@@ -1,81 +1,142 @@
-const UserRepository = require('@/infrastructure/repositories/UserRepository');
-const UserModel = require('@/infrastructure/database/models/User');
-
-jest.mock('@/infrastructure/database/models/User');
-
-describe('UserRepository', () => {
-    let userRepository;
-
-    beforeEach(() => {
-        userRepository = new UserRepository();
-        jest.clearAllMocks();
-    });
-
-    describe('save', () => {
-        it('should save and return a newly created user (Happy Path)', async () => {
-            const userData = { name: 'New User', email: 'new@example.com' };
-<%_ if (database === 'MongoDB') { -%>
-            const savedData = { _id: 'mock-id', ...userData };
-            UserModel.create.mockResolvedValue(savedData);
-<%_ } else if (database === 'None') { -%>
-            UserModel.create.mockResolvedValue(userData);
-<%_ } else { -%>
-            const savedData = { <%= database === "MongoDB" ? "_id" : "id" %>: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData };
-            UserModel.create.mockResolvedValue(savedData);
-<%_ } -%>
-
-            const result = await userRepository.save(userData);
-
-<%_ if (database === 'None') { -%>
-            expect(result.name).toEqual(userData.name);
-<%_ } else { -%>
-            expect(UserModel.create).toHaveBeenCalledWith(userData);
-            expect(result).toEqual({ id: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData });
-<%_ } -%>
-        });
-
-        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
-<%_ if (database === 'None') { -%>
-            // mock data logic doesn't throw naturally
-<%_ } else { -%>
-            const error = new Error('DB Error');
-            UserModel.create.mockRejectedValue(error);
-
-            await expect(userRepository.save({})).rejects.toThrow('DB Error');
-<%_ } -%>
-        });
-    });
-
-    describe('getUsers', () => {
-        it('should return a list of mapped UserEntities (Happy Path)', async () => {
-<%_ if (database === 'MongoDB') { -%>
-            const mockUsers = [
-                { _id: '1', name: 'User 1', email: 'u1@test.com' },
-                { _id: '2', name: 'User 2', email: 'u2@test.com' }
-            ];
-            UserModel.find.mockResolvedValue(mockUsers);
-<%_ } else if (database === 'None') { -%>
-            const mockUsers = [{ id: '1', name: 'User 1', email: 'u1@test.com' }];
-            UserModel.find.mockResolvedValue(mockUsers);
-<%_ } else { -%>
-            const mockUsers = [
-                { <%= database === "MongoDB" ? "_id" : "id" %>: '1', name: 'User 1', email: 'u1@test.com' },
-                { <%= database === "MongoDB" ? "_id" : "id" %>: '2', name: 'User 2', email: 'u2@test.com' }
-            ];
-            UserModel.<%= database === "MongoDB" ? "find" : "findAll" %>.mockResolvedValue(mockUsers);
-<%_ } -%>
-            
-            const result = await userRepository.getUsers();
-
-<%_ if (database !== 'None') { -%>
-            expect(UserModel.<%= database === 'MongoDB' ? 'find' : 'findAll' %>).toHaveBeenCalled();
-<%_ } -%>
-            expect(result).toEqual([
-                { id: '1', name: 'User 1', email: 'u1@test.com' }
-<%_ if (database !== 'None') { -%>
-                , { id: '2', name: 'User 2', email: 'u2@test.com' }
-<%_ } -%>
-            ]);
-        });
-    });
-});
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+const UserModel = require('@/infrastructure/database/models/User');
+
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            const userData = { name: 'New User', email: 'new@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const savedData = { _id: 'mock-id', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } else if (database === 'None') { -%>
+            UserModel.create.mockResolvedValue(userData);
+<%_ } else { -%>
+            const savedData = { <%= database === "MongoDB" ? "_id" : "id" %>: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData };
+            UserModel.create.mockResolvedValue(savedData);
+<%_ } -%>
+
+            const result = await userRepository.save(userData);
+
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(userData.name);
+<%_ } else { -%>
+            expect(UserModel.create).toHaveBeenCalledWith(userData);
+            expect(result).toEqual({ id: '<%= database === "MongoDB" ? "mock-id" : "1" %>', ...userData });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // mock data logic doesn't throw naturally
+<%_ } else { -%>
+            const error = new Error('DB Error');
+            UserModel.create.mockRejectedValue(error);
+
+            await expect(userRepository.save({})).rejects.toThrow('DB Error');
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            const mockUsers = [
+                { _id: '1', name: 'User 1', email: 'u1@test.com' },
+                { _id: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else if (database === 'None') { -%>
+            const mockUsers = [{ id: '1', name: 'User 1', email: 'u1@test.com' }];
+            UserModel.find.mockResolvedValue(mockUsers);
+<%_ } else { -%>
+            const mockUsers = [
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '1', name: 'User 1', email: 'u1@test.com' },
+                { <%= database === "MongoDB" ? "_id" : "id" %>: '2', name: 'User 2', email: 'u2@test.com' }
+            ];
+            UserModel.<%= database === "MongoDB" ? "find" : "findAll" %>.mockResolvedValue(mockUsers);
+<%_ } -%>
+            
+            const result = await userRepository.getUsers();
+
+<%_ if (database !== 'None') { -%>
+            expect(UserModel.<%= database === 'MongoDB' ? 'find' : 'findAll' %>).toHaveBeenCalled();
+<%_ } -%>
+            expect(result).toEqual([
+                { id: '1', name: 'User 1', email: 'u1@test.com' }
+<%_ if (database !== 'None') { -%>
+                , { id: '2', name: 'User 2', email: 'u2@test.com' }
+<%_ } -%>
+            ]);
+        });
+    });
+
+    describe('update', () => {
+        it('should successfully update a user (Happy Path)', async () => {
+            const id = '1';
+            const updateData = { name: 'Updated name' };
+<%_ if (database === 'MongoDB') { -%>
+            const updatedUser = { _id: id, ...updateData, email: 'test@test.com' };
+            UserModel.findByIdAndUpdate.mockResolvedValue(updatedUser);
+<%_ } else if (database === 'None') { -%>
+            const updatedUser = { id, ...updateData, email: 'test@test.com' };
+            UserModel.update.mockResolvedValue(updatedUser);
+<%_ } else { -%>
+            const updatedUser = { id: '1', ...updateData, email: 'test@test.com', update: jest.fn().mockResolvedValue(true) };
+            UserModel.findByPk.mockResolvedValue(updatedUser);
+<%_ } -%>
+
+            const result = await userRepository.update(id, updateData);
+            expect(result.name).toEqual(updateData.name);
+        });
+
+        it('should handle user not found during update (Error Handling)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndUpdate.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            UserModel.update.mockResolvedValue(null);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            const result = await userRepository.update('999', { name: 'fail' });
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            const id = '1';
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndDelete.mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            UserModel.destroy.mockResolvedValue(true);
+<%_ } else { -%>
+            const userMock = { id, destroy: jest.fn().mockResolvedValue(true) };
+            UserModel.findByPk.mockResolvedValue(userMock);
+<%_ } -%>
+
+            const result = await userRepository.delete(id);
+            expect(result).toBe(true);
+        });
+
+        it('should handle user not found during deletion (Error Handling)', async () => {
+<%_ if (database === 'MongoDB') { -%>
+            UserModel.findByIdAndDelete.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            UserModel.destroy.mockResolvedValue(false);
+<%_ } else { -%>
+            UserModel.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            const result = await userRepository.delete('999');
+            expect(result).toBe(false);
+        });
+    });
+});