nodejs-quickstart-structure 1.9.2 → 1.10.0

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

@@ -3,27 +3,41 @@ const cors = require('cors');
 require('dotenv').config();
 const logger = require('../log/logger');
 const morgan = require('morgan');
-<% if (communication === 'REST APIs') { %>const apiRoutes = require('../../interfaces/routes/api');<% } -%>
-<% if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('../../interfaces/routes/api');<%_ } -%>
+<%_ if (communication === 'REST APIs') { -%>
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./swagger');
-<% } -%>
+<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+const { ApolloServer } = require('@apollo/server');
+const { expressMiddleware } = require('@apollo/server/express4');
+const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
+const { typeDefs, resolvers } = require('../../interfaces/graphql');
+const { gqlContext } = require('../../interfaces/graphql/context');
+<%_ } -%>
 
-const startServer = (port) => {
+const startServer = async (port) => {
     const app = express();
 
     app.use(cors());
     app.use(express.json());
     app.use(morgan('combined', { stream: { write: message => logger.info(message.trim()) } }));
-
-    <% if (communication === 'REST APIs') { -%>
+    <%_ if (communication === 'REST APIs') { -%>
     app.use('/api', apiRoutes);
-    <% } -%>
-
-    <% if (communication === 'REST APIs') { -%>
+    <%_ } -%>
+    <%_ if (communication === 'REST APIs') { -%>
     app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-    <% } -%>
-
+    <%_ } -%>
+    <%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const server = new ApolloServer({
+        typeDefs,
+        resolvers,
+        plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+    });
+    await server.start();
+    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    <%_ } -%>
     app.get('/health', (req, res) => {
         res.json({ status: 'UP' });
     });

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

@@ -1,23 +1,6 @@
-const swaggerJsdoc = require('swagger-jsdoc');
+const path = require('path');
+const YAML = require('yamljs');
 
-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 swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
 
-const specs = swaggerJsdoc(options);
-
-module.exports = specs;
+module.exports = swaggerDocument;

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

@@ -1,7 +1,9 @@
 const CreateUser = require('../../usecases/CreateUser');
 const GetAllUsers = require('../../usecases/GetAllUsers');
 const UserRepository = require('../../infrastructure/repositories/UserRepository');
+<% if (communication !== 'GraphQL') { -%>
 const HTTP_STATUS = require('../../utils/httpCodes');
+<% } -%>
 const logger = require('../../infrastructure/log/logger');
 
 class UserController {
@@ -11,6 +13,26 @@ class UserController {
         this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
     }
 
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+            return await this.getAllUsersUseCase.execute();
+        } catch (error) {
+            logger.error('Error getting users:', error);
+            throw error;
+        }
+    }
+
+    async createUser(data) {
+        const { name, email } = data;
+        try {
+            return await this.createUserUseCase.execute(name, email);
+        } catch (error) {
+            logger.error('Error creating user:', error);
+            throw error;
+        }
+    }
+<% } else { -%>
     getUsers(req, res) {
         this.getAllUsersUseCase.execute()
             .then(users => res.json(users))
@@ -30,6 +52,7 @@ class UserController {
             res.status(HTTP_STATUS.BAD_REQUEST).json({ error: error.message });
         }
     }
+<% } -%>
 }
 
 module.exports = UserController;

package/templates/clean-architecture/js/src/interfaces/graphql/context.js.ejs

@@ -0,0 +1,13 @@
+const UserRepository = require('../../infrastructure/repositories/UserRepository');
+
+const gqlContext = async ({ req }) => {
+  const token = req.headers.authorization || '';
+  const userRepository = new UserRepository();
+  
+  return { 
+    token, 
+    userRepository 
+  };
+};
+
+module.exports = { gqlContext };

package/templates/clean-architecture/js/src/interfaces/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/clean-architecture/js/src/interfaces/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/clean-architecture/js/src/interfaces/graphql/resolvers/user.resolvers.js.ejs

