nodejs-quickstart-structure 1.9.4 → 1.10.0

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

@@ -1,12 +1,19 @@
 const express = require('express');
 const cors = require('cors');
 require('dotenv').config();
-<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { %>const apiRoutes = require('./routes/api');<% } -%>
-<% if (communication === 'Kafka') { %>const { connectKafka, sendMessage } = require('./services/kafkaService');<% } -%>
-<% if (communication === 'REST APIs') { -%>
+<%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>const { connectKafka, sendMessage } = require('./services/kafkaService');<%_ } -%>
+<%_ 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('./graphql');
+const { gqlContext } = require('./graphql/context');
+<% } -%>
+<%_ if (communication === 'REST APIs') { -%>
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./config/swagger');
-<% } -%>
+<%_ } -%>
 
 const app = express();
 const PORT = process.env.PORT || 3000;
@@ -17,22 +24,18 @@ 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-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-<% } -%>
-
-<% if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
+<%_ } -%>
+<%_ if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
 // View Engine Setup
 const path = require('path');
 app.set('views', path.join(__dirname, 'views'));
 app.set('view engine', '<%= viewEngine.toLowerCase() %>');
-app.use(express.static(path.join(__dirname, '../public')));<% } -%>
-
-// Routes
-<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { -%>
+app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
+<%_ if (communication === 'REST APIs') { -%>
 app.use('/api', apiRoutes);
-<% } -%>
-<% if (viewEngine && viewEngine !== 'None') { -%>
+<%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
 app.get('/', (req, res) => {
   res.render('index', { 
     projectName: 'NodeJS Service',
@@ -42,24 +45,33 @@ app.get('/', (req, res) => {
   });
 });
 <% } -%>
-
 app.get('/health', (req, res) => {
   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({
+      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 {
-      await connectKafka();
-      logger.info('Kafka connected');
-      // Demo: Send a test message
-      await sendMessage('test-topic', 'Hello Kafka from MVC JS!');
-    } catch (err) {
-      logger.error('Failed to connect to Kafka:', err);
-    }
+        connectKafka().then(() => {
+          logger.info('Kafka connected');
+          sendMessage('test-topic', 'Hello Kafka from MVC JS!');
+        }).catch(err => {
+          logger.error('Failed to connect to Kafka:', err);
+        });
 <%_ } -%>
+    });
 };
 
 <%_ if (database !== 'None') { -%>
@@ -78,7 +90,7 @@ const syncDatabase = async () => {
             logger.info('Database synced');
             
             // Start Server after DB is ready
-            app.listen(PORT, startServer);
+            await startServer();
             break;
         } catch (err) {
             logger.error('Database sync failed:', err);
@@ -91,5 +103,5 @@ const syncDatabase = async () => {
 
 syncDatabase();
 <%_ } else { -%>
-app.listen(PORT, startServer);
+startServer();
 <%_ } -%>

package/templates/mvc/ts/src/controllers/userController.ts.ejs

@@ -1,6 +1,8 @@
+<% if (communication !== 'GraphQL') { -%>
 import { Request, Response } from 'express';
-import User from '@/models/User';
 import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
+import User from '@/models/User';
 import logger from '@/utils/logger';
 <%_ if (caching === 'Redis') { -%>
 import cacheService from '@/config/redisClient';
@@ -9,6 +11,58 @@ import cacheService from '@/config/memoryCache';
 <%_ } -%>
 
 export class UserController {
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            const users = await cacheService.getOrSet('users:all', async () => {
+<%_ if (database === 'MongoDB') { -%>
+                return await User.find();
+<%_ } else if (database === 'None') { -%>
+                return User.mockData;
+<%_ } else { -%>
+                return await User.findAll();
+<%_ } -%>
+            }, 60);
+<%_ } else { -%>
+<%_ if (database === 'MongoDB') { -%>
+            const users = await User.find();
+<%_ } else if (database === 'None') { -%>
+            const users = User.mockData;
+<%_ } else { -%>
+            const users = await User.findAll();
+<%_ } -%>
+<%_ } -%>
+            return users;
+        } catch (error) {
+            logger.error('Error fetching users:', error);
+            throw error;
+        }
+    }
+
+    async createUser(data: { name: string, email: string }) {
+        try {
+            const { name, email } = data;
+<%_ if (database === 'None') { -%>
+            const newUser = { id: String(User.mockData.length + 1), name, email };
+            User.mockData.push(newUser);
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+            return newUser;
+<%_ } else { -%>
+            const user = await User.create({ name, email });
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            await cacheService.del('users:all');
+<%_ } -%>
+            return user;
+<%_ } -%>
+        } catch (error) {
+            logger.error('Error creating user:', error);
+            throw error;
+        }
+    }
+<% } else { -%>
     async getUsers(req: Request, res: Response) {
         try {
 <%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
@@ -67,5 +121,6 @@ export class UserController {
             }
         }
     }
+<% } -%>
 }
 

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

@@ -0,0 +1,12 @@
+import { Request } from 'express';
+
+export interface MyContext {
+  token?: string;
+  // user?: User;
+}
+
+export const gqlContext = async ({ req }: { req: Request }): Promise<MyContext> => {
+  // Setup authorization or context here
+  const token = req.headers.authorization || '';
+  return { token };
+};

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { GraphQLError } from 'graphql';
+import { UserController } from '@/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/mvc/ts/src/graphql/typeDefs/index.ts.ejs

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

package/templates/mvc/ts/src/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/mvc/ts/src/index.ts.ejs

@@ -6,11 +6,19 @@ import rateLimit from 'express-rate-limit';
 import dotenv from 'dotenv';
 import logger from '@/utils/logger';
 import morgan from 'morgan';
-<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { %>import apiRoutes from '@/routes/api';<% } -%>
+<%_ if (communication === 'REST APIs') { -%>
+import apiRoutes from '@/routes/api';<%_ } -%>
 <% if (communication === 'REST APIs') { %>
 import swaggerUi from 'swagger-ui-express';
 import swaggerSpecs from '@/config/swagger';<% } -%>
-<% if (communication === 'Kafka') { %>import { KafkaService } from '@/services/kafkaService';<% } -%>
+<%_ 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 { typeDefs, resolvers } from '@/graphql';
+import { gqlContext, MyContext } from '@/graphql/context';
+<% } -%>
 
 dotenv.config();
 
