@feardread/fear 1.0.1

package/libs/config/db.js

@@ -0,0 +1,21 @@
+const mongoose = require("mongoose");
+
+const connectDB = async () => {
+  try {
+    const uri = process.env.MONGO_URI || "mongodb://localhost/bags-ecommerce";
+    await mongoose
+      .connect(uri, {
+        useNewUrlParser: true,
+        useCreateIndex: true,
+        useUnifiedTopology: true,
+      })
+      .catch((error) => console.log(error));
+    const connection = mongoose.connection;
+    console.log("MONGODB CONNECTED SUCCESSFULLY!");
+  } catch (error) {
+    console.log(error);
+    return error;
+  }
+};
+
+module.exports = connectDB;

package/libs/config/validator.js

@@ -0,0 +1,82 @@
+const { check, validationResult } = require("express-validator");
+
+const userSignUpValidationRules = () => {
+  return [
+    check("name", "Name is required").not().isEmpty(),
+    check("email", "Invalid email").not().isEmpty().isEmail(),
+    check("password", "Please enter a password with 4 or more characters")
+      .not()
+      .isEmpty()
+      .isLength({ min: 4 }),
+  ];
+};
+
+const userSignInValidationRules = () => {
+  return [
+    check("email", "Invalid email").not().isEmpty().isEmail(),
+    check("password", "Invalid password").not().isEmpty().isLength({ min: 4 }),
+  ];
+};
+
+const userContactUsValidationRules = () => {
+  return [
+    check("name", "Please enter a name").not().isEmpty(),
+    check("email", "Please enter a valid email address")
+      .not()
+      .isEmpty()
+      .isEmail(),
+    check("message", "Please enter a message with at least 10 words")
+      .not()
+      .isEmpty()
+      .isLength({ min: 10 }),
+  ];
+};
+
+const validateSignup = (req, res, next) => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    var messages = [];
+    errors.array().forEach((error) => {
+      messages.push(error.msg);
+    });
+    req.flash("error", messages);
+    return res.redirect("/user/signup");
+  }
+  next();
+};
+
+const validateSignin = (req, res, next) => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    var messages = [];
+    errors.array().forEach((error) => {
+      messages.push(error.msg);
+    });
+    req.flash("error", messages);
+    return res.redirect("/user/signin");
+  }
+  next();
+};
+
+const validateContactUs = (req, res, next) => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    var messages = [];
+    errors.array().forEach((error) => {
+      messages.push(error.msg);
+    });
+    console.log(messages);
+    req.flash("error", messages);
+    return res.redirect("/pages/contact-us");
+  }
+  next();
+};
+
+module.exports = {
+  userSignUpValidationRules,
+  userSignInValidationRules,
+  userContactUsValidationRules,
+  validateSignup,
+  validateSignin,
+  validateContactUs,
+};

package/libs/db/index.js

