Merge pull request #5 from frckbrice/fix/blog

Fix/blog

Author: frckbrice

.husky/pre-push

@@ -1,4 +1,4 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-yarn lint && yarn format && yarn test
+yarn lint && yarn format 

application-business-rules/use-cases/blogs/blog-handlers.js

@@ -0,0 +1,62 @@
+// Blog use cases (Clean Architecture)
+module.exports = {
+  createBlogUseCase: ({ dbBlogHandler, makeBlogModel, logEvents, errorHandlers }) =>
+    async function createBlogUseCaseHandler(blogData) {
+      try {
+        const validatedBlog = await makeBlogModel({ blogData });
+        const newBlog = await dbBlogHandler.createBlog(validatedBlog);
+        return Object.freeze(newBlog);
+      } catch (error) {
+        logEvents && logEvents(error.message, 'blogUseCase.log');
+        throw error;
+      }
+    },
+
+  findAllBlogsUseCase: ({ dbBlogHandler, logEvents }) =>
+    async function findAllBlogsUseCaseHandler() {
+      try {
+        const blogs = await dbBlogHandler.findAllBlogs();
+        return blogs || [];
+      } catch (error) {
+        logEvents && logEvents(error.message, 'blogUseCase.log');
+        throw error;
+      }
+    },
+
+  findOneBlogUseCase: ({ dbBlogHandler, logEvents }) =>
+    async function findOneBlogUseCaseHandler({ blogId }) {
+      try {
+        const blog = await dbBlogHandler.findOneBlog({ blogId });
+        if (!blog) throw new Error('Blog not found');
+        return blog;
+      } catch (error) {
+        logEvents && logEvents(error.message, 'blogUseCase.log');
+        throw error;
+      }
+    },
+
+  updateBlogUseCase: ({ dbBlogHandler, makeBlogModel, logEvents, errorHandlers }) =>
+    async function updateBlogUseCaseHandler({ blogId, updateData }) {
+      try {
+        const existingBlog = await dbBlogHandler.findOneBlog({ blogId });
+        if (!existingBlog) throw new Error('Blog not found');
+        const validatedBlog = await makeBlogModel({ blogData: { ...existingBlog, ...updateData } });
+        const updatedBlog = await dbBlogHandler.updateBlog({ blogId, ...validatedBlog });
+        return Object.freeze(updatedBlog);
+      } catch (error) {
+        logEvents && logEvents(error.message, 'blogUseCase.log');
+        throw error;
+      }
+    },
+
+  deleteBlogUseCase: ({ dbBlogHandler, logEvents }) =>
+    async function deleteBlogUseCaseHandler({ blogId }) {
+      try {
+        const deleted = await dbBlogHandler.deleteBlog({ blogId });
+        return deleted;
+      } catch (error) {
+        logEvents && logEvents(error.message, 'blogUseCase.log');
+        throw error;
+      }
+    },
+};

application-business-rules/use-cases/blogs/index.js

@@ -0,0 +1,23 @@
+const blogUseCases = require('./blog-handlers');
+const { dbBlogHandler } = require('../../../interface-adapters/database-access');
+const { makeBlogModel } = require('../../../enterprise-business-rules/entities/blog-model');
+const { logEvents } = require('../../../interface-adapters/middlewares/loggers/logger');
+const errorHandlers = require('../../../interface-adapters/validators-errors/errors');
+
+module.exports = {
+  createBlogUseCaseHandler: blogUseCases.createBlogUseCase({
+    dbBlogHandler,
+    makeBlogModel,
+    logEvents,
+    errorHandlers,
+  }),
+  findAllBlogsUseCaseHandler: blogUseCases.findAllBlogsUseCase({ dbBlogHandler, logEvents }),
+  findOneBlogUseCaseHandler: blogUseCases.findOneBlogUseCase({ dbBlogHandler, logEvents }),
+  updateBlogUseCaseHandler: blogUseCases.updateBlogUseCase({
+    dbBlogHandler,
+    makeBlogModel,
+    logEvents,
+    errorHandlers,
+  }),
+  deleteBlogUseCaseHandler: blogUseCases.deleteBlogUseCase({ dbBlogHandler, logEvents }),
+};

docker-compose.yml

@@ -7,7 +7,7 @@ services:
       - '5001:5000' # Change 5001 to any free port
     environment:
       - PORT=5000
