nodejs-quickstart-structure 1.1.6

package/templates/clean-architecture/js/src/index.js.ejs

@@ -0,0 +1,37 @@
+const startServer = require('./infrastructure/webserver/server');
+const logger = require('./infrastructure/log/logger');
+<% if (communication === 'Kafka') { -%>
+const { connectKafka, sendMessage } = require('./infrastructure/messaging/kafkaClient');
+<% } -%>
+
+const PORT = process.env.PORT || 3000;
+
+// Database Sync
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            const sequelize = require('./infrastructure/database/database');
+            await sequelize.sync();
+            logger.info('Database synced');
+            // Start the web server after DB sync
+            startServer(PORT);
+            <% if (communication === 'Kafka') { %>
+            // Connect Kafka
+            connectKafka().then(async () => {
+              logger.info('Kafka connected');
+              await sendMessage('test-topic', 'Hello Kafka from Clean Arch JS!');
+            }).catch(err => {
+              logger.error('Failed to connect to Kafka:', err);
+            });
+            <% } -%>
+            break;
+        } catch (err) {
+            logger.error('Database sync failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+syncDatabase();

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

@@ -0,0 +1,22 @@
+const winston = require('winston');
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'combined.log' }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(new winston.transports.Console({
+    format: winston.format.simple(),
+  }));
+}
+
+module.exports = logger;

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

@@ -0,0 +1,19 @@
+const UserModel = require('../database/models/User');
+
+class UserRepository {
+  async save(user) {
+    const newUser = await UserModel.create({ name: user.name, email: user.email });
+    return { ...user, id: newUser.id };
+  }
+
+  async getUsers() {
+    const users = await UserModel.findAll();
+    return users.map(user => ({
+        id: user.id,
+        name: user.name,
+        email: user.email
+    }));
+  }
+}
+
+module.exports = UserRepository;

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

@@ -0,0 +1,31 @@
+const express = require('express');
+const cors = require('cors');
+require('dotenv').config();
+<% if (communication === 'REST APIs') { %>const apiRoutes = require('../../interfaces/routes/api');<% } %>
+<% if (communication === 'REST APIs') { %>
+const swaggerUi = require('swagger-ui-express');
+const swaggerSpecs = require('./swagger');
+<% } %>
+
+const startServer = (port) => {
+    const app = express();
+
+    app.use(cors());
+    app.use(express.json());
+
+    <% if (communication === 'REST APIs') { %>app.use('/api', apiRoutes);<% } %>
+
+    <% if (communication === 'REST APIs') { %>
+    app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+    <% } %>
+
+    app.get('/health', (req, res) => {
+        res.json({ status: 'UP' });
+    });
+
+    app.listen(port, () => {
+        console.log(`Server running on port ${port}`);
+    });
+};
+
+module.exports = startServer;

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

@@ -0,0 +1,23 @@
+const swaggerJsdoc = require('swagger-jsdoc');
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'NodeJS API Service',
+      version: '1.0.0',
+      description: 'API documentation for the NodeJS Service',
+    },
+    servers: [
+      {
+        url: process.env.SERVER_URL || `http://localhost:${process.env.PORT || 3000}`,
+        description: 'Server',
+      },
+    ],
+  },
+  apis: ['./src/interfaces/routes/*.js'], // Path to the API docs
+};
+
+const specs = swaggerJsdoc(options);
+
+module.exports = specs;

package/templates/clean-architecture/js/src/interfaces/controllers/UserController.js

@@ -0,0 +1,30 @@
+const CreateUser = require('../../usecases/CreateUser');
+const GetAllUsers = require('../../usecases/GetAllUsers');
+const UserRepository = require('../../infrastructure/repositories/UserRepository');
+const HTTP_STATUS = require('../../utils/httpCodes');
+
+class UserController {
+    constructor() {
+        this.userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(this.userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
+    }
+
+    getUsers(req, res) {
+        this.getAllUsersUseCase.execute()
+            .then(users => res.json(users))
+            .catch(err => res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: err.message }));
+    }
+
+    async createUser(req, res) {
+        const { name, email } = req.body;
+        try {
+            const user = await this.createUserUseCase.execute(name, email);
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            res.status(HTTP_STATUS.BAD_REQUEST).json({ error: error.message });
+        }
+    }
+}
+
+module.exports = UserController;

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

