nodejs-structure-cli 1.0.0

package/templates/mvc/js/src/controllers/userController.spec.js.ejs

@@ -0,0 +1,481 @@
+const HTTP_STATUS = require('@/utils/httpCodes');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+<% if (communication !== 'GraphQL') { -%>
+// Express-only imports would go here
+<% } -%>
+const { getUsers, createUser, updateUser, deleteUser } = require('@/controllers/userController');
+<%_ if (caching === 'Redis') { -%>
+const cacheService = require('@/config/redisClient');
+<%_ } else if (caching === 'Memory Cache') { -%>
+const cacheService = require('@/config/memoryCache');
+<%_ } -%>
+
+// Mock dependencies
+jest.mock('@/models/User', () => {
+    return {
+        create: jest.fn(),
+        find: jest.fn(),
+        findAll: jest.fn(),
+        findById: jest.fn(),
+        findByIdAndUpdate: jest.fn(),
+        findByIdAndDelete: jest.fn(),
+        findByPk: jest.fn(),
+        update: jest.fn(),
+        destroy: jest.fn(),
+        mockData: []
+    };
+});
+const User = require('@/models/User');
+<%_ if (caching === 'Redis') { -%>
+jest.mock('@/config/redisClient', () => ({
+    getOrSet: jest.fn((_key, fetcher) => fetcher()),
+    del: jest.fn(),
+    flush: jest.fn()
+}));
+<%_ } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/config/memoryCache', () => ({
+    getOrSet: jest.fn((_key, fetcher) => fetcher()),
+    del: jest.fn(),
+    flush: jest.fn()
+}));
+<%_ } -%>
+jest.mock('@/utils/logger');
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('@/services/kafkaService', () => {
+    const mockSendMessage = jest.fn().mockResolvedValue(undefined);
+    return {
+        sendMessage: mockSendMessage,
+        kafkaService: {
+            sendMessage: mockSendMessage
+        },
+        KafkaService: jest.fn().mockImplementation(() => ({
+            sendMessage: mockSendMessage
+        }))
+    };
+});
+const { sendMessage } = require('@/services/kafkaService');
+<%_ } -%>
+
+
+describe('UserController', () => {
+<% if (communication !== 'GraphQL') { -%>
+    let mockRequest;
+    let mockResponse;
+    let mockNext;
+<% } -%>
+
+    beforeEach(() => {
+<% if (communication !== 'GraphQL') { -%>
+        mockRequest = {
+            body: {}
+        };
+        mockResponse = {
+            json: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+        mockNext = jest.fn();
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+        cacheService.getOrSet.mockImplementation((_key, fetcher) => fetcher());
+        cacheService.flush.mockClear();
+<%_ } -%>
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+<%_ if (database === 'None') { -%>
+        User.mockData = [];
+<%_ } -%>
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            // Arrange
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockResolvedValue(usersMock);
+<%_ } else { -%>
+            User.findAll.mockResolvedValue(usersMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await getUsers();
+
+            // Assert
+            expect(result).toEqual(usersMock);
+<% } else { -%>
+            await getUsers(mockRequest, mockResponse, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+        });
+
+        it('should return an empty array when no users found', async () => {
+            // Arrange
+            const usersMock = [];
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockResolvedValue(usersMock);
+<%_ } else { -%>
+            User.findAll.mockResolvedValue(usersMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await getUsers();
+
+            // Assert
+            expect(result).toEqual(usersMock);
+<% } else { -%>
+            await getUsers(mockRequest, mockResponse, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Database Error');
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            // Simulating error inside the fetcher by making User.findAll fail
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findAll.mockRejectedValue(error);
+<%_ } -%>
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.find.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findAll.mockRejectedValue(error);
+<%_ } -%>
+<%_ } -%>
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(getUsers()).rejects.toThrow(error);
+<% } else { -%>
+            await getUsers(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { id: '1', ...payload };
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            User.create.mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            User.create.mockResolvedValue(expectedUser);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await createUser(dataArg);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toBe(payload.name);
+            expect(result.email).toBe(payload.email);
+<%_ } else { -%>
+            expect(result).toEqual(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+
+            // Assert
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+        it('should handle errors when creation fails (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Creation Error');
+            const payload = { name: 'Bob', email: 'bob@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+
+            User.create.mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(createUser(dataArg)).rejects.toThrow(error);
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+
+<%_ if (communication === 'Kafka') { -%>
+        it('should successfully create a new user with _id for Kafka (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Bob', email: 'bob@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { _id: '2', ...payload };
+            User.create.mockResolvedValue(expectedUser);
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            await createUser(dataArg);
+<% } else { -%>
+            await createUser(mockRequest, mockResponse, mockNext);
+<% } -%>
+
+            // Assert
+            expect(sendMessage).toHaveBeenCalledWith(
+                'user-topic',
+                expect.stringContaining('"id":"2"'),
+                '2'
+            );
+        });
+<%_ } -%>
+    });
+
+    describe('updateUser', () => {
+        it('should successfully update a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+            const payload = { name: 'Alice Updated' };
+<% if (communication === 'GraphQL') { -%>
+            const idArg = id;
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { id, ...payload, email: 'alice@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndUpdate.mockResolvedValue(expectedUser);
+<%_ } else if (database === 'None') { -%>
+            User.update.mockResolvedValue(expectedUser);
+            User.findByPk.mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            const userMock = { ...expectedUser, update: jest.fn().mockResolvedValue(true) };
+            User.findByPk.mockResolvedValue(userMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await updateUser(idArg, dataArg);
+            expect(result.name).toBe(payload.name);
+<% } else { -%>
+            await updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.json).toHaveBeenCalled();
+<% } -%>
+
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+        it('should handle 404/errors when user not found or update fails', async () => {
+             // Arrange
+            const id = '999';
+<%_ if (communication === 'GraphQL') { -%>
+            const idArg = id;
+            const dataArg = { name: 'Fail' };
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndUpdate.mockResolvedValue(null);
+<%_ } else { -%>
+            User.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            await expect(updateUser(idArg, dataArg)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Fail' };
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndUpdate.mockResolvedValue(null);
+<%_ } else { -%>
+            User.findByPk.mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            await updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.NOT_FOUND);
+<%_ } -%>
+        });
+
+        it('should handle database errors during update (Error Handling)', async () => {
+            // Arrange
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndUpdate.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findByPk.mockRejectedValue(error);
+<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(updateUser(id, { name: 'Fail' })).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('deleteUser', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+<% if (communication === 'GraphQL') { -%>
+            const idArg = id;
+<% } else { -%>
+            mockRequest.params = { id };
+<% } -%>
+            
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndDelete.mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            User.destroy.mockResolvedValue(true);
+<%_ } else { -%>
+            const userMock = { id, destroy: jest.fn().mockResolvedValue(true) };
+            User.findByPk.mockResolvedValue(userMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await deleteUser(idArg);
+            expect(result).toBe(true);
+<% } else { -%>
+            await deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.OK);
+<% } -%>
+
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+<% if (communication === 'GraphQL') { -%>
+        it('should handle user not found during deletion (Error Handling)', async () => {
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndDelete.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            User.destroy.mockResolvedValue(false);
+<%_ } else { -%>
+            User.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            await expect(deleteUser(id)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+        });
+
+        it('should handle database errors during deletion (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndDelete.mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            User.destroy.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findByPk.mockRejectedValue(error);
+<%_ } -%>
+            await expect(deleteUser(id)).rejects.toThrow(error);
+        });
+<% } else { -%>
+        it('should handle user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+            mockRequest.params = { id };
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndDelete.mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            User.destroy.mockResolvedValue(false);
+<%_ } else { -%>
+            User.findByPk.mockResolvedValue(null);
+<%_ } -%>
+            await deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.NOT_FOUND);
+        });
+
+        it('should handle database errors during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '1';
+            mockRequest.params = { id };
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndDelete.mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            User.destroy.mockRejectedValue(error);
+<%_ } else { -%>
+            User.findByPk.mockRejectedValue(error);
+<%_ } -%>
+            await deleteUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+        });
+<% } -%>
+    });
+
+    describe('createUser Error Paths', () => {
+        it('should handle database errors during creation (Error Handling)', async () => {
+            const error = new Error('Database Error');
+            User.create.mockRejectedValue(error);
+<% if (communication === 'GraphQL') { -%>
+            await expect(createUser({ name: 'Alice', email: 'alice@example.com' })).rejects.toThrow(error);
+<% } else { -%>
+            mockRequest.body = { name: 'Alice', email: 'alice@example.com' };
+            await createUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('updateUser Error Paths', () => {
+        it('should handle database errors during update (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            User.findByIdAndUpdate.mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            User.findByPk.mockResolvedValue({ id });
+            User.update.mockRejectedValue(error);
+<%_ } else { -%>
+            const userMock = { id, update: jest.fn().mockRejectedValue(error) };
+            User.findByPk.mockResolvedValue(userMock);
+<%_ } -%>
+<% if (communication === 'GraphQL') { -%>
+            await expect(updateUser(id, { name: 'Bob' })).rejects.toThrow(error);
+<% } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Bob' };
+            await updateUser(mockRequest, mockResponse, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+});

package/templates/mvc/js/src/errors/ApiError.js

@@ -0,0 +1,14 @@
+class ApiError extends Error {
+  constructor(statusCode, message, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+module.exports = { ApiError };

package/templates/mvc/js/src/errors/BadRequestError.js

@@ -0,0 +1,11 @@
+const { ApiError } = require('./ApiError');
+const HTTP_STATUS = require('../utils/httpCodes');
+const ERROR_MESSAGES = require('../utils/errorMessages');
+
+class BadRequestError extends ApiError {
+  constructor(message = ERROR_MESSAGES.BAD_REQUEST) {
+    super(HTTP_STATUS.BAD_REQUEST, message);
+  }
+}
+
+module.exports = { BadRequestError };

package/templates/mvc/js/src/errors/BadRequestError.spec.js.ejs

@@ -0,0 +1,22 @@
+const { BadRequestError } = require('@/errors/BadRequestError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+
+describe('BadRequestError', () => {
+    it('should extend ApiError', () => {
+        const error = new BadRequestError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Bad Request"', () => {
+        const error = new BadRequestError();
+        expect(error.message).toBe(ERROR_MESSAGES.BAD_REQUEST);
+        expect(error.statusCode).toBe(HTTP_STATUS.BAD_REQUEST);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new BadRequestError('Custom bad request');
+        expect(error.message).toBe('Custom bad request');
+    });
+});

package/templates/mvc/js/src/errors/NotFoundError.js

@@ -0,0 +1,11 @@
+const { ApiError } = require('./ApiError');
+const HTTP_STATUS = require('../utils/httpCodes');
+const ERROR_MESSAGES = require('../utils/errorMessages');
+
+class NotFoundError extends ApiError {
+  constructor(message = ERROR_MESSAGES.RESOURCE_NOT_FOUND) {
+    super(HTTP_STATUS.NOT_FOUND, message);
+  }
+}
+
+module.exports = { NotFoundError };

package/templates/mvc/js/src/errors/NotFoundError.spec.js.ejs

@@ -0,0 +1,22 @@
+const { NotFoundError } = require('@/errors/NotFoundError');
+const { ApiError } = require('@/errors/ApiError');
+const HTTP_STATUS = require('@/utils/httpCodes');
+const ERROR_MESSAGES = require('@/utils/errorMessages');
+
+describe('NotFoundError', () => {
+    it('should extend ApiError', () => {
+        const error = new NotFoundError();
+        expect(error).toBeInstanceOf(ApiError);
+    });
+
+    it('should have default message "Resource not found"', () => {
+        const error = new NotFoundError();
+        expect(error.message).toBe(ERROR_MESSAGES.RESOURCE_NOT_FOUND);
+        expect(error.statusCode).toBe(HTTP_STATUS.NOT_FOUND);
+    });
+
+    it('should accept a custom message', () => {
+        const error = new NotFoundError(ERROR_MESSAGES.USER_NOT_FOUND);
+        expect(error.message).toBe(ERROR_MESSAGES.USER_NOT_FOUND);
+    });
+});

package/templates/mvc/js/src/graphql/context.js.ejs

@@ -0,0 +1,7 @@
+const gqlContext = async ({ req }) => {
+  // Setup authorization or context here
+  const token = req.headers.authorization || '';
+  return { token };
+};
+
+module.exports = { gqlContext };

package/templates/mvc/js/src/graphql/context.spec.js.ejs

@@ -0,0 +1,29 @@
+const { gqlContext } = require('@/graphql/context');
+const { resolvers } = require('@/graphql/resolvers');
+const { typeDefs } = require('@/graphql/typeDefs');
+
+describe('GraphQL Context', () => {
+    it('should exercise GraphQL index entry points', () => {
+        expect(resolvers).toBeDefined();
+        expect(typeDefs).toBeDefined();
+    });
+  it('should return context with token when authorization header is present', async () => {
+    const mockRequest = {
+      headers: {
+        authorization: 'Bearer token123',
+      },
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: 'Bearer token123' });
+  });
+
+  it('should return context with empty token when authorization header is missing', async () => {
+    const mockRequest = {
+      headers: {},
+    };
+
+    const context = await gqlContext({ req: mockRequest });
+    expect(context).toEqual({ token: '' });
+  });
+});

package/templates/mvc/js/src/graphql/index.js.ejs

@@ -0,0 +1,5 @@
+const { typeDefs } = require('./typeDefs');
+const { resolvers } = require('./resolvers');
+const { gqlContext } = require('./context');
+
+module.exports = { typeDefs, resolvers, gqlContext };

package/templates/mvc/js/src/graphql/resolvers/index.js.ejs

@@ -0,0 +1,6 @@
+const { mergeResolvers } = require('@graphql-tools/merge');
+const { userResolvers } = require('./user.resolvers');
+
+const resolvers = mergeResolvers([userResolvers]);
+
+module.exports = { resolvers };

package/templates/mvc/js/src/graphql/resolvers/user.resolvers.js.ejs

@@ -0,0 +1,25 @@
+const userController = require('../../controllers/userController');
+
+const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      return await userController.getUsers();
+    }
+  },
+  Mutation: {
+    createUser: async (_, { name, email }) => {
+      return await userController.createUser({ name, email });
+    },
+    updateUser: async (_, { id, name, email }) => {
+      return await userController.updateUser(id, { name, email });
+    },
+    deleteUser: async (_, { id }) => {
+      return await userController.deleteUser(id);
+    }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent) => parent.id || parent._id
+  }<%_ } %>
+};
+
+module.exports = { userResolvers };