WIP for blog post

Author: frckbrice

application-business-rules/use-cases/products/product-handlers.js

@@ -32,10 +32,10 @@ const createProductUseCase = ({ makeProductModelHandler }) => async function
 const findOneProductUseCase = ({ productValidation }) => async function
     findOneProductUseCaseHandler({ productId, logEvents, findOneProductDbHandler, errorHandlers }) {
     const { InvalidPropertyError } = errorHandlers;
-    const { validateUUID } = productValidation;
+    const { } = productValidation;
     try {
         // validate id
-        const uuid = validateUUID(productId, InvalidPropertyError);
+        const uuid = validateObjectId(productId, InvalidPropertyError);
         // store product in database mongodb
         const newProduct = await findOneProductDbHandler({ productId: uuid });
         return Object.freeze(newProduct)
@@ -73,10 +73,10 @@ const deleteProductUseCase = () => async function deleteProductUseCaseHandler({
 
     const { findOneProductDbHandler, deleteProductDbHandler } = dbProductHandler;
     const { InvalidPropertyError } = errorHandlers;
-    const { validateUUID } = productValidation;
+    const { validateObjectId } = productValidation;
     try {
         // validate id
-        const uuid = validateUUID(productId, InvalidPropertyError);
+        const uuid = validateObjectId(productId, InvalidPropertyError);
         // check first that the product exists
         const existingProduct = await findOneProductDbHandler({ productId: uuid });
         if (!existingProduct) {
@@ -105,10 +105,10 @@ const updateProductUseCase = ({ makeProductModelHandler }) => async function
 
     const { findOneProductDbHandler, updateProductDbHandler } = dbProductHandler;
     const { InvalidPropertyError } = errorHandlers;
-    const { validateUUID } = productValidation;
+    const { } = productValidation;
     try {
         // validate id
-        const uuid = validateUUID(productId, InvalidPropertyError);
+        const uuid = validateObjectId(productId, InvalidPropertyError);
         // check first that the product exists
         const existingProduct = await findOneProductDbHandler({ productId: uuid });
         if (!existingProduct) {

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

@@ -2,17 +2,19 @@
 // user and product validation
 const userValidationData = require("../validate-models/user-validation-functions");
 const productValidation = require("../validate-models/product-validation-fcts")();
+const { validateRatingModel } = require("../validate-models/rating-validation")();
 
 //log errors
 const { logEvents } = require("../../interface-adapters/middlewares/loggers/logger");
 
 // user and product models
 const { makeUserModel } = require("./user-model");
 const productModels = require("./product-model");
+const { makeRatingProductModel } = require("./rating-model");
 
 const makeUser = makeUserModel({ userValidationData, logEvents });
 const makeProductModelHandler = productModels.makeProductModel({ productValidation });
-const makeProductRatingModelHandler = productModels.makeRatingProductModel({ productValidation });
+const makeProductRatingModelHandler = makeRatingProductModel({ validateRatingModel });
 
 
 module.exports = {

enterprise-business-rules/entities/index.js

@@ -4,7 +4,6 @@ module.exports = {
     makeProductModel: ({ productValidation }) => async function makeProductModelHandler({ productData, errorHandlers }) {
 
         console.log(" hit makeProduct model: ");
-
         const { basicProductValidation } = productValidation;
 
         try {
@@ -16,20 +15,4 @@ module.exports = {
             throw new Error(error.message);
         }
     },
-
-    //make rating model
-    makeRatingProductModel: ({ productValidation }) => async function makeProductRatingModelHandler({ errorHandlers, ...ratingData }) {
-
-        console.log(" hit make Rating Product model: ");
-        const { validateRatingModel } = productValidation;
-        const { InvalidPropertyError } = errorHandlers;
-
-        try {
-            const validatedRatingData = await validateRatingModel(ratingData, InvalidPropertyError);
-            return Object.freeze(validatedRatingData)
-        } catch (error) {
-            console.log("Error from rating-model handler: ", error);
-            throw new Error(error.message);
-        }
-    }
 }

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

@@ -0,0 +1,17 @@
+module.exports = {
+
+    //make rating model
+    makeRatingProductModel: ({ validateRatingModel }) => async function makeProductRatingModelHandler({ errorHandlers, ...ratingData }) {
+
+        console.log(" hit make Rating Product model: ");
+        const { InvalidPropertyError } = errorHandlers;
+
+        try {
+            const validatedRatingData = await validateRatingModel(ratingData, InvalidPropertyError);
+            return Object.freeze(validatedRatingData)
+        } catch (error) {
+            console.log("Error from rating-model handler: ", error);
+            throw new Error(error.message);
+        }
+    }
+}

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

@@ -0,0 +1,92 @@
+const productValidation = require("./product-validation-fcts")();
+
+const { validateDescription, validateTitle, validateObjectId } = productValidation;
+
+//validate cover image for only more optimized types
+const validateCoverImage = ({ cover_image, InvalidPropertyError }) => {
+
+    const ext = cover_image.split('.').pop();
+    if (ext !== 'png' && ext !== 'jpeg' && ext !== 'jpg') {
+        throw new InvalidPropertyError(
+            `Invalid cover image.`
+        )
+    }
+    return cover_image;
+}
+
+//validate tags as an array of strings
+const validateTags = (tags, InvalidPropertyError) => {
+    if (!tags || !tags.length) {
+        throw new InvalidPropertyError(
+            `Tags are required.`
+        )
+    }
+    return tags ?? [];
+}
+
+
+//validate image_urls as an array of strings
+const validateImageUrls = ({ image_urls, InvalidPropertyError }) => {
+    return image_urls.map(image => validateCoverImage({ coverImage: image, InvalidPropertyError }));
+}
+
+
+// create blog post model validation
+const blogPostValidation = ({ blogPostData, errorHandlers }) => {
+
+    // blog post props
+    const {
+        title,
+        content,
+        author,
+        tags,
+        image_urls,
+        cover_image,
+    } = blogPostData;
+
+    const { RequiredParameterError, InvalidPropertyError } = errorHandlers;
+    const resultingBlogPostData = {};
+    const errors = [];
+    if (!title) {
+        errors.push(`Blog post title is required`);
+    } else resultingBlogPostData.title = validateTitle({ title, InvalidPropertyError });
+    if (!content) {
+        errors.push(`Blog post description is required`);
+    } else resultingBlogPostData.content = validateDescription({ description: content, InvalidPropertyError });
+
+    if (!cover_image)
+        errors.push(`Blog post cover image is required`);
+    else resultingBlogPostData.cover_image = validateCoverImage({ cover_image, InvalidPropertyError });
+    if (!author) {
+        errors.push(`Blog post author is required`);
+    } else resultingBlogPostData.author = validateTitle({ title: author, InvalidPropertyError });
+    if (!tags) {
+        errors.push(`Blog post tags are required`);
+    } else resultingBlogPostData.tags = validateTags(tags, InvalidPropertyError);
+    if (!image_urls) {
+        errors.push(`Blog post image_urls are required`);
+    } else resultingBlogPostData.image_urls = validateImageUrls({ image_urls, InvalidPropertyError });
+
+    if (errors.length) {
+        throw new RequiredParameterError(errors.join("\n"));
+    }
+
+    resultingBlogPostData.isLiked = false;
+    resultingBlogPostData.isDisliked = false;
+    resultingBlogPostData.likes = [];
+    resultingBlogPostData.comments = [];
+    resultingBlogPostData.numViews = 0;
+    resultingBlogPostData.created_at = new Date().toISOString();
+    resultingBlogPostData.lastModifiedDate = null;
+
+    console.log("successfully validated blog post: ");
+    return resultingBlogPostData;
+}
+module.exports = Object.freeze({
+    blogPostValidation,
+    validateCoverImage,
+    validateTags,
+    validateImageUrls,
+    validateTitle,
+    validateDescription,
+})

enterprise-business-rules/validate-models/blog-validation.js

@@ -9,13 +9,13 @@ function validateTitle({ title, InvalidPropertyError }) {
 //validate title length
 
 //validate and normalise product description
-function validateDescription({ descripton, InvalidPropertyError }) {
-    if (descripton.length < 50) {
+function validateDescription({ description, InvalidPropertyError }) {
+    if (description.length < 50) {
         throw new InvalidPropertyError(
             `A product's title must be at least 20 characters long.`
         )
     }
-    return descripton.charAt(0).toUpperCase() + descripton.slice(1);
+    return description.charAt(0).toUpperCase() + description.slice(1);
 }
 
 /**
@@ -153,46 +153,21 @@ const CalculateTotalReviews = (totalRatings) => {
 }
 
 //calculate average rating
-const calculateAverageRating = (totalRatings) => {
+const calculateAverageRating = (totalRatings, resultingProductData) => {
     if (!totalRatings || !totalRatings.length) return 0
     return totalRatings.reduce((acc, curr, idx) => acc + curr * (idx + 1), 0) / resultingProductData.totalReviews;
 }
 
-// validate uuid  as ObjectId
-const validateUUID = (id, InvalidPropertyError) => {
-    // const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    // console.log(id);
-    const regex = /^[a-fA-F0-9]{24}$/; // ObjectId validation regex
-    if (!regex.test(id)) {
-        throw new InvalidPropertyError(`Invalid product ObjectId.`)
+// validate uuid as ObjectId
+const validateObjectId = (id, InvalidPropertyError) => {
+    if (!/^[0-9a-fA-F]{24}$/.test(id)) {
+        throw new InvalidPropertyError("Invalid product id.");
     }
     return id;
-}
-
-// validate rating model 
-const validateRatingModel = (ratingModel, InvalidPropertyError) => {
-    const { productId, userId, ratingValue } = ratingModel;
-
-    // validate IDs
-    const productUUID = validateUUID(productId, InvalidPropertyError);
-    const userUUID = validateUUID(userId, InvalidPropertyError);
-
-    // validate rating value
-    const validRatingValues = [1, 2, 3, 4, 5];
-    if (!ratingValue || !validRatingValues.includes(ratingValue)) {
-        throw new InvalidPropertyError(
-            `Invalid rating value.`
-        )
-    }
 
-    return {
-        productId: productUUID,
-        userId: userUUID,
-        ratingValue,
-        date: new Date().toISOString(),
-    };
 }
 
+
 //basic product validation 
 const basicProductValidation = ({ productData, errorHandlers }) => {
 
@@ -207,7 +182,7 @@ const basicProductValidation = ({ productData, errorHandlers }) => {
 
     if (!productData.descripton) {
         errors.push(`Product descripton is required`);
-    } else resultingProductData.descripton = validateDescription({ descripton: productData.descripton, InvalidPropertyError });
+    } else resultingProductData.description = validateDescription({ description: productData.description, InvalidPropertyError });
 
     if (!productData.price) {
         errors.push(`Product price is required`);
@@ -283,13 +258,13 @@ const basicProductValidation = ({ productData, errorHandlers }) => {
     resultingProductData.latestRating = null;
     resultingProductData.rateAverage = 0;
     resultingProductData.lastModified = new Date().toISOString();
-    resultingProductData.instock = Boolean(resultingProductData.inventory && resultingProductData.inventory > 0)
+    resultingProductData.instock = Boolean(resultingProductData.inventory)
     resultingProductData.brands = productData.brands || [];
 
     if (errors.length) {
         throw new RequiredParameterError(errors.join(', '));
     }
-    console.log("end of validations: ");
+    console.log("successfully validated product: ");
     return resultingProductData;
 }
 
@@ -298,7 +273,11 @@ module.exports = () => {
         basicProductValidation,
         CalculateTotalReviews,
         calculateAverageRating,
-        validateUUID,
-        validateRatingModel
+        validateObjectId,
+        validateTitle,
+        validateNumber,
+        validateCategory,
+        validateColors,
+        validateDescription
     })
 }

enterprise-business-rules/validate-models/product-validation-fcts.js

@@ -0,0 +1,33 @@
+
+const { validateObjectId,
+} = require("./product-validation-fcts")();
+
+// validate rating model 
+const validateRatingModel = ({ productId, userId, ratingValue }, InvalidPropertyError) => {
+    // validate IDs
+    validateObjectId,
+        (productId, InvalidPropertyError);
+    validateObjectId,
+        (userId, InvalidPropertyError);
+
+    // validate rating value
+    if (!ratingValue || ![1, 2, 3, 4, 5].includes(ratingValue)) {
+        throw new InvalidPropertyError(
+            `Invalid rating value.`
+        )
+    }
+
+    return {
+        productId,
+        userId,
+        ratingValue,
+        date: new Date().toISOString(),
+    };
+}
+
+module.exports = () => {
+    return Object.freeze({
+        validateObjectId,
+        validateRatingModel
+    })
+}

enterprise-business-rules/validate-models/rating-validation.js

@@ -9,6 +9,7 @@ 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();
 
@@ -31,6 +32,7 @@ app.use(express.urlencoded({ extended: false }));
 
 app.use('/users', userAndAuthRouter);
 app.use('/products', productRouter);
+app.use('/blogs', blogRouter);
 
 app.use("/", (_, res) => {
     res.sendFile(path.join(__dirname, "public", "views", "index.html"));