@feardread/fear 2.0.6 → 2.0.7

package/FEAR.js

@@ -15,6 +15,15 @@ module.exports = FEAR = (() => {
   const DEFAULT_JSON_LIMIT = '10mb';
   const DEFAULT_ROUTE_PATH = '/fear/api';
   const AGENT_ROUTE_PATH = '/fear/api/agent';
+  const FEAR_LOGO=`
+_________________________
+|  ___| ____|  / \  |  _ \ 
+| |_  |  _|   / _ \ | |_) |
+|  _| | |___ / ___ \|  _ < 
+|_|   |_____/_/   \_\_| \_\
+----The Quieter we become----
+-- the more we are able to hear.--
+`
 
   // Constructor function
   const FEAR = function (config) {
@@ -47,7 +56,6 @@ module.exports = FEAR = (() => {
     this.setupRoutes();
   };
 
-
   FEAR.prototype = {
     constructor: FEAR,
     getStripe() {
@@ -114,7 +122,7 @@ module.exports = FEAR = (() => {
       this.db = require("./libs/db");
       this.handler = require("./libs/handler");
       this.validator = require("./libs/validator");
-      this.logo = this.env.FEAR_LOGO;
+      this.logo = FEAR_LOGO;
       this.origins = this.getAllowedOrigins();
     },
 

package/FEARServer.js

@@ -278,10 +278,6 @@ const FearServer = (function () {
       return https.createServer(httpsOptions, this.fear.getApp());
     },
 
-    /**
-     * Create HTTP to HTTPS redirect server
-     * @private
-     */
     _createHttpRedirectServer(httpsPort) {
       const redirectApp = express();
       
@@ -438,7 +434,7 @@ const FearServer = (function () {
       };
 
       this.fear.getApp().use((req, res, next) => {
-        res.header('Access-Control-Allow-Origin', defaultOptions.origin);
+        res.header('Access-Control-Allow-Origin', '*');
         res.header('Access-Control-Allow-Methods', defaultOptions.methods.join(', '));
         res.header('Access-Control-Allow-Headers', defaultOptions.allowedHeaders.join(', '));
         

package/controllers/crud/crud.js

@@ -34,7 +34,7 @@ const sanitizeUpdateData = (data) => {
  */
 const processImages = (images) => {
   if (!images) return Promise.resolve(null);
-  
+  console.log('processing images = ', images);
   const imageArray = Array.isArray(images) 
     ? images 
     : images.split(',').map(item => item.trim());
@@ -132,34 +132,34 @@ exports.read = tryCatch((Model, req, res) => {
  */
 exports.create = tryCatch((Model, req, res) => {
   const documentData = { ...req.body };
+  const featured = documentData.featuredImage;
+  if (featured && documentData.images) documentData.images.push(featured);
+  let imagePromise;
+  
+  if (documentData.images && documentData.images.length !== 0) {
+    imagePromise = processImages(documentData.images);
+  } else {
+    imagePromise = Promise.resolve(null);
+  }
 
-  return processImages(documentData.images)
-    .then(imageLinks => {
+  return imagePromise
+  .then((imageLinks) => {
       if (imageLinks) {
         documentData.images = imageLinks;
       }
-      
-      console.log('Creating document:', documentData);
-      const document = new Model(documentData);
-      
+    
+      const document = new Model(documentData);      
       return document.save();
-    })
-    .then(result => {
-      return res.status(201).json({
-        result,
-        success: true,
-        message: `Document created successfully in ${Model.modelName} collection`
+  })
+  .then((result) => {
+      return res.status(201)
+        .json({ result, success: true, message: `Document created successfully in ${Model.modelName} collection`
       });
-    })
-    .catch(error => {
+  })
+  .catch((error) => {
       console.error('Error creating document:', error);
-      return res.status(500).json({
-        result: null,
-        success: false,
-        message: "Error creating document",
-        error: error.message
-      });
-    });
+      return res.status(500).json({ result: null,  success: false,  message: "Error creating document",  error: error.message });
+  })
 });
 
 /**

package/libs/cloud/index.js

@@ -26,21 +26,21 @@ const convertToBase64 = (file) => {
  * @param {string} file - Base64 encoded file or file path
  * @returns {Promise<Object>} Avatar object with public_id and url
  */
-const uploadAvatar = async (file) => {
-  try {
-    const result = await cloudinary.uploader.upload(file, {
-      folder: "avatar",
-      width: 150,
-      crop: "scale",
+const uploadAvatar = (file) => {
+  return cloudinary.uploader.upload(file, {
+    folder: "avatar",
+    width: 150,
+    crop: "scale",
+  })
+    .then((result) => {
+      return {
+        public_id: result.public_id,
+        url: result.secure_url,
+      };
+    })
+    .catch((error) => {
+      throw new Error(`Avatar upload failed: ${error.message}`);
     });
-
-    return {
-      public_id: result.public_id,
-      url: result.secure_url,
-    };
-  } catch (error) {
-    throw new Error(`Avatar upload failed: ${error.message}`);
-  }
 };
 
 /**
@@ -49,41 +49,49 @@ const uploadAvatar = async (file) => {
  * @param {number} chunkSize - Number of files to upload concurrently
  * @returns {Promise<Object[]>} Array of image objects with public_id and url
  */
-const uploadImages = async (files, chunkSize = 3) => {
-  try {
-    // Normalize input to array
-    const imageArray = Array.isArray(files) ? [...files] : [files];
-    
-    if (imageArray.length === 0) {
-      return [];
-    }
+const uploadImages = (files, chunkSize = 3) => {
+  // Normalize input to array
+  const imageArray = Array.isArray(files) ? [...files] : [files];
+  
+  if (imageArray.length === 0) {
+    return Promise.resolve([]);
+  }
 
-    const imageLinks = [];
+  const imageLinks = [];
+  
+  // Create a promise chain for sequential chunk processing
+  let promiseChain = Promise.resolve();
+  
+  // Process images in chunks to avoid overwhelming the API
+  for (let i = 0; i < imageArray.length; i += chunkSize) {
+    const chunk = imageArray.slice(i, i + chunkSize);
     
-    // Process images in chunks to avoid overwhelming the API
-    for (let i = 0; i < imageArray.length; i += chunkSize) {
-      const chunk = imageArray.slice(i, i + chunkSize);
-      
+    promiseChain = promiseChain.then(() => {
       const uploadPromises = chunk.map((image) =>
         cloudinary.uploader.upload(image, {
           folder: "products",
         })
       );
 
-      const results = await Promise.all(uploadPromises);
-      
-      const chunkResults = results.map((result) => ({
-        product_id: result.public_id,
-        url: result.secure_url,
-      }));
-      
-      imageLinks.push(...chunkResults);
-    }
-
-    return imageLinks;
-  } catch (error) {
-    throw new Error(`Image upload failed: ${error}`);
+      return Promise.all(uploadPromises)
+        .then((results) => {
+          const chunkResults = results.map((result) => ({
+            public_id: result.public_id,
+            url: result.secure_url,
+          }));
+          
+          imageLinks.push(...chunkResults);
+        });
+    });
   }
+  
+  return promiseChain
+    .then(() => {
+      return imageLinks;
+    })
+    .catch((error) => {
+      throw new Error('Image upload failed: ', error);
+    });
 };
 
 /**
@@ -130,56 +138,55 @@ const uploadPhoto = multer({
  * @param {Object} res - Express response object
  * @param {Function} next - Express next function
  */
-const resizeImages = async (req, res, next) => {
-  try {
-    // Skip if no files uploaded or no directory specified
-    if (!req.files || !req.directory) {
-      return next();
-    }
-
-    // Ensure directory exists
-    const targetDir = path.join("public/images", req.directory);
-    if (!fs.existsSync(targetDir)) {
-      fs.mkdirSync(targetDir, { recursive: true });
-    }
-
-    // Process all files concurrently
-    await Promise.all(
-      req.files.map(async (file) => {
-        const originalPath = file.path;
-        const targetPath = path.join(targetDir, file.filename);
-
-        try {
-          // Resize and convert image
-          await sharp(originalPath)
-            .resize(300, 300, { 
-              fit: 'cover',
-              position: 'center'
-            })
-            .jpeg({ quality: 90 })
-            .toFile(targetPath);
-
-          // Clean up original file
-          if (fs.existsSync(originalPath)) {
-            fs.unlinkSync(originalPath);
-          }
-        } catch (imageError) {
-          console.error(`Failed to process image ${file.filename}:`, imageError);
-          // Clean up files on error
-          [originalPath, targetPath].forEach(filePath => {
-            if (fs.existsSync(filePath)) {
-              fs.unlinkSync(filePath);
-            }
-          });
-          throw imageError;
+const resizeImages = (req, res, next) => {
+  // Skip if no files uploaded or no directory specified
+  if (!req.files || !req.directory) {
+    return next();
+  }
+
+  // Ensure directory exists
+  const targetDir = path.join("public/images", req.directory);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Process all files concurrently
+  const processPromises = req.files.map((file) => {
+    const originalPath = file.path;
+    const targetPath = path.join(targetDir, file.filename);
+
+    return sharp(originalPath)
+      .resize(300, 300, { 
+        fit: 'cover',
+        position: 'center'
+      })
+      .jpeg({ quality: 90 })
+      .toFile(targetPath)
+      .then(() => {
+        // Clean up original file
+        if (fs.existsSync(originalPath)) {
+          fs.unlinkSync(originalPath);
         }
       })
-    );
+      .catch((imageError) => {
+        console.error(`Failed to process image ${file.filename}:`, imageError);
+        // Clean up files on error
+        [originalPath, targetPath].forEach(filePath => {
+          if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+          }
+        });
+        throw imageError;
+      });
+  });
 
-    next();
-  } catch (error) {
-    next(new Error(`Image resize failed: ${error.message}`));
-  }
+  Promise.all(processPromises)
+    .then(() => {
+      next();
+    })
+    .catch((error) => {
+      next(new Error(`Image resize failed: ${error.message}`));
+    });
 };
 
 /**
@@ -187,13 +194,14 @@ const resizeImages = async (req, res, next) => {
  * @param {string} publicId - Public ID of the image to delete
  * @returns {Promise<Object>} Deletion result
  */
-const deleteImage = async (publicId) => {
-  try {
-    const result = await cloudinary.uploader.destroy(publicId);
-    return result;
-  } catch (error) {
-    throw new Error(`Image deletion failed: ${error.message}`);
-  }
+const deleteImage = (publicId) => {
+  return cloudinary.uploader.destroy(publicId)
+    .then((result) => {
+      return result;
+    })
+    .catch((error) => {
+      throw new Error(`Image deletion failed: ${error.message}`);
+    });
 };
 
 /**

package/libs/greenlock/setup.js

@@ -67,7 +67,7 @@ try {
   
   greenlock.ready((manager) => {
     console.log('manager = ', manager);
-  manager.defaults({
+  manager.serveApp({
     agreeToTerms: true,
     subscriberEmail: email
   }).then(() => {

package/models/blog.js

@@ -3,13 +3,9 @@ const slugify = require("slugify");
 
 const blogSchema = new mongoose.Schema(
   {
-    // Basic Information
-    title: {
-      type: String,
+    title: {type: String, trim: true, index: true,
       required: [true, "Blog title is required"],
-      trim: true,
-      maxlength: [200, "Title cannot exceed 200 characters"],
-      index: true
+      maxlength: [300, "Title cannot exceed 200 characters"],
     },
 
     slug: {
@@ -22,13 +18,13 @@ const blogSchema = new mongoose.Schema(
     subtitle: {
       type: String,
       trim: true,
-      maxlength: [250, "Subtitle cannot exceed 250 characters"]
+      maxlength: [350, "Subtitle cannot exceed 250 characters"]
     },
 
     excerpt: {
       type: String,
       trim: true,
-      maxlength: [500, "Excerpt cannot exceed 500 characters"]
+      maxlength: [600, "Excerpt cannot exceed 500 characters"]
     },
 
     content: {
@@ -43,10 +39,6 @@ const blogSchema = new mongoose.Schema(
     images: [{
       public_id: { type: String },
       url: { type: String },
-      secure_url: { type: String },
-      alt: { type: String },
-      caption: { type: String },
-      order: { type: Number, default: 0 }
     }],
 
     video: {
@@ -285,11 +277,11 @@ const blogSchema = new mongoose.Schema(
     seo: {
       metaTitle: {
         type: String,
-        maxlength: [70, "Meta title cannot exceed 70 characters"]
+        maxlength: [170, "Meta title cannot exceed 170 characters"]
       },
       metaDescription: {
         type: String,
-        maxlength: [160, "Meta description cannot exceed 160 characters"]
+        maxlength: [260, "Meta description cannot exceed 260 characters"]
       },
       metaKeywords: [{ type: String }],
       focusKeyword: { type: String },

package/models/brand.js

@@ -43,7 +43,6 @@ brandSchema.index({ createdAt: -1 });
 // Text index for search
 brandSchema.index({
   name: "text",
-  title: "text",
   tags: "text"
 });
 
@@ -83,11 +82,6 @@ brandSchema.pre("save", async function(next) {
     this.active = this.isActive;
   }
 
-  // Set title to name if not provided
-  if (!this.title) {
-    this.title = this.name;
-  }
-  
   next();
 });
 

package/models/product.js

@@ -19,7 +19,12 @@ const productSchema = new mongoose.Schema({
         url: String
       },
     ],
-    tags: String,
+    tags: [{
+      type: String,
+      trim: true,
+      lowercase: true,
+      index: true
+    }],
     ratings: [{
         star: Number,
         comment: String,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feardread/fear",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "",
   "main": "index.js",
   "scripts": {