nodejs-quickstart-structure 1.18.0 → 1.19.0

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

@@ -1,21 +1,29 @@
-import { UserController } from '@/controllers/userController';
-
-const userController = new UserController();
-
-export const userResolvers = {
-  Query: {
-    getAllUsers: async () => {
-      const users = await userController.getUsers();
-      return users;
-    }
-  },
-  Mutation: {
-    createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
-      const user = await userController.createUser({ name, email });
-      return user;
-    }
-  }<%_ if (database === 'MongoDB') { -%>,
-  User: {
-    id: (parent: { id?: string; _id?: unknown }) => parent.id || parent._id
-  }<%_ } %>
-};
+import { UserController } from '@/controllers/userController';
+
+const userController = new UserController();
+
+export const userResolvers = {
+  Query: {
+    getAllUsers: async () => {
+      const users = await userController.getUsers();
+      return users;
+    }
+  },
+  Mutation: {
+    createUser: async (_: unknown, { name, email }: { name: string, email: string }) => {
+      const user = await userController.createUser({ name, email });
+      return user;
+    },
+    updateUser: async (_: unknown, { id, name, email }: { id: string, name?: string, email?: string }) => {
+      const user = await userController.updateUser(id, { name, email });
+      return user;
+    },
+    deleteUser: async (_: unknown, { id }: { id: string }) => {
+      const result = await userController.deleteUser(id);
+      return result;
+    }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent: { id?: string; _id?: unknown }) => parent.id || parent._id
+  }<%_ } %>
+};

package/templates/mvc/ts/src/graphql/typeDefs/user.types.ts.ejs

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

package/templates/mvc/ts/src/index.ts.ejs

