nodejs-quickstart-structure 1.19.0 → 1.19.1

package/templates/clean-architecture/js/src/interfaces/routes/api.spec.js.ejs

@@ -1,38 +1,38 @@
-const request = require('supertest');
-const express = require('express');
-const router = require('@/interfaces/routes/api');
-
-const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
-const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
-
-jest.mock('@/interfaces/controllers/userController', () => {
-  return jest.fn().mockImplementation(() => ({
-    getUsers: (...args) => mockGetUsers(...args),
-    createUser: (...args) => mockCreateUser(...args)
-  }));
-});
-
-describe('ApiRoutes', () => {
-    let app;
-
-    beforeEach(() => {
-        app = express();
-        app.use(express.json());
-        app.use('/api', router);
-    });
-
-    it('POST /api/users should call controller.createUser', async () => {
-        await request(app)
-            .post('/api/users')
-            .send({ name: 'Test', email: 'test@example.com' });
-
-        expect(mockCreateUser).toHaveBeenCalledTimes(1);
-    });
-
-    it('GET /api/users should call controller.getUsers', async () => {
-        await request(app)
-            .get('/api/users');
-
-        expect(mockGetUsers).toHaveBeenCalledTimes(1);
-    });
-});
+const request = require('supertest');
+const express = require('express');
+const router = require('@/interfaces/routes/api');
+
+const mockGetUsers = jest.fn().mockImplementation((req, res) => res.status(200).json([{ id: '1', name: 'John Doe' }]));
+const mockCreateUser = jest.fn().mockImplementation((req, res) => res.status(201).json({ id: '1', name: 'Test' }));
+
+jest.mock('@/interfaces/controllers/userController', () => {
+  return jest.fn().mockImplementation(() => ({
+    getUsers: (...args) => mockGetUsers(...args),
+    createUser: (...args) => mockCreateUser(...args)
+  }));
+});
+
+describe('ApiRoutes', () => {
+    let app;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('POST /api/users should call controller.createUser', async () => {
+        await request(app)
+            .post('/api/users')
+            .send({ name: 'Test', email: 'test@example.com' });
+
+        expect(mockCreateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/clean-architecture/js/src/usecases/CreateUser.js

@@ -1,14 +1,14 @@
-const User = require('../domain/models/User');
-
-class CreateUser {
-    constructor(userRepository) {
-        this.userRepository = userRepository;
-    }
-
-    async execute(name, email) {
-        const user = new User(null, name, email);
-        return await this.userRepository.save(user);
-    }
-}
-
-module.exports = CreateUser;
+const User = require('../domain/models/User');
+
+class CreateUser {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute(name, email) {
+        const user = new User(null, name, email);
+        return await this.userRepository.save(user);
+    }
+}
+
+module.exports = CreateUser;

package/templates/clean-architecture/js/src/usecases/CreateUser.spec.js.ejs

@@ -1,51 +1,51 @@
-const CreateUser = require('@/usecases/CreateUser');
-const UserRepository = require('@/infrastructure/repositories/UserRepository');
-<%_ if (caching !== 'None') { -%>
-const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
-<%_ } -%>
-
-jest.mock('@/infrastructure/repositories/UserRepository');
-<%_ if (caching !== 'None') { -%>
-jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
-    get: jest.fn(),
-    set: jest.fn(),
-    del: jest.fn()
-}));
-<%_ } -%>
-
-describe('CreateUser UseCase', () => {
-    let createUser;
-    let mockUserRepository;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository();
-        createUser = new CreateUser(mockUserRepository);
-        jest.clearAllMocks();
-    });
-
-    it('should create and save a new user', async () => {
-        const name = 'Test User';
-        const email = 'test@example.com';
-        const expectedResult = { id: 1, name, email };
-
-        mockUserRepository.save.mockResolvedValue(expectedResult);
-
-        const result = await createUser.execute(name, email);
-
-        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
-        const savedUser = mockUserRepository.save.mock.calls[0][0];
-        expect(savedUser.name).toBe(name);
-        expect(savedUser.email).toBe(email);
-        expect(result).toEqual(expectedResult);
-<%_ if (caching !== 'None') { -%>
-        expect(cacheService.del).toHaveBeenCalledWith('users:all');
-<%_ } -%>
-    });
-
-    it('should throw an error if repository fails', async () => {
-        const error = new Error('Database error');
-        mockUserRepository.save.mockRejectedValue(error);
-
-        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
-    });
-});
+const CreateUser = require('@/usecases/CreateUser');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('CreateUser UseCase', () => {
+    let createUser;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        createUser = new CreateUser(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should create and save a new user', async () => {
+        const name = 'Test User';
+        const email = 'test@example.com';
+        const expectedResult = { id: 1, name, email };
+
+        mockUserRepository.save.mockResolvedValue(expectedResult);
+
+        const result = await createUser.execute(name, email);
+
+        expect(mockUserRepository.save).toHaveBeenCalledTimes(1);
+        const savedUser = mockUserRepository.save.mock.calls[0][0];
+        expect(savedUser.name).toBe(name);
+        expect(savedUser.email).toBe(email);
+        expect(result).toEqual(expectedResult);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+    });
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.save.mockRejectedValue(error);
+
+        await expect(createUser.execute('Test', 'test@test.com')).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/js/src/usecases/GetAllUsers.js

@@ -1,12 +1,12 @@
-
-class GetAllUsers {
-    constructor(userRepository) {
-        this.userRepository = userRepository;
-    }
-
-    async execute() {
-        return await this.userRepository.getUsers();
-    }
-}
-
-module.exports = GetAllUsers;
+
+class GetAllUsers {
+    constructor(userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    async execute() {
+        return await this.userRepository.getUsers();
+    }
+}
+
+module.exports = GetAllUsers;

package/templates/clean-architecture/js/src/usecases/GetAllUsers.spec.js.ejs

@@ -1,61 +1,61 @@
-const GetAllUsers = require('@/usecases/GetAllUsers');
-const UserRepository = require('@/infrastructure/repositories/UserRepository');
-<%_ if (caching !== 'None') { -%>
-const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
-<%_ } -%>
-
-jest.mock('@/infrastructure/repositories/UserRepository');
-<%_ if (caching !== 'None') { -%>
-jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
-    get: jest.fn(),
-    set: jest.fn(),
-    del: jest.fn()
-}));
-<%_ } -%>
-
-describe('GetAllUsers UseCase', () => {
-    let getAllUsers;
-    let mockUserRepository;
-
-    beforeEach(() => {
-        mockUserRepository = new UserRepository();
-        getAllUsers = new GetAllUsers(mockUserRepository);
-        jest.clearAllMocks();
-    });
-
-    it('should retrieve all users', async () => {
-        const expectedUsers = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];
-        mockUserRepository.getUsers.mockResolvedValue(expectedUsers);
-<%_ if (caching !== 'None') { -%>
-        cacheService.get.mockResolvedValue(null); // Cache miss
-<%_ } -%>
-        const result = await getAllUsers.execute();
-
-        expect(mockUserRepository.getUsers).toHaveBeenCalledTimes(1);
-        expect(result).toEqual(expectedUsers);
-<%_ if (caching !== 'None') { -%>
-        expect(cacheService.set).toHaveBeenCalled();
-<%_ } -%>
-    });
-
-<%_ if (caching !== 'None') { -%>
-    it('should return from cache if available', async () => {
-        const cachedUsers = [{ id: 1, name: 'Cached', email: 'cached@example.com' }];
-        cacheService.get.mockResolvedValue(cachedUsers);
-
-        const result = await getAllUsers.execute();
-
-        expect(mockUserRepository.getUsers).not.toHaveBeenCalled();
-        expect(result).toEqual(cachedUsers);
-    });
-<%_ } -%>
-
-    it('should throw an error if repository fails', async () => {
-        const error = new Error('Database error');
-        mockUserRepository.getUsers.mockRejectedValue(error);
-<%_ if (caching !== 'None') { -%>
-        cacheService.get.mockResolvedValue(null); // Cache miss
-<%_ } -%>
-        await expect(getAllUsers.execute()).rejects.toThrow(error);
-    });
-});
+const GetAllUsers = require('@/usecases/GetAllUsers');
+const UserRepository = require('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+const cacheService = require('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>');
+<%_ } -%>
+
+jest.mock('@/infrastructure/repositories/UserRepository');
+<%_ if (caching !== 'None') { -%>
+jest.mock('<% if (caching === "Redis") { %>@/infrastructure/caching/redisClient<% } else { %>@/infrastructure/caching/memoryCache<% } %>', () => ({
+    get: jest.fn(),
+    set: jest.fn(),
+    del: jest.fn()
+}));
+<%_ } -%>
+
+describe('GetAllUsers UseCase', () => {
+    let getAllUsers;
+    let mockUserRepository;
+
+    beforeEach(() => {
+        mockUserRepository = new UserRepository();
+        getAllUsers = new GetAllUsers(mockUserRepository);
+        jest.clearAllMocks();
+    });
+
+    it('should retrieve all users', async () => {
+        const expectedUsers = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];
+        mockUserRepository.getUsers.mockResolvedValue(expectedUsers);
+<%_ if (caching !== 'None') { -%>
+        cacheService.get.mockResolvedValue(null); // Cache miss
+<%_ } -%>
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).toHaveBeenCalledTimes(1);
+        expect(result).toEqual(expectedUsers);
+<%_ if (caching !== 'None') { -%>
+        expect(cacheService.set).toHaveBeenCalled();
+<%_ } -%>
+    });
+
+<%_ if (caching !== 'None') { -%>
+    it('should return from cache if available', async () => {
+        const cachedUsers = [{ id: 1, name: 'Cached', email: 'cached@example.com' }];
+        cacheService.get.mockResolvedValue(cachedUsers);
+
+        const result = await getAllUsers.execute();
+
+        expect(mockUserRepository.getUsers).not.toHaveBeenCalled();
+        expect(result).toEqual(cachedUsers);
+    });
+<%_ } -%>
+
+    it('should throw an error if repository fails', async () => {
+        const error = new Error('Database error');
+        mockUserRepository.getUsers.mockRejectedValue(error);
+<%_ if (caching !== 'None') { -%>
+        cacheService.get.mockResolvedValue(null); // Cache miss
+<%_ } -%>
+        await expect(getAllUsers.execute()).rejects.toThrow(error);
+    });
+});

