@feardread/fear 1.0.6 → 1.0.8

package/FEAR.js

@@ -23,8 +23,6 @@ module.exports = FEAR = (() => {
     this.logger = null;
     this.morgan = null;
     this.cloud = null;
-    this.agentService = null;
-    this.agentWebInterface = null;
     this.db = null;
     this.handler = null;
     this.validator = null;
@@ -38,47 +36,12 @@ module.exports = FEAR = (() => {
     this.setupMiddleware();
     this.corsConfig = this.getCorsConfig();
     this.setupRoutes();
-    //this.setupAiAgent();
-    //this.setupAgentWebInterface();
   };
 
   // Consolidated prototype
   FEAR.prototype = {
     constructor: FEAR,
 
-    /**
-     * Initialize AI Agent service
-     */
-    setupAiAgent() {
-      const { getInstance } = require("./libs/agent");
-
-      if (!this.agentService) {
-        this.agentService = getInstance();
-      }
-    },
-
-    /**
-     * Initialize Agent Web Interface
-     */
-    setupAgentWebInterface() {
-      try {
-        const AgentWebInterface = require("./libs/agent");
-        
-        this.agentWebInterface = new AgentWebInterface(this);
-        
-        // Register agent routes
-        this.useRouter(
-          this.agentWebInterface.getRouter(), 
-          AGENT_ROUTE_PATH
-        );
-        
-        this.logger.info(`Agent Web Interface initialized at ${AGENT_ROUTE_PATH}`);
-      } catch (error) {
-        this.logger.error("Failed to initialize Agent Web Interface:", error);
-        this.logger.warn("Agent Web Interface will not be available");
-      }
-    },
-
     /**
      * Get AI Agent service instance
      */
@@ -86,13 +49,6 @@ module.exports = FEAR = (() => {
       return this.agentService;
     },
 
-    /**
-     * Get Agent Web Interface instance
-     */
-    getAgentWebInterface() {
-      return this.agentWebInterface;
-    },
-
     /**
      * Clear global FearRouter
      */
@@ -307,7 +263,7 @@ module.exports = FEAR = (() => {
 
       routers.forEach(config => {
         if (typeof config === 'function') {
-          this.useRouter(config);
+          this.useRouter(config, DEFAULT_ROUTE_PATH, this.corsConfig);
         } else if (config && config.router) {
           this.useRouter(config.router, config.path, config.cors);
         } else {

package/controllers/crud/crud.js

@@ -1,43 +1,52 @@
 const { tryCatch } = require("../../libs/handler/error");
 const cloud = require("../../libs/cloud");
 const SearchApi = require("../../libs/search/api");
+const mongoose = require("mongoose");
 
 /**
- * Generic CRUD operations for any Mongoose Model
- * All methods use then/catch pattern for consistency
+ * Validates MongoDB ObjectId format
+ * @param {string} id - ID to validate
+ * @returns {boolean} True if valid ObjectId
  */
+const isValidObjectId = (id) => {
+  return mongoose.Types.ObjectId.isValid(id) && /^[0-9a-fA-F]{24}$/.test(id);
+};
+
 /**
  * Get all documents for requested Model
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @returns {boolean} Success
- * @returns {string} Message
- * @returns {Array} Result: Array of found Documents
+ * @returns {Promise<void>}
  */
 exports.all = tryCatch(async (Model, req, res) => {
-  const { sort = 'category', order = 'asc', populate = true } = req.query;
-  let query = Model.find();
-  // Apply sorting
-  const sortOrder = order === 'desc' ? 'desc' : 'asc';
-  query = query.sort({ [sort]: sortOrder });
+  const { sort = 'category', order = 'asc', populate = 'true' } = req.query;
+  
+  const sortOrder = order === 'desc' ? -1 : 1;
+  let query = Model.find().sort({ [sort]: sortOrder });
+
   // Apply population if requested
-  if (populate && populate !== 'false') {
+  if (populate !== 'false') {
     query = query.populate();
   }
-  return query
-    .then((result) => {
-      if (!result || result.length === 0) {
-        return res.status(200).json({ result: [], success: true, message: "No documents found", count: 0 });
-      }
-      return res.status(200).json({
-        result, success: true, message: `Found ${result.length} documents`, count: result.length
-      });
-    })
-    .catch((error) => {
-      console.error('Error in all method:', error);
-      return res.status(500).json({ result: null, success: false, message: "Error retrieving documents", error: error.message });
+
+  const result = await query.exec();
+
+  if (!result || result.length === 0) {
+    return res.status(200).json({
+      result: [],
+      success: true,
+      message: "No documents found",
+      count: 0
     });
+  }
+
+  return res.status(200).json({
+    result,
+    success: true,
+    message: `Found ${result.length} documents`,
+    count: result.length
+  });
 });
 
 /**
@@ -45,65 +54,42 @@ exports.all = tryCatch(async (Model, req, res) => {
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {string} req.params.id - Document ID
- * @returns {Document} Single Document
+ * @returns {Promise<void>}
  */
 exports.read = tryCatch(async (Model, req, res) => {
-  console.log('crud read id = ', req.params);
-  /*
-  if (!req.params || !req.params.id) {
+  const { id } = req.params;
+
+  if (!id) {
     return res.status(400).json({
       result: null,
       success: false,
       message: "Document ID is required"
     });
   }
-*/
-  const { id } = req.query;
-  const { populate = true } = req.query;
 
-  /*
-  // Validate ObjectId format
-  if (!id.match(/^[0-9a-fA-F]{24}$/)) {
+  if (!isValidObjectId(id)) {
     return res.status(400).json({
       result: null,
       success: false,
       message: "Invalid document ID format"
     });
   }
-*/
-  let query = Model.findById(id);
 
-  // Apply population if requested
-  if (populate && populate !== 'false') {
-    query = query.populate();
-  }
+  const result = await Model.findById(id).exec();
 
-  return query
-    .then((result) => {
-      if (!result) {
-        return res.status(404).json({
-          result: null,
-          success: false,
-          message: `Document with ID ${id} not found`
-        });
-      }
-
-      return res.status(200).json({
-        result,
-        success: true,
-        message: "Document found successfully"
-      });
-    })
-    .catch((error) => {
-      console.error('Error in read method:', error);
-      return res.status(500).json({
-        result: null,
-        success: false,
-        message: "Error retrieving document",
-        error: error.message
-      });
+  if (!result) {
+    return res.status(404).json({
+      result: null,
+      success: false,
+      message: `Document with ID ${id} not found`
     });
+  }
+
+  return res.status(200).json({
+    result,
+    success: true,
+    message: "Document found successfully"
+  });
 });
 
 /**
@@ -111,63 +97,49 @@ exports.read = tryCatch(async (Model, req, res) => {
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {Object} req.body - Document data
- * @returns {string} Message
+ * @returns {Promise<void>}
  */
 exports.create = tryCatch(async (Model, req, res) => {
   const documentData = { ...req.body };
 
   // Handle image uploads if present
-  if (documentData.images)  {
-      documentData.images.split(',').map(item => item.trim());
-
-      const imageLinks = await cloud.uploadImages(documentData.images);
-      if ( imageLinks ) documentData.images = imageLinks;
+  if (documentData.images) {
+    // Parse comma-separated string to array if needed
+    const imageArray = typeof documentData.images === 'string'
+      ? documentData.images.split(',').map(item => item.trim())
+      : documentData.images;
+
+    let imageLinks = await cloud.uploadImages(imageArray);
+    
+    if (imageLinks) {
+      documentData.images = imageLinks;
       console.log('Added Images:', imageLinks);
+    }
   }
-  console.log('Creating modified document:', documentData);
-  await new Model(documentData).save()
-      .then((result) => {
-        if (!result) {
-          throw new Error("Failed to save document");
-        }
-        return res.status(201).json({
-          result, success: true, message: `Document created successfully in ${Model.modelName} collection`
-        });
-      })
-      .catch((error) => {
-        console.error('Error in create method with images:', error);
-
-        if (error.name === "ValidationError") {
-          return res.status(400).json({
-            result: null,
-            success: false,
-            message: "Validation failed: Required fields are missing or invalid",
-            errors: error.errors
-          });
-        }
-
-        return res.status(500).json({
-          result: null,
-          success: false,
-          message: "Internal server error during document creation",
-          error: error.message
-        });
-      });
 
+  console.log('Creating document:', documentData);
+
+  const document = new Model(documentData);
+  const result = await document.save();
+
+  return res.status(201).json({
+    result,
+    success: true,
+    message: `Document created successfully in ${Model.modelName} collection`
   });
+});
 
 /**
  * Updates a single document
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {Object} req.body - Updated document data
- * @param {string} req.params.id - Document ID
- * @returns {Document} Returns updated document
+ * @returns {Promise<void>}
  */
 exports.update = tryCatch(async (Model, req, res) => {
-  if (!req.params || !req.params.id) {
+  const { id } = req.params;
+
+  if (!id) {
     return res.status(400).json({
       result: null,
       success: false,
@@ -175,7 +147,14 @@ exports.update = tryCatch(async (Model, req, res) => {
     });
   }
 
-  const { id } = req.params;
+  if (!isValidObjectId(id)) {
+    return res.status(400).json({
+      result: null,
+      success: false,
+      message: "Invalid document ID format"
+    });
+  }
+
   const updateData = { ...req.body };
 
   // Remove undefined values
@@ -185,114 +164,32 @@ exports.update = tryCatch(async (Model, req, res) => {
     }
   });
 
-  // Validate ObjectId format
-  if (!id.match(/^[0-9a-fA-F]{24}$/)) {
-    return res.status(400).json({
-      result: null,
-      success: false,
-      message: "Invalid document ID format"
-    });
-  }
-
   // Handle image uploads if present
-  if (updateData.images && Array.isArray(updateData.images)) {
-    return cloud.uploadImages(updateData.images)
-      .then((uploadedImages) => {
-        updateData.images = uploadedImages;
-
-        // Update document with uploaded images
-        return Model.findOneAndUpdate(
-          { _id: id },
-          updateData,
-          { new: true, runValidators: true }
-        ).exec();
-      })
-      .then((result) => {
-        if (!result) {
-          return res.status(404).json({
-            result: null,
-            success: false,
-            message: `Document with ID ${id} not found`
-          });
-        }
-
-        return res.status(200).json({
-          result,
-          success: true,
-          message: `Document updated successfully with ID: ${id}`
-        });
-      })
-      .catch((error) => {
-        console.error('Error in update method with images:', error);
-
-        if (error.name === "ValidationError") {
-          return res.status(400).json({
-            result: null,
-            success: false,
-            message: "Validation failed: Invalid field values provided",
-            errors: error.errors
-          });
-        }
-
-        return res.status(500).json({
-          result: null,
-          success: false,
-          message: "Internal server error during document update",
-          error: error.message
-        });
-      });
+  if (updateData.images && Array.isArray(updateData.images) && updateData.images.length > 0) {
+    const uploadedImages = await cloud.uploadImages(updateData.images);
+    updateData.images = uploadedImages;
   }
 
-  // Update document without image uploads
-  return Model.findOneAndUpdate(
-    { _id: id },
+  // Update document
+  const result = await Model.findByIdAndUpdate(
+    id,
     updateData,
     { new: true, runValidators: true }
-  )
-    .exec()
-    .then((result) => {
-      if (!result) {
-        return res.status(404).json({
-          result: null,
-          success: false,
-          message: `Document with ID ${id} not found`
-        });
-      }
-
-      return res.status(200).json({
-        result,
-        success: true,
-        message: `Document updated successfully with ID: ${id}`
-      });
-    })
-    .catch((error) => {
-      console.error('Error in update method:', error);
-
-      if (error.name === "ValidationError") {
-        return res.status(400).json({
-          result: null,
-          success: false,
-          message: "Validation failed: Invalid field values provided",
-          errors: error.errors
-        });
-      }
-
-      if (error.code === 11000) {
-        return res.status(409).json({
-          result: null,
-          success: false,
-          message: "Update failed: Duplicate value for unique field",
-          error: error.message
-        });
-      }
-
-      return res.status(500).json({
-        result: null,
-        success: false,
-        message: "Internal server error during document update",
-        error: error.message
-      });
+  ).exec();
+
+  if (!result) {
+    return res.status(404).json({
+      result: null,
+      success: false,
+      message: `Document with ID ${id} not found`
     });
+  }
+
+  return res.status(200).json({
+    result,
+    success: true,
+    message: `Document updated successfully with ID: ${id}`
+  });
 });
 
 /**
@@ -300,11 +197,12 @@ exports.update = tryCatch(async (Model, req, res) => {
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {string} req.params.id - Document ID
- * @returns {string} Message response
+ * @returns {Promise<void>}
  */
 exports.delete = tryCatch(async (Model, req, res) => {
-  if (!req.params || !req.params.id) {
+  const { id } = req.params;
+
+  if (!id) {
     return res.status(400).json({
       result: null,
       success: false,
@@ -312,10 +210,7 @@ exports.delete = tryCatch(async (Model, req, res) => {
     });
   }
 
-  const { id } = req.params;
-
-  // Validate ObjectId format
-  if (!id.match(/^[0-9a-fA-F]{24}$/)) {
+  if (!isValidObjectId(id)) {
     return res.status(400).json({
       result: null,
       success: false,
@@ -323,38 +218,28 @@ exports.delete = tryCatch(async (Model, req, res) => {
     });
   }
 
-  return Model.findOneAndDelete({ _id: id })
-    .exec()
-    .then((result) => {
-      if (!result) {
-        return res.status(404).json({
-          result: null,
-          success: false,
-          message: `Document with ID ${id} not found`
-        });
-      }
-
-      // TODO: Clean up associated images if they exist
-      if (result.images && Array.isArray(result.images)) {
-        // Could add cloud.deleteImages(result.images) here
-        console.log('Document had images that should be cleaned up:', result.images);
-      }
-
-      return res.status(200).json({
-        result,
-        success: true,
-        message: `Document deleted successfully with ID: ${id}`
-      });
-    })
-    .catch((error) => {
-      console.error('Error in delete method:', error);
-      return res.status(500).json({
-        result: null,
-        success: false,
-        message: "Error deleting document",
-        error: error.message
-      });
+  const result = await Model.findByIdAndDelete(id).exec();
+
+  if (!result) {
+    return res.status(404).json({
+      result: null,
+      success: false,
+      message: `Document with ID ${id} not found`
     });
+  }
+
+  // TODO: Clean up associated images if they exist
+  if (result.images && Array.isArray(result.images) && result.images.length > 0) {
+    console.log('Document had images that should be cleaned up:', result.images);
+    // Uncomment when cloud.deleteImages is available:
+    // await cloud.deleteImages(result.images);
+  }
+
+  return res.status(200).json({
+    result,
+    success: true,
+    message: `Document deleted successfully with ID: ${id}`
+  });
 });
 
 /**
@@ -362,71 +247,45 @@ exports.delete = tryCatch(async (Model, req, res) => {
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {Object} req.query - Query parameters
- * @returns {Object} Results with pagination
+ * @returns {Promise<void>}
  */
 exports.list = tryCatch(async (Model, req, res) => {
-  const page = parseInt(req.query.page) || 1;
-  const limit = parseInt(req.query.items) || 10;
+  const page = Math.max(1, parseInt(req.query.page) || 1);
+  const limit = Math.min(100, Math.max(1, parseInt(req.query.items) || 10));
   const skip = (page - 1) * limit;
-  const { sort = 'createdAt', order = 'desc', populate = true } = req.query;
+  const { sort = 'createdAt', order = 'desc', populate = 'true' } = req.query;
 
-  // Limit maximum items per page
-  const maxLimit = Math.min(limit, 100);
   const sortOrder = order === 'asc' ? 1 : -1;
 
-  // Create count and results promises
-  const countPromise = Model.countDocuments();
-
-  let resultsQuery = Model.find()
-    .skip(skip)
-    .limit(maxLimit)
-    .sort({ [sort]: sortOrder });
-
-  // Apply population if requested
-  if (populate && populate !== 'false') {
-    resultsQuery = resultsQuery.populate();
-  }
+  // Execute count and find queries in parallel
+  const [result, count] = await Promise.all([
+    Model.find()
+      .skip(skip)
+      .limit(limit)
+      .sort({ [sort]: sortOrder })
+      .populate(populate !== 'false' ? undefined : null)
+      .exec(),
+    Model.countDocuments().exec()
+  ]);
+
+  const totalPages = Math.ceil(count / limit);
+  const pagination = {
+    currentPage: page,
+    totalPages,
+    totalItems: count,
+    itemsPerPage: limit,
+    hasNextPage: page < totalPages,
+    hasPrevPage: page > 1
+  };
 
-  const resultsPromise = resultsQuery.exec();
-
-  return Promise.all([resultsPromise, countPromise])
-    .then(([result, count]) => {
-      const totalPages = Math.ceil(count / maxLimit);
-      const pagination = {
-        currentPage: page,
-        totalPages,
-        totalItems: count,
-        itemsPerPage: maxLimit,
-        hasNextPage: page < totalPages,
-        hasPrevPage: page > 1
-      };
-
-      if (count > 0) {
-        return res.status(200).json({
-          result,
-          success: true,
-          pagination,
-          message: `Found ${result.length} of ${count} documents`
-        });
-      } else {
-        return res.status(200).json({
-          result: [],
-          success: true,
-          pagination,
-          message: "Collection is empty"
-        });
-      }
-    })
-    .catch((error) => {
-      console.error('Error in list method:', error);
-      return res.status(500).json({
-        result: null,
-        success: false,
-        message: "Error retrieving document list",
-        error: error.message
-      });
-    });
+  return res.status(200).json({
+    result,
+    success: true,
+    pagination,
+    message: count > 0 
+      ? `Found ${result.length} of ${count} documents` 
+      : "Collection is empty"
+  });
 });
 
 /**
@@ -434,68 +293,75 @@ exports.list = tryCatch(async (Model, req, res) => {
  * @param {mongoose.Model} Model - Mongoose model
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
- * @param {Object} req.query - Query parameters
- * @returns {Array} List of Documents
+ * @returns {Promise<void>}
  */
 exports.search = tryCatch(async (Model, req, res) => {
-  console.log('crud serach req:: ', req.query);
-      const {
-        keyword,
-        category,
-        brand,
-        minPrice,
-        maxPrice,
-        rating,
-        sortBy = 'popularity',
-        page = 1,
-        limit = 24
-    } = req.query;
-
-    // Build query object
-    const queryObj = { page, limit };
-    if (keyword) queryObj.keyword = keyword;
-    if (category) queryObj.category = category;
-    if (brand) queryObj.brand = { in: brand }; // Support multiple brands
-    if (minPrice || maxPrice) {
-        queryObj.price = {};
-        if (minPrice) queryObj.price.gte = minPrice;
-        if (maxPrice) queryObj.price.lte = maxPrice;
-    }
-    if (rating) queryObj.rating = { gte: rating };
-
-    const sortOptions = {
-        popularity: { popularity: -1 },
-        newest: { createdAt: -1 },
-        'price-low': { price: 1 },
-        'price-high': { price: -1 },
-        rating: { rating: -1 }
-    };
-
-    const Search = new SearchApi(Model, queryObj, {
-        searchFields: ['_id', 'id', 'price', 'name', 'description', 'tags'],
-        defaultSort: sortOptions[sortBy] || sortOptions.popularity
-    });
+  console.log('CRUD search query:', req.query);
+
+  const {
+    keyword,
+    category,
+    brand,
+    minPrice,
+    maxPrice,
+    rating,
+    sortBy = 'popularity',
+    page = 1,
+    limit = 24
+  } = req.query;
+
+  // Build query object
+  const queryObj = { 
+    page: parseInt(page), 
+    limit: parseInt(limit) 
+  };
 
-    return await Search
-        .search(['_id', 'id', 'price', 'name', 'description', 'brand', 'tags'])
-        .filter()
-        .sort()
-        .selectFields('-__v,-updatedAt')
-        .populate('reviews')
-        .paginate(limit, 50) // Max 50 items per page
-        .execute()
-        .then((result) => { return res.status(200).json({ success: true, ...result }); })
-        .catch((error) => { return res.status(500).json({ success: false, message: error.message }); })
-});
+  if (keyword) queryObj.keyword = keyword;
+  if (category) queryObj.category = category;
+  if (brand) queryObj.brand = { in: brand };
+  
+  if (minPrice || maxPrice) {
+    queryObj.price = {};
+    if (minPrice) queryObj.price.gte = parseFloat(minPrice);
+    if (maxPrice) queryObj.price.lte = parseFloat(maxPrice);
+  }
+  
+  if (rating) queryObj.rating = { gte: parseFloat(rating) };
+
+  const sortOptions = {
+    popularity: { popularity: -1 },
+    newest: { createdAt: -1 },
+    'price-low': { price: 1 },
+    'price-high': { price: -1 },
+    rating: { rating: -1 }
+  };
 
+  const searchApi = new SearchApi(Model, queryObj, {
+    searchFields: ['_id', 'id', 'price', 'name', 'description', 'tags'],
+    defaultSort: sortOptions[sortBy] || sortOptions.popularity
+  });
+
+  const result = await searchApi
+    .search(['_id', 'id', 'price', 'name', 'description', 'brand', 'tags'])
+    .filter()
+    .sort()
+    .selectFields('-__v,-updatedAt')
+    .populate('reviews')
+    .paginate(parseInt(limit), 50)
+    .execute();
+
+  return res.status(200).json({
+    success: true,
+    ...result
+  });
+});
 
 /**
  * Create a controller object with all CRUD methods bound to a specific Model
  * @param {mongoose.Model} Model - Mongoose model
  * @returns {Object} Controller object with all CRUD methods
  */
-module.exports = ( Model ) => {
-
+module.exports = (Model) => {
   return {
     all: (req, res) => exports.all(Model, req, res),
     read: (req, res) => exports.read(Model, req, res),
@@ -503,6 +369,6 @@ module.exports = ( Model ) => {
     update: (req, res) => exports.update(Model, req, res),
     delete: (req, res) => exports.delete(Model, req, res),
     list: (req, res) => exports.list(Model, req, res),
-    search: (req, res) => exports.search(Model, req, res),
+    search: (req, res) => exports.search(Model, req, res)
   };
 };

package/libs/cloud/index.js

@@ -82,7 +82,7 @@ const uploadImages = async (files, chunkSize = 3) => {
 
     return imageLinks;
   } catch (error) {
-    throw new Error(`Image upload failed: ${error.message}`);
+    throw new Error(`Image upload failed: ${error}`);
   }
 };
 

package/package.json

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

package/routes/product.js

@@ -14,8 +14,8 @@ module.exports = (fear) => {
       router.route('/search/all').get(Product.productSearch);
       router.route("/one").get(handler.async(Product.read));
       router.route("/:id")
-            .get(handler.async(Product.read))
-            .put(handler.async(Product.update))
+            .get(Product.read)
+            .put(Product.update)
             .delete(handler.async(Product.delete));
 
       return router;