@feardread/fear 1.0.1

package/libs/search/api.js

@@ -0,0 +1,384 @@
+const logger = require("../logger");
+
+/**
+ * Advanced search, filter, and pagination features for Mongoose models
+ * Provides chainable methods for building complex database queries
+ */
+module.exports = class SearchApi {
+  /**
+   * Initialize SearchFeatures with model and query parameters
+   * @param {mongoose.Model} Model - Mongoose model to query
+   * @param {Object} queryObj - Query parameters from request
+   * @param {Object} [options={}] - Additional configuration options
+   */
+  constructor(Model, queryObj, options = {}) {
+    if (!Model) {
+      throw new Error('Model parameter is required');
+    }
+    
+    this.Model = Model;
+    this.query = Model.find();
+    this.queryObj = queryObj || {};
+    this.options = {
+      defaultSort: { createdAt: -1 }, // Default sorting
+      searchFields: [], // Specific fields to search in
+      excludeFields: ["keyword", "page", "limit", "sort", "fields"], // Fields to exclude from filtering
+      caseSensitive: false, // Case sensitivity for search
+      fuzzySearch: true, // Enable fuzzy matching
+      ...options
+    };
+    
+    this.originalQuery = { ...this.queryObj };
+    this.isExecuted = false;
+  }
+
+  /**
+   * Perform text search across specified fields or all string fields
+   * @param {string[]} [searchFields] - Specific fields to search in
+   * @returns {SearchApi} Chainable instance
+   */
+  search(searchFields = null) {
+    try {
+      const fieldsToSearch = searchFields || this.options.searchFields;
+      const searchTerms = {};
+      const keyword = this.queryObj.keyword;
+      
+      if (!keyword) {
+        return this;
+      }
+
+      // If specific search fields are provided
+      if (fieldsToSearch.length > 0) {
+        const searchConditions = fieldsToSearch.map(field => ({
+          [field]: {
+            $regex: keyword,
+            $options: this.options.caseSensitive ? "" : "i"
+          }
+        }));
+        
+        this.query = this.query.find({
+          $or: searchConditions
+        });
+      } else {
+        // Search in all provided query fields (excluding system fields)
+        Object.keys(this.queryObj).forEach(prop => {
+          if (this.queryObj.hasOwnProperty(prop) && 
+              !this.options.excludeFields.includes(prop)) {
+            searchTerms[prop] = {
+              $regex: this.queryObj[prop],
+              $options: this.options.caseSensitive ? "" : "$i"
+            };
+          }
+        });
+
+        if (Object.keys(searchTerms).length > 0) {
+          logger.info('Search terms applied:', searchTerms);
+          this.query = this.query.find(searchTerms);
+        }
+      }
+
+      return this;
+    } catch (error) {
+      logger.error('Search operation failed:', error);
+      throw new Error(`Search failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Apply filters for exact matches and range queries
+   * @param {string[]} [additionalExcludeFields] - Additional fields to exclude
+   * @returns {SearchFeatures} Chainable instance
+   */
+  filter(additionalExcludeFields = []) {
+    try {
+      const queryCopy = { ...this.queryObj };
+      const excludeFields = [...this.options.excludeFields, ...additionalExcludeFields];
+      
+      // Remove excluded fields
+      excludeFields.forEach(field => delete queryCopy[field]);
+      
+      if (Object.keys(queryCopy).length === 0) {
+        return this;
+      }
+
+      // Handle range operators (gt, gte, lt, lte, ne, in, nin)
+      let queryString = JSON.stringify(queryCopy);
+      queryString = queryString.replace(
+        /\b(gt|gte|lt|lte|ne|in|nin|regex)\b/g, 
+        match => `$${match}`
+      );
+
+      const filterQuery = JSON.parse(queryString);
+      
+      // Handle array fields (in/nin operations)
+      Object.keys(filterQuery).forEach(key => {
+        const value = filterQuery[key];
+        if (typeof value === 'object' && value !== null) {
+          // Handle comma-separated values for $in operator
+          Object.keys(value).forEach(operator => {
+            if ((operator === '$in' || operator === '$nin') && 
+                typeof value[operator] === 'string') {
+              value[operator] = value[operator].split(',').map(item => item.trim());
+            }
+          });
+        }
+      });
+
+      logger.info('Filter query applied:', filterQuery);
+      this.query = this.query.find(filterQuery);
+      
+      return this;
+    } catch (error) {
+      logger.error('Filter operation failed:', error);
+      throw new Error(`Filter failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Apply sorting to the query
+   * @param {string|Object} [customSort] - Custom sort criteria
+   * @returns {SearchFeatures} Chainable instance
+   */
+  sort(customSort = null) {
+    try {
+      let sortCriteria = customSort || this.queryObj.sort || this.options.defaultSort;
+      
+      // Convert string sort to object
+      if (typeof sortCriteria === 'string') {
+        const sortObj = {};
+        sortCriteria.split(',').forEach(field => {
+          const trimmedField = field.trim();
+          if (trimmedField.startsWith('-')) {
+            sortObj[trimmedField.substring(1)] = -1;
+          } else {
+            sortObj[trimmedField] = 1;
+          }
+        });
+        sortCriteria = sortObj;
+      }
+
+      this.query = this.query.sort(sortCriteria);
+      logger.info('Sort applied:', sortCriteria);
+      
+      return this;
+    } catch (error) {
+      logger.error('Sort operation failed:', error);
+      throw new Error(`Sort failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Select specific fields to return
+   * @param {string|string[]} [fields] - Fields to select
+   * @returns {SearchFeatures} Chainable instance
+   */
+  selectFields(fields = null) {
+    try {
+      const fieldsToSelect = fields || this.queryObj.fields;
+      
+      if (fieldsToSelect) {
+        const selectFields = Array.isArray(fieldsToSelect) 
+          ? fieldsToSelect.join(' ')
+          : fieldsToSelect.split(',').join(' ');
+        
+        this.query = this.query.select(selectFields);
+        logger.info('Fields selected:', selectFields);
+      }
+      
+      return this;
+    } catch (error) {
+      logger.error('Field selection failed:', error);
+      throw new Error(`Field selection failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Apply pagination with configurable limits
+   * @param {number} [resultPerPage=10] - Number of results per page
+   * @param {number} [maxLimit=100] - Maximum allowed limit
+   * @returns {SearchFeatures} Chainable instance
+   */
+  paginate(resultPerPage = 10, maxLimit = 100) {
+    try {
+      const page = Math.max(1, Number(this.queryObj.page) || 1);
+      const limit = Math.min(
+        maxLimit, 
+        Math.max(1, Number(this.queryObj.limit) || resultPerPage)
+      );
+      
+      const skip = limit * (page - 1);
+
+      this.query = this.query.limit(limit).skip(skip);
+      
+      // Store pagination info for later use
+      this.paginationInfo = {
+        page,
+        limit,
+        skip
+      };
+      
+      logger.info('Pagination applied:', { page, limit, skip });
+      
+      return this;
+    } catch (error) {
+      logger.error('Pagination failed:', error);
+      throw new Error(`Pagination failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Populate referenced fields
+   * @param {string|Object|Array} [populateOptions] - Population configuration
+   * @returns {SearchFeatures} Chainable instance
+   */
+  populate(populateOptions = null) {
+    try {
+      if (populateOptions) {
+        this.query = this.query.populate(populateOptions);
+        logger.info('Population applied:', populateOptions);
+      } else if (this.queryObj.populate) {
+        // Handle populate from query string
+        const populateFields = this.queryObj.populate.split(',').map(field => field.trim());
+        populateFields.forEach(field => {
+          this.query = this.query.populate(field);
+        });
+        logger.info('Population applied from query:', populateFields);
+      }
+      
+      return this;
+    } catch (error) {
+      logger.error('Population failed:', error);
+      throw new Error(`Population failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Execute the query and return results with metadata
+   * @returns {Promise<Object>} Results with pagination metadata
+   */
+  async execute() {
+    try {
+      if (this.isExecuted) {
+        logger.warn('Query has already been executed');
+      }
+      
+      // Get total count for pagination metadata
+      const totalDocuments = await this.Model.countDocuments(this.query.getQuery());
+      
+      // Execute the main query
+      const results = await this.query.exec();
+      
+      // Prepare pagination metadata
+      const paginationMeta = this.paginationInfo ? {
+        currentPage: this.paginationInfo.page,
+        totalPages: Math.ceil(totalDocuments / this.paginationInfo.limit),
+        totalDocuments,
+        documentsPerPage: this.paginationInfo.limit,
+        hasNextPage: this.paginationInfo.page < Math.ceil(totalDocuments / this.paginationInfo.limit),
+        hasPrevPage: this.paginationInfo.page > 1
+      } : null;
+
+      this.isExecuted = true;
+      
+      return {
+        result: results,
+        meta: {
+          total: totalDocuments,
+          count: results.length,
+          pagination: paginationMeta,
+          query: this.originalQuery
+        }
+      };
+    } catch (error) {
+      logger.error('Query execution failed:', error);
+      throw new Error(`Query execution failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get the current query object (for debugging)
+   * @returns {mongoose.Query} Current Mongoose query
+   */
+  getQuery() {
+    return this.query;
+  }
+
+  /**
+   * Get the current query filter (for debugging)
+   * @returns {Object} Current query filter
+   */
+  getFilter() {
+    return this.query.getQuery();
+  }
+
+  /**
+   * Reset the query to its initial state
+   * @returns {SearchFeatures} Chainable instance
+   */
+  reset() {
+    this.query = this.Model.find();
+    this.isExecuted = false;
+    this.paginationInfo = null;
+    logger.info('Query reset to initial state');
+    return this;
+  }
+
+  /**
+   * Clone the current SearchFeatures instance
+   * @returns {SearchFeatures} New SearchFeatures instance
+   */
+  clone() {
+    const cloned = new SearchFeatures(this.Model, this.queryObj, this.options);
+    cloned.query = this.query.clone();
+    return cloned;
+  }
+
+  /**
+   * Apply full-text search using MongoDB text indexes
+   * @param {string} searchText - Text to search for
+   * @param {Object} [options] - Text search options
+   * @returns {SearchFeatures} Chainable instance
+   */
+  textSearch(searchText, options = {}) {
+    try {
+      if (!searchText) {
+        return this;
+      }
+
+      const textSearchOptions = {
+        $search: searchText,
+        ...options
+      };
+
+      this.query = this.query.find({ $text: textSearchOptions });
+      logger.info('Text search applied:', textSearchOptions);
+      
+      return this;
+    } catch (error) {
+      logger.error('Text search failed:', error);
+      throw new Error(`Text search failed: ${error.message}`);
+    }
+  }
+
+  safeSearch(obj) {
+        // Fallback to basic search if SearchFeatures fails
+    const { keyword } = this.queryObj || obj; 
+    const limit = parseInt(this.queryObj.limit) || 10;
+    
+    if (!keyword) {
+      return res.status(400).json({
+        success: false, result: null, message: "Search keyword is required"
+      });
+    }
+
+    this.query = this.query.find({
+      $or: [
+        { name: { $regex: keyword, $options: 'i' } },
+        { description: { $regex: keyword, $options: 'i' } }
+      ]})
+      .limit(limit)
+      .sort({ createdAt: -1 });
+      
+      return this;
+  }
+}

package/libs/search/features.js

@@ -0,0 +1,219 @@
+const logger = require("../logger");
+const SearchApi = require('./api');
+
+// Helper function to get/set model
+let currentModel = null;
+
+exports.getModel = () => {
+    return currentModel;
+};
+
+exports.setModel = (Model) => {
+    currentModel = Model;
+    return currentModel;
+};
+
+exports.basicSearch = async (params, Model = currentModel) => {
+    const queryParams = params || {
+        keyword: "laptop",
+        page: 1,
+        limit: 10
+    };
+
+    const Search = new SearchApi(Model, queryParams, {
+        searchFields: ['name', 'description', 'brand']
+    });
+
+    const results = await Search
+        .search()
+        .sort()
+        .paginate()
+        .execute();
+
+    console.log('Basic Search Results:', results);
+    return results;
+};
+
+exports.textSearch = async (searchText, Model = currentModel) => {
+    const queryParams = { searchText } || { searchText: "marvel comic book" };
+
+    const Search = new SearchApi(Model, queryParams);
+
+    const results = await Search
+        .textSearch(queryParams.searchText, {
+            $language: 'english',
+            $caseSensitive: false
+        })
+        .sort({ score: { $meta: 'textScore' } })
+        .paginate()
+        .execute();
+
+    console.log('Full-text Search Results:', results);
+    return results;
+};
+
+exports.standardSearch = async (Model, query) => {
+        const Search = new SearchApi(Model, query, {
+            searchFields: ['title', 'description', 'brand'],
+            defaultSort: { createdAt: -1 }
+        });
+
+        const results = await Search.search()
+            .filter()
+            .sort()
+            .selectFields()
+            .populate('category brand')
+            .paginate()
+            .execute();
+
+        return results;
+};
+
+exports.productSearch = async (query, Product) => {
+    const {
+        keyword,
+        category,
+        brand,
+        minPrice,
+        maxPrice,
+        rating,
+        sortBy = 'popularity',
+        page = 1,
+        limit = 24
+    } = 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(Product, queryObj, {
+        searchFields: ['name', 'description', 'tags'],
+        defaultSort: sortOptions[sortBy] || sortOptions.popularity
+    });
+
+    const results = await Search
+        .search(['name', 'description', 'brand', 'tags'])
+        .filter()
+        .sort()
+        .selectFields('-__v,-updatedAt')
+        .populate('reviews')
+        .paginate(limit, 50) // Max 50 items per page
+        .execute();
+
+    return results;
+};
+
+exports.orderSearch = async (searchParams, Order) => {
+    const {
+        customerEmail,
+        status,
+        minAmount,
+        maxAmount,
+        dateFrom,
+        dateTo,
+        paymentMethod
+    } = searchParams;
+
+    const queryObj = {};
+    if (status) queryObj.status = status;
+    if (paymentMethod) queryObj.paymentMethod = paymentMethod;
+
+    if (minAmount || maxAmount) {
+        queryObj.totalAmount = {};
+        if (minAmount) queryObj.totalAmount.gte = parseFloat(minAmount);
+        if (maxAmount) queryObj.totalAmount.lte = parseFloat(maxAmount);
+    }
+
+    if (dateFrom || dateTo) {
+        queryObj.orderDate = {};
+        if (dateFrom) queryObj.orderDate.gte = new Date(dateFrom);
+        if (dateTo) queryObj.orderDate.lte = new Date(dateTo);
+    }
+
+    const Search = new SearchApi(Order, queryObj);
+
+    let query = Search
+        .filter()
+        .sort({ orderDate: -1 })
+        .populate({
+            path: 'customer',
+            select: 'firstName lastName email'
+        })
+        .populate({
+            path: 'items.product',
+            select: 'name price'
+        });
+
+    // Add customer email search if provided
+    if (customerEmail) {
+        // This requires a more complex approach since we're searching in populated fields
+        query = query.populate({
+            path: 'customer',
+            match: { email: { $regex: customerEmail, $options: 'i' } },
+            select: 'firstName lastName email'
+        });
+    }
+
+    return await query.paginate().execute();
+};
+
+exports.userSearch = async (adminQuery, User) => {
+    const {
+        keyword,
+        role,
+        status,
+        dateFrom,
+        dateTo,
+        sortBy = 'createdAt',
+        order = 'desc'
+    } = adminQuery;
+
+    const queryObj = {};
+    if (keyword) queryObj.keyword = keyword;
+    if (role) queryObj.role = role;
+    if (status) queryObj.status = status;
+
+    // Date range filtering
+    if (dateFrom || dateTo) {
+        queryObj.createdAt = {};
+        if (dateFrom) queryObj.createdAt.gte = new Date(dateFrom);
+        if (dateTo) queryObj.createdAt.lte = new Date(dateTo);
+    }
+
+    const sortOrder = order === 'desc' ? -1 : 1;
+    const sortOptions = { [sortBy]: sortOrder };
+
+    const Search = new SearchApi(User, queryObj, {
+        searchFields: ['firstName', 'lastName', 'email', 'username'],
+        excludeFields: ['password', 'resetToken']
+    });
+
+    const results = await Search
+        .search()
+        .filter()
+        .sort(sortOptions)
+        .selectFields('-password,-resetToken,-__v')
+        .paginate(25)
+        .execute();
+
+    return results;
+};
+
+// Also provide module.exports for compatibility
+module.exports = exports;

package/libs/search/service.js

@@ -0,0 +1,64 @@
+const SearchApi = require('./api');
+
+module.exports = class SearchService {
+  constructor(model, config = {}) {
+    this.model = model;
+    this.config = {
+      searchFields: [],
+      sortOptions: {},
+      filterRules: {},
+      ...config
+    };
+  }
+
+  async search(params) {
+    const searchFeatures = new SearchApi(this.model, params, {
+      searchFields: this.config.searchFields,
+      defaultSort: this.config.sortOptions.default || { createdAt: -1 }
+    });
+
+    // Apply custom filter rules
+    if (this.config.filterRules.beforeSearch) {
+      await this.config.filterRules.beforeSearch(searchFeatures, params);
+    }
+
+    let query = searchFeatures.search().filter().sort();
+
+    // Apply population rules
+    if (this.config.populate) {
+      query = query.populate(this.config.populate);
+    }
+
+    const results = await query.paginate().execute();
+
+    // Apply post-processing
+    if (this.config.filterRules.afterSearch) {
+      await this.config.filterRules.afterSearch(results, params);
+    }
+
+    return results;
+  }
+}
+
+/*
+// Usage of Dynamic Search Service
+const productSearchService = new DynamicSearchService(Product, {
+  searchFields: ['name', 'description', 'tags'],
+  populate: 'category reviews',
+  filterRules: {
+    beforeSearch: async (searchFeatures, params) => {
+      // Apply business logic before search
+      if (params.featured) {
+        searchFeatures.query = searchFeatures.query.find({ featured: true });
+      }
+    },
+    afterSearch: async (results, params) => {
+      // Apply business logic after search
+      results.data = results.data.map(item => ({
+        ...item.toObject(),
+        discountedPrice: item.price * 0.9 // Apply 10% discount
+      }));
+    }
+  }
+});
+*/

package/libs/swagger/config.js

@@ -0,0 +1,18 @@
+const swaggerJSDoc = require("swagger-jsdoc");
+
+const swaggerDefinition = {
+    openapi: "3.0.0",
+        info: {
+            title: "FEAR API",
+            version: "1.0.0",
+            description: "The Main API for all FEAR apps (Ekomix, Ekoins, Admin CRM",
+        },
+};
+
+const options = {
+    swaggerDefinition,
+    apis: [`../routes/*.js`],
+};
+
+const swaggerSpec = swaggerJSDoc(options);
+module.exports = swaggerSpec;