@@ -1,154 +1,157 @@
-import { env } from '@/config/env';
-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 logger from '@/utils/logger';
-import morgan from 'morgan';
-import { errorMiddleware } from '@/utils/errorMiddleware';
-import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
-import healthRoutes from '@/routes/healthRoute';
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-import apiRoutes from '@/routes/api';
-import swaggerUi from 'swagger-ui-express';
-import swaggerSpecs from '@/config/swagger';<%_ } %>
-<%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/services/kafkaService';<%_ } -%>
-<%_ if (communication === 'GraphQL') { -%>
-import { ApolloServer } from '@apollo/server';
-import { expressMiddleware } from '@apollo/server/express4';
-import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
-import { unwrapResolverError } from '@apollo/server/errors';
-import { ApiError } from '@/errors/ApiError';
-import { typeDefs, resolvers } from '@/graphql';
-import { gqlContext, MyContext } from '@/graphql/context';
-<% } -%>
-
-const app = express();
-const port = env.PORT;
-
-// 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 });
-app.use(limiter);
-
-app.use(express.json());
-app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-<%_ } -%>
-<%_ if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
-// View Engine Setup
-import path from 'path';
-app.set('views', path.join(__dirname, 'views'));
-app.set('view engine', '<%= viewEngine.toLowerCase() %>');
-app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-app.use('/api', apiRoutes);
-<%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
-app.get('/', (req: Request, res: Response) => {
-  res.render('index', { 
-    projectName: 'NodeJS Service',
-    architecture: 'MVC',
-    database: '<%= database %>',
-    communication: '<%= communication %>'
-  });
-});
-<% } -%>
-app.use('/health', healthRoutes);
-
-// Start Server Logic
-const startServer = async () => {
-<%_ if (communication === 'GraphQL') { -%>
-    // GraphQL Setup
-    const apolloServer = new ApolloServer<MyContext>({
-      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 instanceof Error && 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(errorMiddleware);
-    const server = app.listen(port, () => {
-        logger.info(`Server running on port ${port}`);
-<%_ if (communication === 'Kafka') { -%>
-        kafkaService.connect()
-            .then(async () => {
-                logger.info('Kafka connected');
-            })
-            .catch(err => {
-                logger.error('Failed to connect to Kafka after retries:', (err as Error).message);
-            });
-<%_ } -%>
-    });
-
-    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
-};
-
-<%_ if (database !== 'None') { -%>
-// Database Sync
-<%_ if (database !== 'None') { -%>
-import <% if (database === 'MongoDB') { %>connectDB<% } else { %>sequelize<% } %> from '@/config/database';
-<%_ } -%>
-const syncDatabase = async () => {
-    let retries = 30;
-    while (retries) {
-        try {
-            <%_ if (database === 'MongoDB') { -%>
-            await connectDB();
-            <%_ } else { -%>
-            await sequelize.sync();
-            <%_ } -%>
-            logger.info('Database synced');
-            // Start Server after DB is ready
-            await startServer();
-            break;
-        } catch (error) {
-            logger.error('Error syncing database:', error);
-            retries -= 1;
-            logger.info(`Retries left: ${retries}`);
-            await new Promise(res => setTimeout(res, 5000));
-        }
-    }
-};
-
-syncDatabase();
-<%_ } else { -%>
-startServer();
+import { env } from '@/config/env';
+import express from 'express';
+<% if (viewEngine && viewEngine !== 'None') { -%>
+import type { Request, Response } from 'express';
+<% } -%>
+import cors from 'cors';
+import helmet from 'helmet';
+import hpp from 'hpp';
+import rateLimit from 'express-rate-limit';
+import logger from '@/utils/logger';
+import morgan from 'morgan';
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/routes/healthRoute';
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+import apiRoutes from '@/routes/api';
+import swaggerUi from 'swagger-ui-express';
+import swaggerSpecs from '@/config/swagger';<%_ } %>
+<%_ if (communication === 'Kafka') { -%>import { kafkaService } from '@/services/kafkaService';<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+import { ApolloServer } from '@apollo/server';
+import { expressMiddleware } from '@as-integrations/express4';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { unwrapResolverError } from '@apollo/server/errors';
+import { ApiError } from '@/errors/ApiError';
+import { typeDefs, resolvers } from '@/graphql';
+import { gqlContext, MyContext } from '@/graphql/context';
+<% } -%>
+
+const app = express();
+const port = env.PORT;
+
+// 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 });
+app.use(limiter);
+
+app.use(express.json());
+app.use(morgan('combined', { stream: { write: (message) => logger.info(message.trim()) } }));
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+<%_ } -%>
+<%_ if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
+// View Engine Setup
+import path from 'path';
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', '<%= viewEngine.toLowerCase() %>');
+app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+app.use('/api', apiRoutes);
+<%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
+app.get('/', (req: Request, res: Response) => {
+  res.render('index', { 
+    projectName: 'NodeJS Service',
+    architecture: 'MVC',
+    database: '<%= database %>',
+    communication: '<%= communication %>'
+  });
+});
+<% } -%>
+app.use('/health', healthRoutes);
+
+// Start Server Logic
+const startServer = async () => {
+<%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const apolloServer = new ApolloServer<MyContext>({
+      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 instanceof Error && 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(errorMiddleware);
+    const server = app.listen(port, () => {
+        logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'Kafka') { -%>
+        kafkaService.connect()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', (err as Error).message);
+            });
+<%_ } -%>
+    });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
+};
+
+<%_ if (database !== 'None') { -%>
+// Database Sync
+<%_ if (database !== 'None') { -%>
+import <% if (database === 'MongoDB') { %>connectDB<% } else { %>sequelize<% } %> from '@/config/database';
+<%_ } -%>
+const syncDatabase = async () => {
+    let retries = 30;
+    while (retries) {
+        try {
+            <%_ if (database === 'MongoDB') { -%>
+            await connectDB();
+            <%_ } else { -%>
+            await sequelize.sync();
+            <%_ } -%>
+            logger.info('Database synced');
+            // Start Server after DB is ready
+            await startServer();
+            break;
+        } catch (error) {
+            logger.error('Error syncing database:', error);
+            retries -= 1;
+            logger.info(`Retries left: ${retries}`);
+            await new Promise(res => setTimeout(res, 5000));
+        }
+    }
+};
+
+syncDatabase();
+<%_ } else { -%>
+startServer();
 <%_ } -%>

package/templates/mvc/ts/src/routes/api.spec.ts.ejs