@@ -0,0 +1,27 @@
+const { GraphQLError } = require('graphql');
+const UserController = require('../../controllers/userController');
+
+const userController = new UserController();
+
+const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      try {
+        return await userController.getUsers();
+      } catch (error) {
+        throw new GraphQLError(error.message || 'Internal server error', { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
+      }
+    }
+  },
+  Mutation: {
+    createUser: async (_, { name, email }) => {
+      try {
+        return await userController.createUser({ name, email });
+      } catch (error) {
+        throw new GraphQLError(error.message || 'Internal server error', { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
+      }
+    }
+  }
+};
+
+module.exports = { userResolvers };

package/templates/clean-architecture/js/src/interfaces/graphql/typeDefs/index.js.ejs

@@ -0,0 +1,6 @@
+const { mergeTypeDefs } = require('@graphql-tools/merge');
+const { userTypes } = require('./user.types');
+
+const typeDefs = mergeTypeDefs([userTypes]);
+
+module.exports = { typeDefs };

package/templates/clean-architecture/js/src/interfaces/graphql/typeDefs/user.types.js.ejs

@@ -0,0 +1,17 @@
+const userTypes = `#graphql
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+  }
+
+  type Query {
+    getAllUsers: [User]
+  }
+
+  type Mutation {
+    createUser(name: String!, email: String!): User
+  }
+`;
+
+module.exports = { userTypes };

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

@@ -2,75 +2,8 @@ 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));
 

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

@@ -1,23 +1,6 @@
-<% if (communication === 'REST APIs') { %>import swaggerJsdoc from 'swagger-jsdoc';
+<% if (communication === 'REST APIs') { %>import path from 'path';
+import YAML from 'yamljs';
 
-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 swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
 
-const specs = swaggerJsdoc(options);
-
-export default specs;<% } %>
+export default swaggerDocument;<% } %>

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

@@ -6,11 +6,18 @@ import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
 import logger from '@/infrastructure/log/logger';
 import morgan from 'morgan';
-<% if (communication === 'REST APIs') { %>import userRoutes from '@/interfaces/routes/userRoutes';<% } -%>
+<%_ 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';<% } -%>
+<%_ if (communication === 'Kafka') { -%>import { KafkaService } from '@/infrastructure/messaging/kafkaClient';<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@apollo/server/express4';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { typeDefs, resolvers } from '@/interfaces/graphql';
+import { gqlContext, MyContext } from '@/interfaces/graphql/context';
+<% } -%>
 
 dotenv.config();
 
@@ -18,7 +25,21 @@ const app = express();
 const port = process.env.PORT || 3000;
 
 // Security Middleware
+<%_ if (communication === 'GraphQL') { -%>
+app.use(helmet({
+  crossOriginEmbedderPolicy: false,
+  contentSecurityPolicy: {
+    directives: {
+      imgSrc: [`'self'`, 'data:', 'apollo-server-landing-page.cdn.apollographql.com'],
+      scriptSrc: [`'self'`, `https: 'unsafe-inline'`],
+      manifestSrc: [`'self'`, 'apollo-server-landing-page.cdn.apollographql.com'],
+      frameSrc: [`'self'`, 'sandbox.embed.apollographql.com'],
+    },
+  },
+}));
+<%_ } else { -%>
 app.use(helmet());
+<%_ } -%>
 app.use(hpp());
 app.use(cors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'DELETE'] }));
 const limiter = rateLimit({ windowMs: 10 * 60 * 1000, max: 100 });
@@ -27,32 +48,42 @@ app.use(limiter);
 app.use(express.json());
 app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
 
-<% if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs') { -%>
 app.use('/api/users', userRoutes);
-<% } -%>
-
-<% if (communication === 'REST APIs') { -%>
+<%_ } -%>
+<%_ if (communication === 'REST APIs') { -%>
 app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-<% } -%>
-
+<%_ } -%>
 app.get('/health', (req: Request, res: Response) => {
   res.json({ status: 'UP' });
 });
 
 // Start Server Logic
 const startServer = async () => {
-    logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const server = new ApolloServer<MyContext>({
+      typeDefs,
+      resolvers,
+      plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
+    });
+    await server.start();
+    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+<%_ } -%>
+    app.listen(port, () => {
+        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);
-    }
+        try {
+          const kafkaService = new KafkaService();
+          kafkaService.connect().then(() => {
+            logger.info('Kafka connected');
+            kafkaService.sendMessage('test-topic', 'Hello Kafka from Clean Arch TS!');
+          });
+        } catch (err) {
+          logger.error('Failed to connect to Kafka:', err);
+        }
 <%_ } -%>
