nodejs-quickstart-structure 1.18.1 → 1.19.1

package/templates/clean-architecture/js/src/infrastructure/webserver/middleware/errorMiddleware.js

@@ -1,30 +1,30 @@
-const logger = require('../../log/logger');
-const { ApiError } = require('../../../errors/ApiError');
-const HTTP_STATUS = require('../../../utils/httpCodes');
-
-// eslint-disable-next-line no-unused-vars
-const errorMiddleware = (err, req, res, next) => {
-  let error = err;
-
-  if (!(error instanceof ApiError)) {
-    const statusCode = err.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
-    const message = error.message || 'Internal Server Error';
-    error = new ApiError(statusCode, message, false, err.stack);
-  }
-
-  const { statusCode, message } = error;
-
-  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
-    logger.error(error.stack || 'No stack trace');
-  }
-
-  res.status(statusCode).json({
-    statusCode,
-    message,
-    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
-  });
-};
-
-module.exports = { errorMiddleware };
-
+const logger = require('../../log/logger');
+const { ApiError } = require('../../../errors/ApiError');
+const HTTP_STATUS = require('../../../utils/httpCodes');
+
+// eslint-disable-next-line no-unused-vars
+const errorMiddleware = (err, req, res, next) => {
+  let error = err;
+
+  if (!(error instanceof ApiError)) {
+    const statusCode = err.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
+    const message = error.message || 'Internal Server Error';
+    error = new ApiError(statusCode, message, false, err.stack);
+  }
+
+  const { statusCode, message } = error;
+
+  if (statusCode === HTTP_STATUS.INTERNAL_SERVER_ERROR) {
+    logger.error(`${statusCode} - ${message} - ${req.originalUrl} - ${req.method} - ${req.ip}`);
+    logger.error(error.stack || 'No stack trace');
+  }
+
+  res.status(statusCode).json({
+    statusCode,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+};
+
+module.exports = { errorMiddleware };
+

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

@@ -1,89 +1,89 @@
-const express = require('express');
-const cors = require('cors');
-const logger = require('../log/logger');
-const morgan = require('morgan');
-const { errorMiddleware } = require('./middleware/errorMiddleware');
-const healthRoutes = require('../../interfaces/routes/healthRoute');
-const setupGracefulShutdown = require('../../utils/gracefulShutdown');
-<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-const apiRoutes = require('../../interfaces/routes/api');
-const swaggerUi = require('swagger-ui-express');
-const swaggerSpecs = require('./swagger');
-<%_ } -%>
-<%_ if (communication === 'GraphQL') { -%>
-const { ApolloServer } = require('@apollo/server');
-const { expressMiddleware } = require('@as-integrations/express4');
-const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
-const { unwrapResolverError } = require('@apollo/server/errors');
-const { ApiError } = require('../../errors/ApiError');
-const { typeDefs, resolvers } = require('../../interfaces/graphql');
-const { gqlContext } = require('../../interfaces/graphql/context');
-<%_ } -%>
-
-const { env } = require('../config/env');
-
-const startServer = async () => {
-    // Determine port using the validated env
-    const port = env.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' || communication === 'Kafka') { -%>
-    app.use('/api', apiRoutes);
-    <%_ } -%>
-    <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
-    app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
-    <%_ } -%>
-    <%_ if (communication === 'GraphQL') { -%>
-    // GraphQL Setup
-    const apolloServer = new ApolloServer({
-        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 && 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('/health', healthRoutes);
-
-    app.use(errorMiddleware);
-
-    const server = app.listen(port, () => {
-        logger.info(`Server running on port ${port}`);
-<%_ if (communication === 'Kafka') { -%>
-        const { connectKafka } = require('../../infrastructure/messaging/kafkaClient');
-        connectKafka()
-            .then(async () => {
-                logger.info('Kafka connected');
-            })
-            .catch(err => {
-                logger.error('Failed to connect to Kafka after retries:', err.message);
-            });
-<%_ } -%>
-    });
-
-    setupGracefulShutdown(server);
-};
-
-module.exports = startServer;
+const express = require('express');
+const cors = require('cors');
+const logger = require('../log/logger');
+const morgan = require('morgan');
+const { errorMiddleware } = require('./middleware/errorMiddleware');
+const healthRoutes = require('../../interfaces/routes/healthRoute');
+const setupGracefulShutdown = require('../../utils/gracefulShutdown');
+<%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+const apiRoutes = require('../../interfaces/routes/api');
+const swaggerUi = require('swagger-ui-express');
+const swaggerSpecs = require('./swagger');
+<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+const { ApolloServer } = require('@apollo/server');
+const { expressMiddleware } = require('@as-integrations/express4');
+const { ApolloServerPluginLandingPageLocalDefault } = require('@apollo/server/plugin/landingPage/default');
+const { unwrapResolverError } = require('@apollo/server/errors');
+const { ApiError } = require('../../errors/ApiError');
+const { typeDefs, resolvers } = require('../../interfaces/graphql');
+const { gqlContext } = require('../../interfaces/graphql/context');
+<%_ } -%>
+
+const { env } = require('../config/env');
+
+const startServer = async () => {
+    // Determine port using the validated env
+    const port = env.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' || communication === 'Kafka') { -%>
+    app.use('/api', apiRoutes);
+    <%_ } -%>
+    <%_ if (communication === 'REST APIs' || communication === 'Kafka') { -%>
+    app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpecs));
+    <%_ } -%>
+    <%_ if (communication === 'GraphQL') { -%>
+    // GraphQL Setup
+    const apolloServer = new ApolloServer({
+        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 && 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('/health', healthRoutes);
+
+    app.use(errorMiddleware);
+
+    const server = app.listen(port, () => {
+        logger.info(`Server running on port ${port}`);
+<%_ if (communication === 'Kafka') { -%>
+        const { connectKafka } = require('../../infrastructure/messaging/kafkaClient');
+        connectKafka()
+            .then(async () => {
+                logger.info('Kafka connected');
+            })
+            .catch(err => {
+                logger.error('Failed to connect to Kafka after retries:', err.message);
+            });
+<%_ } -%>
+    });
+
+    setupGracefulShutdown(server);
+};
+
+module.exports = startServer;

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

@@ -1,6 +1,6 @@
-const path = require('path');
-const YAML = require('yamljs');
-
-const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
-
-module.exports = swaggerDocument;
+const path = require('path');
+const YAML = require('yamljs');
+
+const swaggerDocument = YAML.load(path.join(__dirname, 'swagger.yml'));
+
+module.exports = swaggerDocument;

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

@@ -1,75 +1,156 @@
-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');
-<%_ if (communication === 'Kafka') { -%>
-const { sendMessage } = require('../../infrastructure/messaging/kafkaClient');
-<%_ } -%>
-
-class UserController {
-    constructor() {
-        this.userRepository = new UserRepository();
-        this.createUserUseCase = new CreateUser(this.userRepository);
-        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 {
-            const user = await this.createUserUseCase.execute(name, email);
-<%_ if (communication === 'Kafka') { -%>
-            await sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                payload: { id: user.id || user._id, email: user.email }
-            }));
-<%_ } -%>
-            return user;
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            throw error;
-        }
-    }
-<% } else { -%>
-    async getUsers(req, res, next) {
-      try {
-        const users = await this.getAllUsersUseCase.execute();
-        res.json(users);
-      } catch (error) {
-        logger.error('Error getting users:', error);
-        next(error);
-      }
-    }
-
-    async createUser(req, res, next) {
-        const { name, email } = req.body;
-        try {
-            const user = await this.createUserUseCase.execute(name, email);
-<%_ if (communication === 'Kafka') { -%>
-            await sendMessage('user-topic', JSON.stringify({
-                action: 'USER_CREATED',
-                payload: { id: user.id || user._id, email: user.email }
-            }));
-<%_ } -%>
-            res.status(HTTP_STATUS.CREATED).json(user);
-        } catch (error) {
-            logger.error('Error creating user:', error);
-            next(error);
-        }
-    }
-<% } -%>
-}
-
-module.exports = UserController;
+const CreateUser = require('../../usecases/CreateUser');
+const GetAllUsers = require('../../usecases/GetAllUsers');
+const UpdateUser = require('../../usecases/UpdateUser');
+const DeleteUser = require('../../usecases/DeleteUser');
+const UserRepository = require('../../infrastructure/repositories/UserRepository');
+const ERROR_MESSAGES = require('../../utils/errorMessages');
+<% if (communication !== 'GraphQL') { -%>
+const HTTP_STATUS = require('../../utils/httpCodes');
+<% } -%>
+const logger = require('../../infrastructure/log/logger');
+<%_ if (communication === 'Kafka') { -%>
+const { sendMessage } = require('../../infrastructure/messaging/kafkaClient');
+const { KAFKA_ACTIONS } = require('../../utils/kafkaEvents');
+<%_ } -%>
+
+class UserController {
+    constructor() {
+        this.userRepository = new UserRepository();
+        this.createUserUseCase = new CreateUser(this.userRepository);
+        this.getAllUsersUseCase = new GetAllUsers(this.userRepository);
+        this.updateUserUseCase = new UpdateUser(this.userRepository);
+        this.deleteUserUseCase = new DeleteUser(this.userRepository);
+    }
+
+<% if (communication === 'GraphQL') { -%>
+    async getUsers() {
+        try {
+            return await this.getAllUsersUseCase.execute();
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async createUser(data) {
+        const { name, email } = data;
+        try {
+            const user = await this.createUserUseCase.execute(name, email);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async updateUser(id, data) {
+        try {
+            const user = await this.updateUserUseCase.execute(id, data);
+            if (!user) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            return user;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+
+    async deleteUser(id) {
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) throw new Error(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            return true;
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            throw error;
+        }
+    }
+<% } else { -%>
+    async getUsers(req, res, next) {
+      try {
+        const users = await this.getAllUsersUseCase.execute();
+        res.json(users);
+      } catch (error) {
+        logger.error(`${ERROR_MESSAGES.FETCH_USERS_ERROR}:`, error);
+        next(error);
+      }
+    }
+
+    async createUser(req, res, next) {
+        const { name, email } = req.body || {};
+        try {
+            const user = await this.createUserUseCase.execute(name, email);
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_CREATED,
+                payload: { id: user.id || user._id, email: user.email }
+            }), (user.id || user._id).toString());
+<%_ } -%>
+            res.status(HTTP_STATUS.CREATED).json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.CREATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async updateUser(req, res, next) {
+        const { id } = req.params;
+        const { name, email } = req.body || {};
+        try {
+            const user = await this.updateUserUseCase.execute(id, { name, email });
+            if (!user) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_UPDATED,
+                payload: { id, email: user.email }
+            }), id);
+<%_ } -%>
+            res.json(user);
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.UPDATE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+
+    async deleteUser(req, res, next) {
+        const { id } = req.params;
+        try {
+            const deleted = await this.deleteUserUseCase.execute(id);
+            if (!deleted) {
+                return res.status(HTTP_STATUS.NOT_FOUND).json({ error: ERROR_MESSAGES.USER_NOT_FOUND });
+            }
+<%_ if (communication === 'Kafka') { -%>
+            await sendMessage('user-topic', JSON.stringify({
+                action: KAFKA_ACTIONS.USER_DELETED,
+                payload: { id }
+            }), id);
+<%_ } -%>
+            res.status(HTTP_STATUS.OK).json({ message: 'User deleted successfully' });
+        } catch (error) {
+            logger.error(`${ERROR_MESSAGES.DELETE_USER_ERROR}:`, error);
+            next(error);
+        }
+    }
+<% } -%>
+}
+
+module.exports = UserController;