@@ -1,40 +1,59 @@
-import request from 'supertest';
-import express, { Express } from 'express';
-import router from '@/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('@/controllers/userController', () => {
-  return {
-    UserController: jest.fn().mockImplementation(() => ({
-      getUsers: (...args: unknown[]) => mockGetUsers(...args),
-      createUser: (...args: unknown[]) => mockCreateUser(...args)
-    }))
-  };
-});
-
-describe('ApiRoutes', () => {
-    let app: Express;
-
-    beforeEach(() => {
-        app = express();
-        app.use(express.json());
-        app.use('/api', router);
-    });
-
-    it('GET /users should call controller.getUsers', async () => {
-        await request(app)
-            .get('/api/users');
-
-        expect(mockGetUsers).toHaveBeenCalledTimes(1);
-    });
-
-    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);
-    });
-});
+import request from 'supertest';
+import express, { Express } from 'express';
+import router from '@/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' }));
+const mockUpdateUser = jest.fn().mockImplementation((req, res) => res.status(200).json({ id: '1', name: 'Updated' }));
+const mockDeleteUser = jest.fn().mockImplementation((req, res) => res.status(204).send());
+
+jest.mock('@/controllers/userController', () => {
+  return {
+    UserController: jest.fn().mockImplementation(() => ({
+      getUsers: (...args: unknown[]) => mockGetUsers(...args),
+      createUser: (...args: unknown[]) => mockCreateUser(...args),
+      updateUser: (...args: unknown[]) => mockUpdateUser(...args),
+      deleteUser: (...args: unknown[]) => mockDeleteUser(...args)
+    }))
+  };
+});
+
+describe('ApiRoutes', () => {
+    let app: Express;
+
+    beforeEach(() => {
+        app = express();
+        app.use(express.json());
+        app.use('/api', router);
+    });
+
+    it('GET /api/users should call controller.getUsers', async () => {
+        await request(app)
+            .get('/api/users');
+
+        expect(mockGetUsers).toHaveBeenCalledTimes(1);
+    });
+
+    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('PATCH /api/users/:id should call controller.updateUser', async () => {
+        await request(app)
+            .patch('/api/users/1')
+            .send({ name: 'Updated' });
+
+        expect(mockUpdateUser).toHaveBeenCalledTimes(1);
+    });
+
+    it('DELETE /api/users/:id should call controller.deleteUser', async () => {
+        await request(app)
+            .delete('/api/users/1');
+
+        expect(mockDeleteUser).toHaveBeenCalledTimes(1);
+    });
+});

package/templates/mvc/ts/src/routes/api.ts

@@ -1,10 +1,12 @@
-import { Router, Request, Response, NextFunction } from 'express';
-import { UserController } from '@/controllers/userController';
-
-const router = Router();
-const userController = new UserController();
-
-router.get('/users', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
-router.post('/users', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
-
-export default router;
+import { Router, Request, Response, NextFunction } from 'express';
+import { UserController } from '@/controllers/userController';
+
+const router = Router();
+const userController = new UserController();
+
+router.get('/users', (req: Request, res: Response, next: NextFunction) => userController.getUsers(req, res, next));
+router.post('/users', (req: Request, res: Response, next: NextFunction) => userController.createUser(req, res, next));
+router.patch('/users/:id', (req: Request, res: Response, next: NextFunction) => userController.updateUser(req, res, next));
+router.delete('/users/:id', (req: Request, res: Response, next: NextFunction) => userController.deleteUser(req, res, next));
+
+export default router;

package/templates/mvc/ts/src/utils/errorMessages.ts

@@ -0,0 +1,12 @@
+export const ERROR_MESSAGES = {
+    USER_NOT_FOUND: 'User not found',
+    RESOURCE_NOT_FOUND: 'Resource not found',
+    INVALID_USER_DATA: 'Invalid user event data',
+    INTERNAL_SERVER_ERROR: 'Internal Server Error',
+    BAD_REQUEST: 'Bad Request',
+    FETCH_USERS_ERROR: 'Error fetching users',
+    CREATE_USER_ERROR: 'Error creating user',
+    UPDATE_USER_ERROR: 'Error updating user',
+    DELETE_USER_ERROR: 'Error deleting user',
+    DATABASE_PING_FAILED: 'Health Check Database Ping Failed',
+} as const;

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

@@ -1,37 +0,0 @@
-import { User as UserEntity } from '@/domain/user';
-import UserModel from '@/infrastructure/database/models/User';
-
-export class UserRepository {
-    async save(user: UserEntity): Promise<UserEntity> {
-<%_ if (database === 'MongoDB') { -%>
-        const newUser = await UserModel.create({ name: user.name, email: user.email });
-        return { id: newUser._id.toString(), name: newUser.name, email: newUser.email };
-<%_ } else if (database === 'None') { -%>
-        const newUser = await UserModel.create(user);
-        return newUser;
-<%_ } else { -%>
-        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[]> {
-<%_ if (database === 'MongoDB') { -%>
-        const users = await UserModel.find();
-        return users.map(user => ({
-            id: user._id.toString(),
-            name: user.name,
-            email: user.email
-        }));
-<%_ } else if (database === 'None') { -%>
-        return await UserModel.find();
-<%_ } else { -%>
-        const users = await UserModel.findAll();
-        return users.map(user => ({
-            id: user.id,
-            name: user.name,
-            email: user.email
-        }));
-<%_ } -%>
-    }
-}