nodejs-quickstart-structure 1.11.1 → 1.13.0

package/templates/mvc/js/src/config/env.js.ejs

@@ -0,0 +1,46 @@
+const { z } = require('zod');
+const logger = require('../utils/logger');
+
+if (process.env.NODE_ENV !== 'production') {
+  require('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);
+}
+
+const env = _env.data;
+
+module.exports = { env };

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

@@ -10,7 +10,10 @@ const userResolvers = {
     createUser: async (_, { name, email }) => {
       return await userController.createUser({ name, email });
     }
-  }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent) => parent.id || parent._id
+  }<%_ } %>
 };
 
 module.exports = { userResolvers };

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

@@ -1,7 +1,7 @@
 const express = require('express');
 const cors = require('cors');
-require('dotenv').config();
 <%_ if (communication === 'REST APIs') { -%>const apiRoutes = require('./routes/api');<%_ } -%>
+const healthRoutes = require('./routes/healthRoute');
 <%_ if (communication === 'Kafka') { -%>const { connectKafka, sendMessage } = require('./services/kafkaService');<%_ } -%>
 <%_ if (communication === 'GraphQL') { -%>
 const { ApolloServer } = require('@apollo/server');
@@ -16,12 +16,13 @@ const { gqlContext } = require('./graphql/context');
 const swaggerUi = require('swagger-ui-express');
 const swaggerSpecs = require('./config/swagger');
 <%_ } -%>
+const { env } = require('./config/env');
 
 const app = express();
-const PORT = process.env.PORT || 3000;
+const PORT = env.PORT;
 const logger = require('./utils/logger');
 const morgan = require('morgan');
-const { errorMiddleware } = require('./utils/error.middleware');
+const { errorMiddleware } = require('./utils/errorMiddleware');
 
 app.use(cors());
 app.use(express.json());
@@ -48,15 +49,13 @@ app.get('/', (req, res) => {
   });
 });
 <% } -%>
-app.get('/health', (req, res) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer({
+    const apolloServer = new ApolloServer({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -80,11 +79,11 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(PORT, () => {
+    const server = app.listen(PORT, () => {
         logger.info(`Server running on port ${PORT}`);
 <%_ if (communication === 'Kafka') { -%>
         connectKafka().then(() => {
@@ -95,6 +94,9 @@ const startServer = async () => {
         });
 <%_ } -%>
     });
+
+    const setupGracefulShutdown = require('./utils/gracefulShutdown');
+    setupGracefulShutdown(server);
 };
 
 <%_ if (database !== 'None') { -%>

package/templates/mvc/js/src/utils/{error.middleware.js → errorMiddleware.js}

@@ -2,7 +2,8 @@ const logger = require('./logger');
 const { ApiError } = require('../errors/ApiError');
 const HTTP_STATUS = require('./httpCodes');
 
-const errorMiddleware = (err, req, res, _) => {
+// eslint-disable-next-line no-unused-vars
+const errorMiddleware = (err, req, res, next) => {
   let error = err;
 
   if (!(error instanceof ApiError)) {

package/templates/mvc/ts/src/config/env.ts.ejs

@@ -0,0 +1,45 @@
+import dotenv from 'dotenv';
+import { z } from 'zod';
+import logger from '@/utils/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/mvc/ts/src/graphql/resolvers/user.resolvers.ts.ejs

@@ -14,5 +14,8 @@ export const userResolvers = {
       const user = await userController.createUser({ name, email });
       return user;
     }
-  }
+  }<%_ if (database === 'MongoDB') { -%>,
+  User: {
+    id: (parent: { id?: string; _id?: unknown }) => parent.id || parent._id
+  }<%_ } %>
 };

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

@@ -1,12 +1,14 @@
+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 dotenv from 'dotenv';
 import logger from '@/utils/logger';
 import morgan from 'morgan';
-import { errorMiddleware } from '@/utils/error.middleware';
+import { errorMiddleware } from '@/utils/errorMiddleware';
+import { setupGracefulShutdown } from '@/utils/gracefulShutdown';
+import healthRoutes from '@/routes/healthRoute';
 <%_ if (communication === 'REST APIs') { -%>
 import apiRoutes from '@/routes/api';<%_ } -%>
 <% if (communication === 'REST APIs') { %>
@@ -23,10 +25,8 @@ import { typeDefs, resolvers } from '@/graphql';
 import { gqlContext, MyContext } from '@/graphql/context';
 <% } -%>
 
-dotenv.config();
-
 const app = express();
-const port = process.env.PORT || 3000;
+const port = env.PORT;
 
 // Security Middleware
 <%_ if (communication === 'GraphQL') { -%>
@@ -72,15 +72,13 @@ app.get('/', (req: Request, res: Response) => {
   });
 });
 <% } -%>
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'UP' });
-});
+app.use('/health', healthRoutes);
 
 // Start Server Logic
 const startServer = async () => {
 <%_ if (communication === 'GraphQL') { -%>
     // GraphQL Setup
-    const server = new ApolloServer<MyContext>({
+    const apolloServer = new ApolloServer<MyContext>({
       typeDefs,
       resolvers,
       plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })],
@@ -104,24 +102,26 @@ const startServer = async () => {
         return formattedError;
       },
     });
-    await server.start();
-    app.use('/graphql', expressMiddleware(server, { context: gqlContext }));
+    await apolloServer.start();
+    app.use('/graphql', expressMiddleware(apolloServer, { context: gqlContext }));
 <%_ } -%>
     app.use(errorMiddleware);
-    app.listen(port, () => {
+<%_ if (communication === 'Kafka') { -%>
+    const kafkaService = new KafkaService();
+<%_ } -%>
+    const server = app.listen(port, () => {
         logger.info(`Server running on port ${port}`);
 <%_ if (communication === 'Kafka') { -%>
-        try {
-          const kafkaService = new KafkaService();
-          kafkaService.connect().then(() => {
-            logger.info('Kafka connected');
-            kafkaService.sendMessage('test-topic', 'Hello Kafka from MVC TS!');
-          });
-        } catch (err) {
+        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);
-        }
+        });
 <%_ } -%>
     });
+
+    setupGracefulShutdown(server<% if(communication === 'Kafka') { %>, kafkaService<% } %>);
 };
 
 <%_ if (database !== 'None') { -%>

package/templates/mvc/ts/src/utils/{error.middleware.ts.ejs → errorMiddleware.ts.ejs}

@@ -3,7 +3,8 @@ import logger from '@/utils/logger';
 import { ApiError } from '@/errors/ApiError';
 import { HTTP_STATUS } from '@/utils/httpCodes';
 
-export const errorMiddleware = (err: Error, req: Request, res: Response, _: unknown) => {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const errorMiddleware = (err: Error, req: Request, res: Response, next: unknown) => {
   let error = err;
 
   if (!(error instanceof ApiError)) {

package/templates/clean-architecture/js/src/domain/repositories/UserRepository.js

@@ -1,9 +0,0 @@
-class UserRepository {
-    async save(user) {
-        // Database logic would go here
-        user.id = Math.floor(Math.random() * 1000);
-        return user;
-    }
-}
-
-module.exports = UserRepository;