@feardread/fear 1.0.1

package/libs/swagger/index.js

@@ -0,0 +1,35 @@
+const swaggerJsdoc = require('swagger-jsdoc');
+const swaggerUi = require('swagger-ui-express');
+
+const options = {
+  definition: {
+    openapi: '3.0.0',
+    info: {
+        title: 'FEAR API',
+        description: "API endpoints for FEAR services documented on swagger",
+        contact: {
+          name: "Garrett Haptonstall <FearDread>",
+          email: "ghaptonstall@gmail.com",
+          url: "https://github.com/FearDread"
+        },
+    },
+    servers: [
+        {
+          url: "http://localhost:4000/",
+          description: "Local server"
+        },
+        {
+          url: "http://fear.master.com:4000",
+          description: "Live server"
+        },
+      ],
+    },
+    apis: ['./routes/*.js'], // Path to your API routes
+};
+
+const specs = swaggerJsdoc(options);
+
+module.exports = {
+  specs,
+  swaggerUi,
+};

package/libs/validator/index.js

@@ -0,0 +1,254 @@
+
+const handler = require('../handler');
+const { body, param, query } = require('express-validator');
+const { validationResult } = require('express-validator');
+
+
+/**
+ * Input validation utilities
+ */
+exports.input = {
+
+  /**
+   * Validate email format
+   * @param {string} email - Email to validate
+   * @returns {boolean} Is email valid
+   */
+  email: (email) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  },
+
+  /**
+   * Validate password strength
+   * @param {string} password - Password to validate
+   * @returns {object} Validation result
+   */
+  password: (password) => {
+    if (!password) {
+      return { isValid: false, message: "Password is required" };
+    }
+    if (password.length < 6) {
+      return { isValid: false, message: "Password must be at least 6 characters long" };
+    }
+    return { isValid: true };
+  },
+
+  /**
+   * Validate login input
+   * @param {object} data - Login data
+   * @returns {object} Validation result
+   */
+  login: ({ email, password }) => {
+    if (!email || !password) return { isValid: false, message: "Email and password are required" };
+    if (!exports.input.email(email)) return { isValid: false, message: "Please provide a valid email address" };
+
+    return { isValid: true };
+  },
+
+  /**
+   * Validate registration input
+   * @param {object} data - Registration data
+   * @returns {object} Validation result
+   */
+  register: (data) => {
+    const { email, password, firstname, lastname, name } = data;
+
+    if (!email) return { isValid: false, message: "Email is required" };
+    if (!exports.input.email(email)) return { isValid: false, message: "Please provide a valid email address" };
+  
+    const passwordValidation = exports.input.password(password);
+    if (!passwordValidation.isValid) return passwordValidation;
+
+    const fullName = firstname && lastname ? `${firstname} ${lastname}` : name;
+    if (!fullName) return { isValid: false, message: "Name is required" };
+
+    return { isValid: true, name: fullName };
+  }
+}
+
+
+/**
+ * Basic validation middleware for express-validator
+ * Checks validation results and throws handler..error if validation fails
+ */
+exports.request = (req, res, next) => {
+  const errors = validationResult(req);
+
+  if (!errors.isEmpty()) {
+    const formattedErrors = errors.array().reduce((acc, error) => {
+      const field = error.path || error.param;
+      if (!acc[field]) {
+        acc[field] = [];
+      }
+      acc[field].push(error.msg);
+      return acc;
+    }, {});
+
+    const errorResponse = {
+      success: false,
+      message: 'Validation failed',
+      errors: formattedErrors,
+      errorCount: errors.array().length
+    };
+
+    return res.status(400).json(errorResponse);
+  }
+
+  next();
+}
+
+/**
+ * Custom validation schemas for common use cases
+ */
+exports.schemas = {
+  // MongoDB ObjectId validation
+  mongoId: (field = 'id') => ({
+    [field]: {
+      in: ['params', 'body', 'query'],
+      isMongoId: {
+        errorMessage: `Valid ${field} is required`
+      }
+    }
+  }),
+
+  // Email validation
+  email: (field = 'email', required = true) => ({
+    [field]: {
+      in: ['body'],
+      ...(required && { notEmpty: { errorMessage: `${field} is required` } }),
+      isEmail: {
+        errorMessage: 'Valid email address is required'
+      },
+      normalizeEmail: true
+    }
+  }),
+
+  // Password validation
+  password: (field = 'password', minLength = 8) => ({
+    [field]: {
+      in: ['body'],
+      isLength: {
+        options: { min: minLength },
+        errorMessage: `Password must be at least ${minLength} characters long`
+      },
+      matches: {
+        options: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/,
+        errorMessage: 'Password must contain at least one uppercase letter, one lowercase letter, and one number'
+      }
+    }
+  }),
+
+  // Pagination validation
+  pagination: () => ({
+    page: {
+      in: ['query'],
+      optional: true,
+      isInt: {
+        options: { min: 1 },
+        errorMessage: 'Page must be a positive integer'
+      },
+      toInt: true
+    },
+    limit: {
+      in: ['query'],
+      optional: true,
+      isInt: {
+        options: { min: 1, max: 100 },
+        errorMessage: 'Limit must be between 1 and 100'
+      },
+      toInt: true
+    }
+  })
+};
+
+/**
+ * Dynamic validation builder
+ */
+exports.buildValidation = (schema) => {
+  const { checkSchema } = require('express-validator');
+  return checkSchema(schema);
+};
+
+/**
+ * Sanitization helpers
+ */
+exports.sanitizers = {
+  trimAndEscape: (field) =>
+    body(field).trim().escape(),
+
+  normalizeEmail: (field = 'email') =>
+    body(field).normalizeEmail(),
+
+  toLowerCase: (field) =>
+    body(field).toLowerCase(),
+
+  toBoolean: (field) =>
+    body(field).toBoolean()
+};
+
+/**
+ * Validation middleware factory
+ * Creates validation middleware with custom error handling
+ */
+exports.factory = (options = {}) => {
+  const {
+    detailed = true,
+    firstOnly = false,
+    location = true
+  } = options;
+
+  return (req, res, next) => {
+    const errors = validationResult(req);
+
+    if (!errors.isEmpty()) {
+      if (firstOnly) {
+        const firstError = errors.array()[0];
+        const message = location
+          ? `${firstError.path}: ${firstError.msg}`
+          : firstError.msg;
+
+        throw new handler.error(message, 400);
+      }
+
+      if (detailed) {
+        const formattedErrors = errors.array().reduce((acc, error) => {
+          const field = error.path || error.param;
+          if (!acc[field]) {
+            acc[field] = [];
+          }
+          acc[field].push({
+            message: error.msg,
+            value: error.value,
+            location: error.location
+          });
+          return acc;
+        }, {});
+
+        return res.status(400).json({
+          success: false,
+          message: 'Validation failed',
+          errors: formattedErrors
+        });
+      }
+
+      // Default: simple error list
+      const errorMessages = errors.array().map(error =>
+        includeLocation ? `${error.path}: ${error.msg}` : error.msg
+      );
+
+      throw new handler.error(errorMessages.join(', '), 400);
+    }
+
+    next();
+  };
+};
+
+module.exports = {
+  input: exports.input,
+  request: exports.request,
+  schemas: exports.schemas,
+  builder: exports.buildValidation,
+  factory: exports.factory,
+  sanitizers: exports.sanitizers,
+}