@@ -18,7 +26,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 });
@@ -26,23 +48,18 @@ 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-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-<% } -%>
-
-<% if (viewEngine === 'EJS' || viewEngine === 'Pug') { -%>
+<%_ } -%>
+<%_ 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')));<% } -%>
-
-// Routes
-<% if (communication === 'REST APIs' || (viewEngine && viewEngine !== 'None')) { -%>
+app.use(express.static(path.join(__dirname, '../public')));<%_ } %>
+<%_ if (communication === 'REST APIs') { -%>
 app.use('/api', apiRoutes);
-<% } -%>
-<% if (viewEngine && viewEngine !== 'None') { -%>
+<%_ } -%><% if (viewEngine && viewEngine !== 'None') { -%>
 app.get('/', (req: Request, res: Response) => {
   res.render('index', { 
     projectName: 'NodeJS Service',
@@ -52,25 +69,36 @@ app.get('/', (req: Request, res: Response) => {
   });
 });
 <% } -%>
-
 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: Send a test message
-      await kafkaService.sendMessage('test-topic', 'Hello Kafka from MVC 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 MVC TS!');
+          });
+        } catch (err) {
+          logger.error('Failed to connect to Kafka:', err);
+        }
 <%_ } -%>
+    });
 };
 
 <%_ if (database !== 'None') { -%>
@@ -88,7 +116,7 @@ const syncDatabase = async () => {
             <%_ } -%>
             logger.info('Database synced');
             // Start Server after DB is ready
-            app.listen(port, startServer);
+            await startServer();
             break;
         } catch (error) {
             logger.error('Error syncing database:', error);
@@ -101,5 +129,5 @@ const syncDatabase = async () => {
 
 syncDatabase();
 <%_ } else { -%>
-app.listen(port, startServer);
+startServer();
 <%_ } -%>