@@ -0,0 +1,77 @@
+const express = require('express');
+const router = express.Router();
+const UserController = require('../controllers/UserController');
+
+// Should inject dependencies here in a real app
+const userController = new UserController();
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     User:
+ *       type: object
+ *       required:
+ *         - name
+ *         - email
+ *       properties:
+ *         id:
+ *           type: integer
+ *           description: The auto-generated id of the user
+ *         name:
+ *           type: string
+ *           description: The name of the user
+ *         email:
+ *           type: string
+ *           description: The email of the user
+ *       example:
+ *         id: 1
+ *         name: John Doe
+ *         email: john@example.com
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   name: Users
+ *   description: The users managing API
+ */
+
+/**
+ * @swagger
+ * /api/users:
+ *   get:
+ *     summary: Returns the list of all the users
+ *     tags: [Users]
+ *     responses:
+ *       200:
+ *         description: The list of the users
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/User'
+ *   post:
+ *     summary: Create a new user
+ *     tags: [Users]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/User'
+ *     responses:
+ *       201:
+ *         description: The created user.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/User'
+ *       500:
+ *         description: Some server error
+ */
+router.post('/users', (req, res) => userController.createUser(req, res));
+router.get('/users', (req, res) => userController.getUsers(req, res));
+
+module.exports = router;

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

@@ -0,0 +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;

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

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

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

@@ -0,0 +1,9 @@
+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/swagger.ts.ejs

@@ -0,0 +1,24 @@
+<% if (communication === 'REST APIs') { %>
+import swaggerJsdoc from 'swagger-jsdoc';
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+      title: 'NodeJS API Service',
+      version: '1.0.0',
+      description: 'API documentation for the NodeJS Service',
+    },
+    servers: [
+      {
+        url: process.env.SERVER_URL || `http://localhost:${process.env.PORT || 3000}`,
+        description: 'Server',
+      },
+    ],
+  },
+  apis: ['./src/interfaces/routes/*.ts', './dist/interfaces/routes/*.js'], // Path to the API docs
+};
+
+const specs = swaggerJsdoc(options);
+
+export default specs;<% } %>

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

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

package/templates/clean-architecture/ts/src/index.ts.ejs