package/models/blog.js

@@ -0,0 +1,31 @@
+const mongoose = require("mongoose");
+
+const blogSchema = new mongoose.Schema({
+    title: { type: String, required: true },
+    slug: { type: String, required: false },
+    description: { type: String, required: true },
+    section: { type:String, required: false, default: "Marketing" },
+    category: { type: mongoose.Schema.Types.String, ref: "Category" },
+    numViews: { type: Number, default: 0 },
+    isLiked: { type: Boolean, default: false },
+    isDisliked: { type: Boolean, default: false },
+    likes: [{ 
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    }],
+    dislikes: [{
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+    }],
+    author: { type: String, default: "Admin" },
+    images: [],
+  },
+  {
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+    timestamps: true,
+  }
+);
+
+//Export the model
+module.exports = mongoose.model("Blog", blogSchema);

package/models/brand.js

@@ -0,0 +1,12 @@
+const mongoose = require("mongoose");
+
+const brandSchema = new mongoose.Schema({
+    title: { type: String, required: true, unique: true, index: true },
+    logo: { type: Object, required: false, default:
+        { public_id: '', secure_url: ''}},
+    isActive: { type: Boolean, default: true }
+  }, 
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("Brand", brandSchema);

package/models/cart.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+
+const cartSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+    productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product" },
+    quantity: { type: Number, required: true },
+    price: { type: Number, required: true },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+module.exports = mongoose.model("Cart", cartSchema);

package/models/category.js

@@ -0,0 +1,11 @@
+const mongoose = require("mongoose"); // Erase if already required
+
+// Declare the Schema of the Mongo model
+const categorySchema = new mongoose.Schema({
+    title: { type: String, required: true, unique: true, index: true },
+  },
+  { timestamps: true }
+);
+
+//Export the model
+module.exports = mongoose.model("Category", categorySchema);

package/models/coupon.js

@@ -0,0 +1,9 @@
+const mongoose = require("mongoose");
+
+const couponSchema = new mongoose.Schema({
+  name: { type: String, required: true, unique: true, uppercase: true },
+  expiry: { type: Date, required: true },
+  discount: { type: Number, required: true },
+});
+
+module.exports = mongoose.model("Coupon", couponSchema);

package/models/enquiry.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose"); // Erase if already required
+
+// Declare the Schema of the Mongo model
+var enqSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: true,
+  },
+  email: {
+    type: String,
+    required: true,
+  },
+  mobile: {
+    type: String,
+    required: true,
+  },
+  comment: {
+    type: String,
+    required: true,
+  },
+  status: {
+    type: String,
+    default: "Submitted",
+    enum: ["Submitted", "Contacted", "In Progress", "Resolved"],
+  },
+});
+
+//Export the model
+module.exports = mongoose.model("Enquiry", enqSchema);