package/templates/clean-architecture/js/src/utils/httpCodes.js

@@ -1,9 +1,9 @@
-const HTTP_STATUS = {
-    OK: 200,
-    CREATED: 201,
-    BAD_REQUEST: 400,
-    NOT_FOUND: 404,
-    INTERNAL_SERVER_ERROR: 500
-};
-
-module.exports = HTTP_STATUS;
+const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+};
+
+module.exports = HTTP_STATUS;

package/templates/clean-architecture/ts/src/config/env.ts.ejs

@@ -1,46 +1,46 @@
-import dotenv from 'dotenv';
-import { z } from 'zod';
-import logger from '@/infrastructure/log/logger';
-
-if (process.env.NODE_ENV !== 'production') {
-  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);
-}
-
-export const env = _env.data;
+import dotenv from 'dotenv';
+import { z } from 'zod';
+import logger from '@/infrastructure/log/logger';
+
+if (process.env.NODE_ENV !== 'production') {
+  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);
+}
+
+export const env = _env.data;

package/templates/clean-architecture/ts/src/config/swagger.ts.ejs

@@ -1,6 +1,6 @@
-<% if (communication === 'REST APIs' || communication === 'Kafka') { %>import path from 'path';
-import YAML from 'yamljs';
-
-const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
-
-export default swaggerDocument;<% } %>
+<% if (communication === 'REST APIs' || communication === 'Kafka') { %>import path from 'path';
+import YAML from 'yamljs';
+
+const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
+
+export default swaggerDocument;<% } %>

package/templates/clean-architecture/ts/src/domain/user.ts

@@ -1,7 +1,7 @@
-export class User {
-    constructor(
-        public id: number | string | null,
-        public name: string,
-        public email: string
-    ) { }
-}
+export class User {
+    constructor(
+        public id: number | string | null,
+        public name: string,
+        public email: string
+    ) { }
+}

package/templates/clean-architecture/ts/src/errors/ApiError.ts

@@ -1,15 +1,15 @@
-export class ApiError extends Error {
-  statusCode: number;
-  isOperational: boolean;
-
-  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
-    super(message);
-    this.statusCode = statusCode;
-    this.isOperational = isOperational;
-    if (stack) {
-      this.stack = stack;
-    } else {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
+export class ApiError extends Error {
+  statusCode: number;
+  isOperational: boolean;
+
+  constructor(statusCode: number, message: string, isOperational = true, stack = '') {
+    super(message);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}