-      - MONGODB_URI=${MONGODB_URI}
+      - MONGODB_URI=mongodb://mongo:27017/cleanarchdb
       - JWT_SECRET=${JWT_SECRET}
     depends_on:
       - mongo

enterprise-business-rules/entities/blog-model.js

@@ -0,0 +1,19 @@
+const blogValidation = require('../validate-models/blog-validation');
+
+module.exports = {
+  makeBlogModel: ({ blogValidation, logEvents }) => {
+    return async function makeBlog({ blogData }) {
+      try {
+        const validatedBlog = await blogValidation.blogPostValidation({
+          blogPostData: blogData,
+          errorHandlers: blogValidation,
+        });
+        // Add normalization or additional logic if needed
+        return Object.freeze(validatedBlog);
+      } catch (error) {
+        logEvents && logEvents(`${error.message}`, 'blog-model.log');
+        throw error;
+      }
+    };
+  },
+};

index.js

@@ -5,19 +5,16 @@ const path = require('path');
 
 const { dbconnection } = require('./interface-adapters/database-access/db-connection.js');
 const errorHandler = require('./interface-adapters/middlewares/loggers/errorHandler.js');
-const userAndAuthRouter = require('./routes/auth-user.router.js');
 const { logger } = require('./interface-adapters/middlewares/loggers/logger.js');
-const productRouter = require('./routes/product.routes.js');
 const createIndexFn = require('./interface-adapters/database-access/db-indexes.js');
-const blogRouter = require('./routes/blog.router.js');
 
 const app = express();
 
 const PORT = process.env.PORT || 5000;
 var cookieParser = require('cookie-parser');
 const corsOptions = require('./interface-adapters/middlewares/config/corsOptions.Js');
 