package/models/events.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+
+const eventSchema = new mongoose.Schema({
+    title: { type: String, required: true, unique: true, index: true },
+    start: { type: Date, required: true, default: mongoose.now() },
+    end:  { type: Date, required: false, default: mongoose.now() },
+    allDay: { type: Boolean, default: false },
+    color: { type: String, required: false, default: 'azure' }
+  }, 
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("Events", eventSchema);

package/models/order.js

@@ -0,0 +1,94 @@
+const mongoose = require("mongoose"); // Erase if already required
+
+// Declare the Schema of the Mongo model
+var orderSchema = new mongoose.Schema(
+  {
+    user: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+    },
+    shippingInfo: {
+      firstname: {
+        type: String,
+        required: true,
+      },
+      lastname: {
+        type: String,
+        required: true,
+      },
+      address: {
+        type: String,
+        required: true,
+      },
+      city: {
+        type: String,
+        required: true,
+      },
+      state: {
+        type: String,
+        required: true,
+      },
+      other: {
+        type: String,
+      },
+      pincode: {
+        type: Number,
+        required: true,
+      },
+    },
+    paymentInfo: {
+      razorpayOrderId: {
+        type: String,
+        required: true,
+      },
+      razorpayPaymentId: {
+        type: String,
+        required: true,
+      },
+    },
+    orderItems: [
+      {
+        product: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: "Product",
+          required: true,
+        },
+        quantity: {
+          type: Number,
+          required: true,
+        },
+        price: {
+          type: Number,
+          required: true,
+        },
+      },
+    ],
+    paidAt: {
+      type: Date,
+      default: Date.now(),
+    },
+    month: {
+      type: Number,
+      default: new Date().getMonth(),
+    },
+    totalPrice: {
+      type: Number,
+      required: true,
+    },
+    totalPriceAfterDiscount: {
+      type: Number,
+      required: true,
+    },
+    orderStatus: {
+      type: String,
+      default: "Ordered",
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+//Export the model
+module.exports = mongoose.model("Order", orderSchema);

package/models/product.js

@@ -0,0 +1,32 @@
+const mongoose = require("mongoose"); // Erase if already required
+const Review = require("./review");
+
+// Declare the Schema of the Mongo model
+const productSchema = new mongoose.Schema({
+    title: { type: String, required: true, trim: true },
+    slug: { type: String, required: false, unique: true, lowercase: true },
+    description: { type: String, required: true },
+    price: { type: Number, required: true },
+    category: { type: mongoose.Schema.Types.String, ref: "Category" },
+    brand: { type: mongoose.Schema.Types.String, ref: "Brand" , required: false },
+    quantity: { type: Number, required: true },
+    sold: { type: Number, default: 0 },
+    reviews: [Review.schema],
+    images: [{
+        public_id: String,
+        url: String
+      },
+    ],
+    tags: String,
+    ratings: [{
+        star: Number,
+        comment: String,
+        postedby: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+      },
+    ],
+    totalrating: { type: Number, default: 0 },
+  }, { timestamps: true }
+);
+
+//Export the model
+module.exports = mongoose.model("Product", productSchema);

package/models/review.js

@@ -0,0 +1,14 @@
+const mongoose = require("mongoose");
+
+const reviewSchema = new mongoose.Schema({
+    user: { type: mongoose.Schema.Types.ObjectId, ref:"User", required:true },
+    product: { type: mongoose.Schema.Types.ObjectId, ref:"Product", required:true },
+    rating: { type:Number, required:true, min:1, max:5 },
+    comment: { type:String, required:true },
+    createdAt: { type:Date, default:Date.now }
+  },
+  { timestamps: true, versionKey:false}
+); 
+
+
+module.exports = mongoose.model("Review", reviewSchema);

package/models/tag.js

@@ -0,0 +1,10 @@
+const mongoose = require("mongoose");
+
+const tagSchema = new mongoose.Schema({
+    tag: { type: String, required: true, unique: true, index: true }
+    
+  }, 
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("Brand", brandSchema);

package/models/task.js

@@ -0,0 +1,11 @@
+const mongoose = require("mongoose");
+
+const taskSchema = new mongoose.Schema({
+    task: { type: String, required: true, index: true },
+    createdBy: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+    createdAt: { type:Date, default:Date.now },
+    isComplete: { type: Boolean, default: false},
+    }, {timestamps: true}
+)
+
+module.exports = mongoose.model("Task", taskSchema);

package/models/user.js

@@ -0,0 +1,68 @@
+const mongoose = require("mongoose");
+const bcrypt = require("bcrypt");
+const crypto = require("crypto");
+
+const userSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    lastname: { type: String, required: false },
+    email: { type: String, required: true, unique: true },
+    username: { type: String, required: false, unique: false },
+    mobile: { type: String, required: false, unique: true },
+    password: { type: String, required: true },
+    avatar: { type: Object, required: false, default: {
+      public_id: '',
+      secure_url: ''
+    }},
+    role: { type: String, default: "customer" },
+    isBlocked: { type: Boolean, default: false },
+    address: { type: String },
+    shipping: { type: String },
+    wishlist: [{ type: mongoose.Schema.Types.ObjectId, ref: "Product" }],
+    refreshToken: { type: String },
+      passwordChangedAt: Date,
+      passwordResetToken: String,
+      passwordResetExpires: Date
+    },
+  { timestamps: true }
+);
+
+// Hooks
+userSchema.pre("save", async function (next) {
+  if (!this.isModified("password")) {
+    next();
+  }
+  const salt = await bcrypt.genSaltSync(10);
+  this.password = await bcrypt.hash(this.password, salt);
+  next();
+});
+
+// Methods
+userSchema.methods.compare = async function (entered) {
+  return await bcrypt.compare(entered, this.password);
+};
+
+userSchema.methods.token = async function () {
+  const resettoken = crypto.randomBytes(32).toString("hex");
+
+  this.passwordResetToken = crypto.createHash("sha256").update(resettoken).digest("hex");
+  this.passwordResetExpires = Date.now() + 30 * 60 * 1000;
+
+  return resettoken;
+};
+
+//Statics
+userSchema.statics.countUsers = function () {
+  return this.countDocuments({});
+};
+
+userSchema.statics.findByEmail = async function (email) {
+return await this.findOne({ email });
+};
+
+// Query
+userSchema.query.paginate = function ({ page, limit }) {
+  const skip = limit * (page - 1);
+  return this.skip(skip).limit(limit);
+};
+
+module.exports = mongoose.model("User", userSchema);

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@feardread/fear",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Garrett Haptonstall",
+  "license": "MIT"
+}