nodejs-structure-cli 1.0.0

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

@@ -0,0 +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' }
+<%_ } -%>
+            ]);
+        });
+    });
+
+    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);
+        });
+    });
+});

package/templates/clean-architecture/js/src/infrastructure/webserver/middleware/errorMiddleware.js

@@ -0,0 +1,30 @@
+const logger = require('../../log/logger');
+const { ApiError } = require('../../../errors/ApiError');
+const HTTP_STATUS = require('../../../utils/httpCodes');
+
+// eslint-disable-next-line no-unused-vars
+const errorMiddleware = (err, req, res, next) => {
+  let error = err;
+
+  if (!(error instanceof ApiError)) {
+    const statusCode = err.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
+    const message = error.message || 'Internal Server Error';
+    error = new ApiError(statusCode, message, false, err.stack);
+  }
+
+  const { statusCode, message } = error;
+
+  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
+    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
+    logger.error(error.stack || 'No stack trace');
+  }
+
+  res.status(statusCode).json({
+    statusCode,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+};
+
+module.exports = { errorMiddleware };
+

package/templates/clean-architecture/js/src/infrastructure/webserver/server.js.ejs

@@ -0,0 +1,93 @@
+const express = require('express');
+const cors = require('cors');
+const logger = require('../log/logger');
+const morgan = require('morgan');
+const { errorMiddleware } = require('./middleware/errorMiddleware');
+const healthRoutes = require('../../interfaces/routes/healthRoute');
+const setupGracefulShutdown = require('../../utils/gracefulShutdown');
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+const apiRoutes = require('../../interfaces/routes/api');
+const swaggerUi = require('swagger-ui-express');
+const swaggerSpecs = require('./swagger');
+<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+const { ApolloServer } = require('@apollo/server');
+const { expressMiddleware } = require('@as-integrations/express4');
+const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
+const { unwrapResolverError } = require('@apollo/server/errors');
+const { ApiError } = require('../../errors/ApiError');
+const { typeDefs, resolvers } = require('../../interfaces/graphql');
+const { gqlContext } = require('../../interfaces/graphql/context');
+<%_ } -%>
+
+const { env } = require('../config/env');
+
+const startServer = async () => {
+    // Determine port using the validated env
+    const port = env.PORT;
+    const app = express();
+
+    app.use(cors());
+    app.use(express.json());
+    <% if (includeMulter) { %>
+    const path = require('path');
+    app.use('/uploads', express.static(path.join(__dirname, '../../../../uploads')));
+    <% } %>
+    app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));
+    <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+    app.use('/api', apiRoutes);
+    <%_ } -%>
+    <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+    app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+    <%_ } -%>
+    <%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const apolloServer = new ApolloServer({
+        typeDefs,
+        resolvers,
+        plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+        formatError: (formattedError, error) => {
+            const originalError = unwrapResolverError(error);
+            if (originalError instanceof ApiError) {
+              return {
+                ...formattedError,
+                message: originalError.message,
+                extensions: {
+                  ...formattedError.extensions,
+                  code: originalError.statusCode.toString(),
+                }
+              };
+            }
+            
+            logger.error(`GraphQL Error: ${formattedError.message}`);
+            if (originalError && originalError.stack && process.env.NODE_ENV === 'development') {
+               logger.error(originalError.stack);
+            }
+            return formattedError;
+        },
+    });
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
+    <%_ } -%>
+    app.use('/health', healthRoutes);
+
+    app.use(errorMiddleware);
+
+    const server = app.listen(port, () => {
+        logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'Kafka') { -%>
+        const { connectKafka } = require('../../infrastructure/messaging/kafkaClient');
+        connectKafka()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', err.message);
+            });
+<%_ } -%>
+    });
+
+    setupGracefulShutdown(server);
+};
+
+module.exports = startServer;

package/templates/clean-architecture/js/src/infrastructure/webserver/swagger.js.ejs

@@ -0,0 +1,6 @@
+const path = require('path');
+const YAML = require('yamljs');
+
+const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
+
+module.exports = swaggerDocument;

package/templates/clean-architecture/js/src/interfaces/controllers/userController.js.ejs

@@ -0,0 +1,190 @@
+const CreateUser = require('../../usecases/CreateUser');
+const GetAllUsers = require('../../usecases/GetAllUsers');
+const UpdateUser = require('../../usecases/UpdateUser');
+const DeleteUser = require('../../usecases/DeleteUser');
+const UserRepository = require('../../infrastructure/repositories/UserRepository');
+const ERROR_MESSAGES = require('../../utils/errorMessages');
+<% if (communication !== 'GraphQL') { -%>
+const HTTP_STATUS = require('../../utils/httpCodes');
+<% } -%>
+const logger = require('../../infrastructure/log/logger');
+<%_ if (communication === 'Kafka') { -%>
+const { sendMessage } = require('../../infrastructure/messaging/kafkaClient');
+const { KAFKA_ACTIONS } = require('../../utils/kafkaEvents');
+<%_ } -%>
+<%_ if (auth && auth !== 'None') { _%>
+const bcrypt = require('bcryptjs');
+<%_ } _%>
+
+class UserController {
+    constructor() {
+        this.userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(this.userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
+        this.updateUserUseCase = new UpdateUser(this.userRepository);
+        this.deleteUserUseCase = new DeleteUser(this.userRepository);
+    }
+
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+            return await this.getAllUsersUseCase.execute();
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async createUser(data) {
+        const { name, email, password, imageUrl } = data;
+        try {
+            let hashedPassword = password;
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                hashedPassword = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+            const user = await this.createUserUseCase.execute(name, email<% if (auth && auth !== 'None') { %>, hashedPassword <% } %> <% if (includeMulter) { %>, imageUrl<% } %>);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async updateUser(id, data) {
+        try {
+            const user = await this.updateUserUseCase.execute(id, data);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async deleteUser(id) {
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            return true;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+<% } else { -%>
+    async getUsers(req, res, next) {
+      try {
+        const users = await this.getAllUsersUseCase.execute();
+        res.json(users);
+      } catch (error) {
+        logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+        next(error);
+      }
+    }
+
+    async createUser(req, res, next) {
+        const { name, email, password } = req.body || {};
+        try {
+            let hashedPassword = password;
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                hashedPassword = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+            let imageUrl = null;
+            <% if (includeMulter) { %>
+            if (req.file) {
+                imageUrl = `/uploads/${req.file.filename}`;
+            }
+            <% } %>
+
+            const user = await this.createUserUseCase.execute(name, email <% if (auth && auth !== 'None') { %>, hashedPassword <% } %> <% if (includeMulter) { %>, imageUrl<% } %>);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async updateUser(req, res, next) {
+        const { id } = req.params;
+        const { name, email, password } = req.body || {};
+        try {
+            const updateData = { name, email };
+            <% if (auth && auth !== 'None') { %>
+            if (password) {
+                updateData.password = await bcrypt.hash(password, 10);
+            }
+            <% } %>
+            <% if (includeMulter) { %>
+            if (req.file) {
+                updateData.imageUrl = `/uploads/${req.file.filename}`;
+            }
+            <% } %>
+
+            const user = await this.updateUserUseCase.execute(id, updateData);
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            res.json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async deleteUser(req, res, next) {
+        const { id } = req.params;
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            res.status(HTTP_STATUS.OK).json({ message: 'User deleted successfully' });
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+<% } -%>
+}
+
+module.exports = UserController;