@@ -0,0 +1,71 @@
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import rateLimit from 'express-rate-limit';
+import dotenv from 'dotenv';
+import logger from './infrastructure/log/logger';
+<% if (communication === 'REST APIs') { %>import userRoutes from './interfaces/routes/userRoutes';<% } %>
+<% if (communication === 'REST APIs') { %>
+import swaggerUi from 'swagger-ui-express';
+import swaggerSpecs from './config/swagger';<% } %>
+<% if (communication === 'Kafka') { %>import { KafkaService } from './infrastructure/messaging/kafkaClient';<% } %>
+
+dotenv.config();
+
+const app = express();
+const port = process.env.PORT || 3000;
+
+// Security Middleware
+app.use(helmet());
+app.use(hpp());
+app.use(cors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] }));
+const limiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 100 });
+app.use(limiter);
+
+app.use(express.json());
+
+<% if (communication === 'REST APIs') { -%>
+app.use('/api/users', userRoutes);<% } -%>
+
+<% if (communication === 'REST APIs') { %>
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));<% } %>
+
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'UP' });
+});
+
+// Database Sync
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            const sequelize = (await import('./infrastructure/database/database')).default;
+            await sequelize.sync();
+            logger.info('Database synced');
+            
+            app.listen(port, async () => {
+              logger.info(`Server running on port ${port}`);
+              <% if (communication === 'Kafka') { %>
+              try {
+                const kafkaService = new KafkaService();
+                await kafkaService.connect();
+                logger.info('Kafka connected');
+                // Demo
+                await kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
+              } catch (err) {
+                logger.error('Failed to connect to Kafka:', err);
+              }
+              <% } -%>
+            });
+            break;
+        } catch (err) {
+            logger.error('Database sync failed:', err);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}. Waiting 5s...`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+syncDatabase();

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

@@ -0,0 +1,22 @@
+import winston from 'winston';
+
+const logger = winston.createLogger({
+  level: 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  defaultMeta: { service: 'user-service' },
+  transports: [
+    new winston.transports.File({ filename: 'error.log', level: 'error' }),
+    new winston.transports.File({ filename: 'combined.log' }),
+  ],
+});
+
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(new winston.transports.Console({
+    format: winston.format.simple(),
+  }));
+}
+
+export default logger;

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

@@ -0,0 +1,18 @@
+import { User as UserEntity } from '../../domain/user';
+import UserModel from '../database/models/User';
+
+export class UserRepository {
+    async save(user: UserEntity): Promise<UserEntity> {
+        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[]> {
+        const users = await UserModel.findAll();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email
+        }));
+    }
+}

package/templates/clean-architecture/ts/src/interfaces/controllers/userController.ts

@@ -0,0 +1,45 @@
+import { Request, Response } from 'express';
+import { UserRepository } from '../../infrastructure/repositories/UserRepository';
+import CreateUser from '../../usecases/createUser';
+import GetAllUsers from '../../usecases/getAllUsers';
+import { HTTP_STATUS } from '../../utils/httpCodes';
+
+export class UserController {
+    private createUserUseCase: CreateUser;
+    private getAllUsersUseCase: GetAllUsers;
+
+    constructor() {
+        const userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(userRepository);
+    }
+
+    async createUser(req: Request, res: Response) {
+        try {
+            const { name, email } = req.body;
+            const user = await this.createUserUseCase.execute(name, email);
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            console.error('UserController Error:', error);
+            if (error instanceof Error) {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+            } else {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
+            }
+        }
+    }
+
+    async getUsers(req: Request, res: Response) {
+        try {
+            const users = await this.getAllUsersUseCase.execute();
+            res.json(users);
+        } catch (error) {
+            console.error('UserController Error:', error);
+            if (error instanceof Error) {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: error.message });
+            } else {
+                res.status(HTTP_STATUS.INTERNAL_SERVER_ERROR).json({ error: 'Unknown error occurred' });
+            }
+        }
+    }
+}

package/templates/clean-architecture/ts/src/interfaces/routes/userRoutes.ts

@@ -0,0 +1,76 @@
+import { Router, Request, Response } from 'express';
+import { UserController } from '../controllers/userController';
+
+const router = Router();
+const userController = new UserController();
+
+/**
+ * @swagger
+ * components:
+ *   schemas:
+ *     User:
+ *       type: object
+ *       required:
+ *         - name
+ *         - email
+ *       properties:
+ *         id:
+ *           type: integer
+ *           description: The auto-generated id of the user
+ *         name:
+ *           type: string
+ *           description: The name of the user
+ *         email:
+ *           type: string
+ *           description: The email of the user
+ *       example:
+ *         id: 1
+ *         name: John Doe
+ *         email: john@example.com
+ */
+
+/**
+ * @swagger
+ * tags:
+ *   name: Users
+ *   description: The users managing API
+ */
+
+/**
+ * @swagger
+ * /api/users:
+ *   get:
+ *     summary: Returns the list of all the users
+ *     tags: [Users]
+ *     responses:
+ *       200:
+ *         description: The list of the users
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/User'
+ *   post:
+ *     summary: Create a new user
+ *     tags: [Users]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/User'
+ *     responses:
+ *       201:
+ *         description: The created user.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/User'
+ *       500:
+ *         description: Some server error
+ */
+router.post('/', (req: Request, res: Response) => userController.createUser(req, res));
+router.get('/', (req: Request, res: Response) => userController.getUsers(req, res));
+
+export default router;

package/templates/clean-architecture/ts/src/usecases/createUser.ts

@@ -0,0 +1,13 @@
+import { User } from '../domain/user';
+
+import { UserRepository } from '../infrastructure/repositories/UserRepository';
+
+export default class CreateUser {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute(name: string, email: string) {
+        const user = new User(null, name, email);
+        return this.userRepository.save(user);
+    }
+}
+

package/templates/clean-architecture/ts/src/usecases/getAllUsers.ts

@@ -0,0 +1,10 @@
+import { UserRepository } from '../infrastructure/repositories/UserRepository';
+
+export default class GetAllUsers {
+    constructor(private userRepository: UserRepository) {}
+
+    async execute() {
+        return this.userRepository.getUsers();
+    }
+}
+

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

@@ -0,0 +1,7 @@
+export const HTTP_STATUS = {
+    OK: 200,
+    CREATED: 201,
+    BAD_REQUEST: 400,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500
+} as const;

package/templates/common/.dockerignore

@@ -0,0 +1,10 @@
+node_modules
+npm-debug.log
+dist
+.env
+.git
+.gitignore
+README.md
+docker-compose.yml
+test_results.log
+flyway/sql

package/templates/common/.eslintrc.json.ejs

@@ -0,0 +1,26 @@
+{
+  "env": {
+    "node": true,
+    "es2021": true,
+    "jest": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "prettier"<% if (language === 'TypeScript') { %>,
+    "plugin:@typescript-eslint/recommended"<% } %>
+  ],
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  }<% if (language === 'TypeScript') { %>,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"]<% } %>,
+  "rules": {
+    "no-console": "warn",
+    <% if (language === 'TypeScript') { %>
+    "no-unused-vars": "off",
+    "@typescript-eslint/no-unused-vars": "warn"
+    <% } else { %>
+    "no-unused-vars": "warn"<% } %>
+  }
+}

package/templates/common/.lintstagedrc

@@ -0,0 +1,6 @@
+{
+  "*.{js,ts}": [
+    "eslint --fix",
+    "prettier --write"
+  ]
+}