+    });
 };
 
 <%_ if (database !== 'None') { -%>
@@ -69,7 +100,7 @@ const syncDatabase = async () => {
             await sequelize.sync();
             <%_ } -%>
             logger.info('Database synced');
-            app.listen(port, startServer);
+            await startServer();
             break;
         } catch (error) {
             logger.error('Error syncing database:', error);
@@ -82,5 +113,5 @@ const syncDatabase = async () => {
 
 syncDatabase();
 <%_ } else { -%>
-app.listen(port, startServer);
+startServer();
 <%_ } -%>

package/templates/clean-architecture/ts/src/interfaces/controllers/{userController.ts → userController.ts.ejs}

@@ -1,8 +1,10 @@
+<% if (communication !== 'GraphQL') { -%>
 import { Request, Response } from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
 import { UserRepository } from '@/infrastructure/repositories/UserRepository';
 import CreateUser from '@/usecases/createUser';
 import GetAllUsers from '@/usecases/getAllUsers';
-import { HTTP_STATUS } from '@/utils/httpCodes';
 import logger from '@/infrastructure/log/logger';
 
 export class UserController {
@@ -15,6 +17,30 @@ export class UserController {
         this.getAllUsersUseCase = new GetAllUsers(userRepository);
     }
 
+<% if (communication === 'GraphQL') { -%>
+    async createUser(data: { name: string, email: string }) {
+        try {
+            const { name, email } = data;
+            const user = await this.createUserUseCase.execute(name, email);
+            return user;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('UserController Error:', message);
+            throw error;
+        }
+    }
+
+    async getUsers() {
+        try {
+            const users = await this.getAllUsersUseCase.execute();
+            return users;
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            logger.error('UserController Error:', message);
+            throw error;
+        }
+    }
+<% } else { -%>
     async createUser(req: Request, res: Response) {
         try {
             const { name, email } = req.body;
@@ -43,4 +69,5 @@ export class UserController {
             }
         }
     }
+<% } -%>
 }

package/templates/clean-architecture/ts/src/interfaces/graphql/context.ts.ejs

@@ -0,0 +1,17 @@
+import { Request } from 'express';
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+
+export interface MyContext {
+  token?: string;
+  userRepository: UserRepository;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  const token = req.headers.authorization || '';
+  const userRepository = new UserRepository();
+  
+  return { 
+    token, 
+    userRepository 
+  };
+};

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

@@ -0,0 +1,3 @@
+export { typeDefs } from '@/interfaces/graphql/typeDefs';
+export { resolvers } from '@/interfaces/graphql/resolvers';
+export { gqlContext, MyContext } from '@/interfaces/graphql/context';

package/templates/clean-architecture/ts/src/interfaces/graphql/resolvers/index.ts.ejs

@@ -0,0 +1,4 @@
+import { mergeResolvers } from '@graphql-tools/merge';
+import { userResolvers } from '@/interfaces/graphql/resolvers/user.resolvers';
+
+export const resolvers = mergeResolvers([userResolvers]);

package/templates/clean-architecture/ts/src/interfaces/graphql/resolvers/user.resolvers.ts.ejs

@@ -0,0 +1,27 @@
+import { GraphQLError } from 'graphql';
+import { UserController } from '@/interfaces/controllers/userController';
+
+const userController = new UserController();
+
+export const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      try {
+        return await userController.getUsers();
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Internal server error';
+        throw new GraphQLError(message, { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
+      }
+    }
+  },
+  Mutation: {
+    createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
+      try {
+        return await userController.createUser({ name, email });
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Internal server error';
+        throw new GraphQLError(message, { extensions: { code: 'INTERNAL_SERVER_ERROR' } });
+      }
+    }
+  }
+};

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/index.ts.ejs

@@ -0,0 +1,4 @@
+import { mergeTypeDefs } from '@graphql-tools/merge';
+import { userTypes } from './user.types';
+
+export const typeDefs = mergeTypeDefs([userTypes]);

package/templates/clean-architecture/ts/src/interfaces/graphql/typeDefs/user.types.ts.ejs

@@ -0,0 +1,15 @@
+export const userTypes = `#graphql
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+  }
+
+  type Query {
+    getAllUsers: [User]
+  }
+
+  type Mutation {
+    createUser(name: String!, email: String!): User
+  }
+`;

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

@@ -4,72 +4,6 @@ import { UserController } from '@/interfaces/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));
 

package/templates/common/Dockerfile

@@ -1,7 +1,7 @@
 # ==========================================
 # Stage 1: Builder
 # ==========================================
-FROM node:18-alpine AS builder
+FROM node:22-alpine AS builder
 
 WORKDIR /app
 
@@ -19,7 +19,7 @@ COPY . .
 # ==========================================
 # Stage 2: Production
 # ==========================================
-FROM node:18-alpine AS production
+FROM node:22-alpine AS production
 
 WORKDIR /app