@@ -0,0 +1,318 @@
+const mongoose = require("mongoose");
+
+/**
+ * MongoDB connection utility module
+ * Provides connection management and ObjectId utilities
+ */
+class DatabaseManager {
+  constructor() {
+    this.isConnected = false;
+    this.currentDbName = null;
+    this._setupEventListeners();
+  }
+
+  /**
+   * Setup mongoose connection event listeners
+   * @private
+   */
+  _setupEventListeners() {
+    mongoose.connection.on('connected', () => {
+      this.isConnected = true;
+      console.log(`✅ MongoDB connected successfully to: ${this.currentDbName}`);
+    });
+
+    mongoose.connection.on('error', (err) => {
+      this.isConnected = false;
+      console.error('❌ MongoDB connection error:', err);
+    });
+
+    mongoose.connection.on('disconnected', () => {
+      this.isConnected = false;
+      console.log(`🔌 MongoDB disconnected from: ${this.currentDbName || 'database'}`);
+    });
+
+    mongoose.connection.on('reconnected', () => {
+      this.isConnected = true;
+      console.log(`🔄 MongoDB reconnected to: ${this.currentDbName}`);
+    });
+
+    // Graceful shutdown handling
+    process.on('SIGINT', async () => {
+      await this.close();
+      process.exit(0);
+    });
+  }
+
+  /**
+   * Connect to MongoDB database
+   * @param {Object} env - Environment configuration object
+   * @param {string} env.DB_LINK - MongoDB connection string
+   * @param {string} env.DB_NAME - Database name
+   * @param {Function} [callback] - Optional callback function
+   * @param {Object} [options] - Additional mongoose connection options
+   * @returns {Promise<void>}
+   */
+  async connect(env, callback = null, options = {}) {
+    try {
+      // Validate required environment variables
+      if (!env.DB_LINK) {
+        throw new Error('DB_LINK is required in environment configuration');
+      }
+      if (!env.DB_NAME) {
+        throw new Error('DB_NAME is required in environment configuration');
+      }
+
+      // Check if already connected to the same database
+      if (this.isConnected && this.currentDbName === env.DB_NAME) {
+        console.log(`📋 Already connected to MongoDB: ${env.DB_NAME}`);
+        if (callback) callback();
+        return;
+      }
+
+      // Close existing connection if connected to different database
+      if (this.isConnected && this.currentDbName !== env.DB_NAME) {
+        await this.close();
+      }
+
+      // Set mongoose configuration
+      mongoose.set("strictQuery", false);
+      
+      // Default connection options
+      const defaultOptions = {
+        dbName: env.DB_NAME,
+        maxPoolSize: 10,
+        serverSelectionTimeoutMS: 5000,
+        socketTimeoutMS: 45000,
+        bufferCommands: false,
+        ...options
+      };
+
+      this.currentDbName = env.DB_NAME;
+
+      // Connect to MongoDB
+      await mongoose.connect(env.DB_LINK, defaultOptions);
+      
+      // Execute callback if provided
+      if (callback) callback();
+      
+    } catch (error) {
+      this.isConnected = false;
+      console.error('❌ Failed to connect to MongoDB:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Disconnect from MongoDB
+   * @param {Function} [callback] - Optional callback function
+   * @returns {Promise<void>}
+   */
+  async close(callback = null) {
+    try {
+      if (!this.isConnected) {
+        console.log('📋 MongoDB is not connected');
+        if (callback) callback();
+        return;
+      }
+
+      await mongoose.disconnect();
+      this.isConnected = false;
+      
+      if (callback) callback();
+      
+    } catch (error) {
+      console.error('❌ Error disconnecting from MongoDB:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Get connection status
+   * @returns {Object} Connection status information
+   */
+  getConnectionStatus() {
+    return {
+      isConnected: this.isConnected,
+      readyState: mongoose.connection.readyState,
+      dbName: this.currentDbName,
+      host: mongoose.connection.host,
+      port: mongoose.connection.port
+    };
+  }
+
+  /**
+   * Wait for database connection to be ready
+   * @param {number} [timeout=10000] - Timeout in milliseconds
+   * @returns {Promise<void>}
+   */
+  async waitForConnection(timeout = 10000) {
+    return new Promise((resolve, reject) => {
+      if (this.isConnected) {
+        resolve();
+        return;
+      }
+
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Connection timeout after ${timeout}ms`));
+      }, timeout);
+
+      mongoose.connection.once('connected', () => {
+        clearTimeout(timeoutId);
+        resolve();
+      });
+
+      mongoose.connection.once('error', (error) => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+}
+
+// Create singleton instance
+const dbManager = new DatabaseManager();
+
+/**
+ * ObjectId utility functions
+ */
+const ObjectIdUtils = {
+  /**
+   * Create new ObjectId from string or return existing ObjectId
+   * @param {string|mongoose.Types.ObjectId} id - ID to wrap
+   * @returns {mongoose.Types.ObjectId} ObjectId instance
+   */
+  wrapId(id) {
+    if (!id) {
+      throw new Error('ID parameter is required');
+    }
+
+    if (mongoose.Types.ObjectId.isValid(id)) {
+      return new mongoose.Types.ObjectId(id);
+    }
+    
+    throw new Error(`Invalid ObjectId format: ${id}`);
+  },
+
+  /**
+   * Validate if string is a valid ObjectId
+   * @param {string} id - ID to validate
+   * @param {boolean} [throwError=true] - Whether to throw error on invalid ID
+   * @returns {boolean} True if valid ObjectId
+   */
+  validate(id, throwError = true) {
+    if (!id) {
+      if (throwError) {
+        throw new Error('ID parameter is required');
+      }
+      return false;
+    }
+
+    const isValid = mongoose.Types.ObjectId.isValid(id);
+    
+    if (!isValid && throwError) {
+      throw new Error(`Invalid ObjectId format: ${id}`);
+    }
+    
+    return isValid;
+  },
+
+  /**
+   * Generate new ObjectId
+   * @returns {mongoose.Types.ObjectId} New ObjectId
+   */
+  generate() {
+    return new mongoose.Types.ObjectId();
+  },
+
+  /**
+   * Convert ObjectId to string
+   * @param {mongoose.Types.ObjectId} objectId - ObjectId to convert
+   * @returns {string} String representation of ObjectId
+   */
+  toString(objectId) {
+    if (!objectId) {
+      throw new Error('ObjectId parameter is required');
+    }
+    return objectId.toString();
+  },
+
+  /**
+   * Check if two ObjectIds are equal
+   * @param {string|mongoose.Types.ObjectId} id1 - First ID
+   * @param {string|mongoose.Types.ObjectId} id2 - Second ID
+   * @returns {boolean} True if IDs are equal
+   */
+  areEqual(id1, id2) {
+    if (!id1 || !id2) return false;
+    
+    try {
+      const objId1 = this.wrapId(id1);
+      const objId2 = this.wrapId(id2);
+      return objId1.equals(objId2);
+    } catch (error) {
+      return false;
+    }
+  }
+};
+
+/**
+ * Legacy compatibility functions (backwards compatibility)
+ */
+const legacyAPI = {
+  /**
+   * Legacy run function for backwards compatibility
+   * @deprecated Use dbManager.connect() instead
+   */
+  async run(env, callback) {
+    console.warn('⚠️  Warning: run() is deprecated. Use connect() instead.');
+    return await dbManager.connect(env, callback);
+  },
+
+  /**
+   * Legacy close function for backwards compatibility
+   * @deprecated Use dbManager.close() instead
+   */
+  async close(callback) {
+    console.warn('⚠️  Warning: close() is deprecated. Use disconnect() instead.');
+    return await dbManager.disconnect(callback);
+  },
+
+  /**
+   * Legacy store function (placeholder)
+   * @deprecated This function was not implemented in original code
+   */
+  store() {
+    console.warn('⚠️  Warning: store() function is not implemented');
+    return null;
+  },
+
+  /**
+   * Legacy wrapId function for backwards compatibility
+   * @deprecated Use ObjectIdUtils.wrapId() instead
+   */
+  wrapId(id) {
+    console.warn('⚠️  Warning: wrapId() is deprecated. Use ObjectIdUtils.wrapId() instead.');
+    return ObjectIdUtils.wrapId(id);
+  },
+
+  /**
+   * Legacy validate function for backwards compatibility
+   * @deprecated Use ObjectIdUtils.validate() instead
+   */
+  validate(id) {
+    console.warn('⚠️  Warning: validate() is deprecated. Use ObjectIdUtils.validate() instead.');
+    return ObjectIdUtils.validate(id);
+  }
+};
+
+module.exports = {
+  // New recommended API
+  connect: (env, callback, options) => dbManager.connect(env, callback, options),
+  disconnect: (callback) => dbManager.close(callback),
+  getConnectionStatus: () => dbManager.getConnectionStatus(),
+  waitForConnection: (timeout) => dbManager.waitForConnection(timeout),
+  ObjectId: ObjectIdUtils,
+  dbManager,
+  mongoose,
+  ...legacyAPI
+};      

package/libs/emailer/imap.js

@@ -0,0 +1,126 @@
+const ImapClient = require("emailjs-imap-client");
+const { ParsedMail, simpleParser } = require("mailparser");
+
+
+module.exports = class Worker {
+    constructor (mailinfo) {
+        this.mailinfo = mailinfo;
+    }
+
+    connectToServer = async (req, res) => {
+        const client = new ImapClient.default(
+            this.mailinfo.imap.host,
+            this.mailinfo.imap.port,
+            { auth: this.mailinfo.imap.auth } 
+        );
+
+        client.logLevel = client.LOG_LEVEL_NONE; // keep the output logging
+        client.onerror = (error) => {
+            console.log("IMAP.Worker.listMailboxes(): Connection error", error);
+        }; 
+        
+        await client.connect();
+        
+        return client;
+    }
+
+    listMailboxes = async (req, res) => {
+        const client = await this.connectToServer();
+        const mailboxes = await client.listMailboxes();
+        await client.close();
+
+        const iterateChildren = (inArray) => {
+    
+            inArray.forEach((inValue: any) => {
+                finalMailboxes.push({
+                    name: inValue.name,
+                    path: inValue.path
+                });
+                iterateChildren(inValue.children); 
+            });
+        };
+        iterateChildren(mailboxes.children);
+
+        return finalMailboxes;
+    }
+
+    listMessages = async (options) => {
+        const client = await this.connectToServer();
+        const mailbox = await client.selectMailbox(options.mailbox);
+
+        if (mailbox.exists === 0) {
+            await client.close();
+            return [];
+        }
+
+        const messages = await client.listMessages(
+            options.mailbox, "1:*", ["uid", "envelope"] 
+        );
+
+        await client.close();
+        const finalMessages = [];
+        messages.forEach((value) => { 
+            finalMessages.push({
+                id: value.uid, 
+                date: value.envelope.date, 
+                from: value.envelope.from[0].address,
+                subject: value.envelope.subject 
+            });
+        });
+
+        return finalMessages;
+    } 
+
+
+    /**
+     * Gets the plain text body of a single message.
+     *
+     * @param  options An object implementing the ICallOptions interface.
+     * @return               The plain text body of the message.
+     */
+    getMessageBody = async (options) => {
+        const client = await this.connectToServer();
+        const messages = await client.listMessages(
+            options.mailbox,
+            options.id,
+            { byUid: true } 
+        );
+        const parsed = await simpleParser(messages[0]["body[]"]);
+        await client.close();
+
+        return parsed?.text; 
+    } 
+
+
+    /**
+     * Deletes a single message.
+     *
+     * @param options An object implementing the ICallOptions interface.
+     */
+    deleteMessage = async (options) => {
+        const client = await this.connectToServer();
+        const messages = await client.listMessages(
+            options.mailbox,
+            options.id, // specifying a specific message ID 
+            ["uid"], // body can be in multiple parts, it’s actually an array
+            { byUid: true } // listing messages based on a specific ID
+        );
+        if (options.mailbox !== 'Deleted'){
+            await client.copyMessages(
+                options.mailbox,
+                messages[0]['uid'],
+                'Deleted',
+                { byUid: true } // tell the method that we are passing a unique ID
+            );
+        }
+        await client.deleteMessages(
+            options.mailbox,
+            messages[0]['uid'],
+            // inCallOptions.id,
+            { byUid: true } // tell the method that we are passing a unique ID
+        );
+        await client.close(); // no return
+    }
+
+
+} 

package/libs/emailer/info.js

@@ -0,0 +1,41 @@
+require("dotenv").config({ path: "backend/.env" });
+
+module.exports = {
+  "smtp": {
+    "service": process.env.SMTP_SERVICE,
+    "host": process.env.SMTP_HOST,
+    "port": process.env.SMTP_PORT,
+    "auth": {
+      "user": process.env.SMTP_MAIL,
+      "pass": process.env.SMTP_PASS
+    },
+    "apps": {
+      "gfolio": {
+        "auth": {
+          "user": process.env.SMTP_MAIL,
+          "pass": process.env.SMTP_PASS
+        },
+      },
+      "gdrea": {
+        "auth": {
+          "user": process.env.SMTP_MAIL,
+          "pass": process.env.SMTP_PASS
+        },
+      },
+      "jbird": {
+        "auth": {
+          "user": process.env.SMTP_MAIL,
+          "pass": process.env.SMTP_PASS
+        },
+      },
+    }
+  },
+  "imap": {
+    "host": "mail.mydomain.com",
+    "port": 999,
+    "auth": {
+      "user": "user@domain.com",
+      "pass": "xxx"
+    }
+  }
+}

package/libs/emailer/smtp.js

@@ -0,0 +1,77 @@
+const nodemailer = require("nodemailer");
+
+module.exports = class Worker {
+    constructor(mailinfo) {
+        this.mailinfo = mailinfo;
+        this.email = mailinfo.smtp.auth.user;
+    }
+
+    /**
+     * Send a message.
+     *
+     * @param  options An object containing to, from, subject and text properties (matches the IContact interface,
+     *                   but can't be used since the type comes from nodemailer, not app code).
+     * @return           A Promise that eventually resolves to a string (null for success, error message for an error).
+     */
+    sendMessage = async (options) => { 
+        return new Promise((res, req) => {
+            const transport = nodemailer.createTransport(this.mailinfo.smtp);
+            
+            transport.sendMail( options, (error, info) => { 
+                if (error) return reject(error);
+                return resolve();  
+            });
+        });
+    }
+
+    sendProjectEmail = async (data) => {
+        return new Promise((resolve, reject) => {
+            let transporter = nodemailer.createTransport(this.mailinfo.smtp);
+
+            const { $subject, fullname, company, email, phone, budget, about } = data;
+    
+            const message = `Fullname: ${fullname}\n`
+                            + `Email: ${email}\n`
+                            + `Budget: ${budget}\n`
+                            + `Phone number: + ${phone}\n`
+                            + `Company: ${company}\n`
+                            + `About project: ${about}\n`
+    
+            const options = {
+                from: email,
+                to: this.email,
+                subject: $subject || `Gfolio Contact Form Submission`,
+                text: message,
+            };
+    
+            transporter.sendMail(options, function(error, info) {
+                if (error) {
+                    return reject({ message: `An error has occured: ${error}`});
+                }
+                return resolve({ message: 'Email sent succesfully!'})
+            })
+        })
+    }
+
+    sendContactEmail = async (data) => {
+        return new Promise((resolve, reject) => {
+            let transport = nodemailer.createTransport(this.mailinfo.smtp);
+            const { $subject, $email, $message, $source } = data;
+
+            const options = {
+                from: $source,
+                to: this.email,
+                subject:"Contact Form :: " + $email,
+                text: $message,
+            }
+
+            transport.sendMail(options, (error, info) => {
+                console.log('send contact email resp :: ', error);
+                
+                if (error) return reject({ message: `An error has occured: ${error}`});
+                
+                return resolve({ message: 'Email sent succesfully!'})
+            })
+        })
+    }
+} 

package/libs/handler/async.js

@@ -0,0 +1,3 @@
+module.exports = (theFunc) => (req, res, next) => {
+  Promise.resolve(theFunc(req, res, next)).catch(next);
+};