-// databae connetion call function
+// database connection call function
 dbconnection().then((db) => {
   console.log('database connected: ', db.databaseName);
   createIndexFn();
@@ -29,9 +26,9 @@ app.use(express.json());
 app.use(cookieParser());
 app.use(express.urlencoded({ extended: false }));
 
-app.use('/users', userAndAuthRouter);
-app.use('/products', productRouter);
-app.use('/blogs', blogRouter);
+// Use the new single entry point for all routes
+const mainRouter = require('./routes');
+app.use('/', mainRouter);
 
 app.use('/', (_, res) => {
   res.sendFile(path.join(__dirname, 'public', 'views', 'index.html'));
@@ -62,4 +59,11 @@ app.use((req, res, next) => {
 
 app.use(errorHandler);
 
-app.listen(PORT, () => console.log(`Server started on port http://localhost:${PORT}`));
+// Only call app.listen() if not in test
+if (require.main === module) {
+  app.listen(PORT, () => {
+    console.log(`Server is running on port ${PORT}`);
+  });
+}
+
+module.exports = app;

interface-adapters/controllers/blogs/blog-controller.js

@@ -0,0 +1,141 @@
+// Blog controller factories (Clean Architecture)
+const defaultHeaders = {
+  'Content-Type': 'application/json',
+  'x-content-type-options': 'nosniff',
+};
+
+const createBlogController = ({ createBlogUseCaseHandler, errorHandlers, logEvents }) =>
+  async function createBlogControllerHandler(httpRequest) {
+    const { body } = httpRequest;
+    if (!body || Object.keys(body).length === 0) {
+      return {
+        headers: defaultHeaders,
+        statusCode: 400,
+        errorMessage: 'No blog data provided',
+      };
+    }
+    try {
+      const createdBlog = await createBlogUseCaseHandler(body);
+      return {
+        headers: defaultHeaders,
+        statusCode: 201,
+        data: { createdBlog },
+      };
+    } catch (e) {
+      logEvents && logEvents(e.message, 'blogController.log');
+      return {
+        headers: defaultHeaders,
+        statusCode: 500,
+        errorMessage: e.message,
+      };
+    }
+  };
+
+const findAllBlogsController = ({ findAllBlogsUseCaseHandler, logEvents }) =>
+  async function findAllBlogsControllerHandler(httpRequest) {
+    try {
+      const blogs = await findAllBlogsUseCaseHandler();
+      return {
+        headers: defaultHeaders,
+        statusCode: 200,
+        data: { blogs },
+      };
+    } catch (e) {
+      logEvents && logEvents(e.message, 'blogController.log');
+      return {
+        headers: defaultHeaders,
+        statusCode: 500,
+        errorMessage: e.message,
+      };
+    }
+  };
+
+const findOneBlogController = ({ findOneBlogUseCaseHandler, logEvents }) =>
+  async function findOneBlogControllerHandler(httpRequest) {
+    const { blogId } = httpRequest.params;
+    if (!blogId) {
+      return {
+        headers: defaultHeaders,
+        statusCode: 400,
+        errorMessage: 'No blog Id provided',
+      };
+    }
+    try {
+      const blog = await findOneBlogUseCaseHandler({ blogId });
+      return {
+        headers: defaultHeaders,
+        statusCode: 200,
+        data: { blog },
+      };
+    } catch (e) {
+      logEvents && logEvents(e.message, 'blogController.log');
+      return {
+        headers: defaultHeaders,
+        statusCode: 500,
+        errorMessage: e.message,
+      };
+    }
+  };
+
+const updateBlogController = ({ updateBlogUseCaseHandler, logEvents }) =>
+  async function updateBlogControllerHandler(httpRequest) {
+    const { blogId } = httpRequest.params;
+    const updateData = httpRequest.body;
+    if (!blogId || !updateData) {
+      return {
+        headers: defaultHeaders,
+        statusCode: 400,
+        errorMessage: 'No blog Id or update data provided',
+      };
+    }
+    try {
+      const updatedBlog = await updateBlogUseCaseHandler({ blogId, updateData });
+      return {
+        headers: defaultHeaders,
+        statusCode: 200,
+        data: { updatedBlog },
+      };
+    } catch (e) {
+      logEvents && logEvents(e.message, 'blogController.log');
+      return {
+        headers: defaultHeaders,
+        statusCode: 500,
+        errorMessage: e.message,
+      };
+    }
+  };
+
+const deleteBlogController = ({ deleteBlogUseCaseHandler, logEvents }) =>
+  async function deleteBlogControllerHandler(httpRequest) {
+    const { blogId } = httpRequest.params;
+    if (!blogId) {
+      return {
+        headers: defaultHeaders,
+        statusCode: 400,
+        errorMessage: 'No blog Id provided',
+      };
+    }
+    try {
+      const deleted = await deleteBlogUseCaseHandler({ blogId });
+      return {
+        headers: defaultHeaders,
+        statusCode: 200,
+        data: deleted,
+      };
+    } catch (e) {
+      logEvents && logEvents(e.message, 'blogController.log');
+      return {
+        headers: defaultHeaders,
+        statusCode: 500,
+        errorMessage: e.message,
+      };
+    }
+  };
+
+module.exports = {
+  createBlogController,
+  findAllBlogsController,
+  findOneBlogController,
+  updateBlogController,
+  deleteBlogController,
+};

interface-adapters/controllers/blogs/index.js

@@ -0,0 +1,28 @@
+const blogController = require('./blog-controller');
+const blogUseCaseHandlers = require('../../../application-business-rules/use-cases/blogs');
+const { logEvents } = require('../../middlewares/loggers/logger');
+const errorHandlers = require('../../validators-errors/errors');
+
+module.exports = {
+  createBlogControllerHandler: blogController.createBlogController({
+    createBlogUseCaseHandler: blogUseCaseHandlers.createBlogUseCaseHandler,
+    errorHandlers,
+    logEvents,
+  }),
+  findAllBlogsControllerHandler: blogController.findAllBlogsController({
+    findAllBlogsUseCaseHandler: blogUseCaseHandlers.findAllBlogsUseCaseHandler,
+    logEvents,
+  }),
+  findOneBlogControllerHandler: blogController.findOneBlogController({
+    findOneBlogUseCaseHandler: blogUseCaseHandlers.findOneBlogUseCaseHandler,
+    logEvents,
+  }),
+  updateBlogControllerHandler: blogController.updateBlogController({
+    updateBlogUseCaseHandler: blogUseCaseHandlers.updateBlogUseCaseHandler,
+    logEvents,
+  }),
+  deleteBlogControllerHandler: blogController.deleteBlogController({
+    deleteBlogUseCaseHandler: blogUseCaseHandlers.deleteBlogUseCaseHandler,
+    logEvents,
+  }),
+};