@feardread/fear 1.0.1

package/libs/handler/error.js

@@ -0,0 +1,66 @@
+
+
+exports.AppError = class AppError extends Error {
+    constructor( message,  statusCode ) {
+        super(message);
+        this.statusCode = statusCode;
+      }
+}
+
+/*
+  Catch Errors Handler
+
+  With async/await, you need some way to catch errors
+  Instead of using try{} catch(e) {} in each controller, we wrap the function in
+  catchErrors(), catch any errors they throw, and pass it along to our express middleware with next()
+*/
+exports.tryCatch = (fn) => {
+    return function (req, res, next) {
+      const resp = fn(req, res, next);
+      if (resp instanceof Promise) {
+        return resp.catch(next);
+      }
+      return next(resp);
+    };
+};
+  
+  /*
+    Not Found Error Handler
+  
+    If we hit a route that is not found, we mark it as 404 and pass it along to the next error handler to display
+  */
+exports.notFound = (req, res, next) => {
+    res.status(404).json({
+      success: false,
+      message: "Api url doesn't exist ",
+    });
+};
+  
+  /*
+    Development Error Handler
+  
+    In development we show good error messages so if we hit a syntax error or any other previously un-handled error, we can show good info on what happened
+  */
+exports.development = (err, req, res, next) => {
+    err.stack = err.stack || "";
+    const errorDetails = {
+      message: err.message,
+      status: err.status,
+      stackHighlighted: err.stack.replace(
+        /[a-z_-\d]+.js:\d+:\d+/gi,
+        "<mark>$&</mark>"
+      ),
+    };
+    console.log("Error Details = ", err);
+    res.status(500).json({ success: false, errorDetails });
+  };
+  
+  /*
+    Production Error Handler
+  
+    No stacktraces are leaked to admin
+  */
+exports.production = (err, req, res, next) => {
+    res.status(500).json({ success: false, message: "Oops ! Error in Server" });
+};
+  

package/libs/handler/index.js

@@ -0,0 +1,161 @@
+/**
+ * Custom Application Error class
+ * Extends the built-in Error class with HTTP status codes
+ */
+class AppError extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.isOperational = true; // Distinguishes operational errors from programming errors
+    
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * Async Error Handler Wrapper
+ * Wraps async route handlers to automatically catch and forward errors
+ * @param {Function} asyncFn - The async function to wrap
+ * @returns {Function} Express middleware function
+ */
+const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};
+
+/**
+ * 404 Not Found Handler
+ * Handles requests to non-existent routes
+ */
+const notFoundHandler = (req, res, next) => {
+  const error = new AppError(`Route ${req.originalUrl} not found`, 404);
+  next(error);
+};
+
+const successResponse = (res, obj) => {3
+  const strip = (text) => text.replace(/\x1b\[[0-9;]*m/g, '')
+
+  if (obj.output) {
+    obj.output = strip(obj.output);
+  }
+
+  return res.status(200).json(obj);
+
+}
+/**
+ * Development Error Handler
+ * Provides detailed error information for debugging
+ */
+const developmentErrorHandler = (err, req, res, next) => {
+  const statusCode = err.statusCode || 500;
+  
+  console.error('Error Details:', {
+    message: err.message,
+    stack: err.stack,
+    url: req.originalUrl,
+    method: req.method,
+    ip: req.ip,
+    userAgent: req.get('User-Agent')
+  });
+
+  const response = {
+    success: false,
+    error: {
+      message: err.message,
+      statusCode,
+      stack: err.stack,
+      details: {
+        url: req.originalUrl,
+        method: req.method,
+        timestamp: new Date().toISOString()
+      }
+    }
+  };
+
+  res.status(statusCode).json(response);
+};
+
+/**
+ * Production Error Handler
+ * Provides sanitized error responses for production
+ */
+const productionErrorHandler = (err, req, res, next) => {
+  const statusCode = err.statusCode || 500;
+  
+  // Log error details for monitoring (but don't expose to client)
+  console.error('Production Error:', {
+    message: err.message,
+    stack: err.stack,
+    url: req.originalUrl,
+    method: req.method,
+    ip: req.ip,
+    timestamp: new Date().toISOString()
+  });
+
+  let message = 'Internal Server Error';
+  
+  // Only expose operational errors to clients
+  if (err.isOperational) {
+    message = err.message;
+  }
+  
+  // Handle specific error types
+  if (statusCode === 404) {
+    message = 'Resource not found';
+  } else if (statusCode === 401) {
+    message = 'Unauthorized access';
+  } else if (statusCode === 403) {
+    message = 'Forbidden';
+  } else if (statusCode === 400) {
+    message = err.message; // Usually safe to expose validation errors
+  }
+
+  const response = {
+    success: false,
+    error: {
+      message,
+      statusCode
+    }
+  };
+
+  res.status(statusCode).json(response);
+};
+
+/**
+ * Global Error Handler
+ * Determines which error handler to use based on environment
+ */
+const globalErrorHandler = (err, req, res, next) => {
+  // Handle specific error types
+  if (err.name === 'ValidationError') {
+    err.statusCode = 400;
+    err.isOperational = true;
+  } else if (err.name === 'CastError') {
+    err.statusCode = 400;
+    err.message = 'Invalid ID format';
+    err.isOperational = true;
+  } else if (err.code === 11000) {
+    // MongoDB duplicate key error
+    err.statusCode = 400;
+    err.message = 'Duplicate field value';
+    err.isOperational = true;
+  }
+
+  if (process.env.NODE_ENV === 'development') {
+    developmentErrorHandler(err, req, res, next);
+  } else {
+    productionErrorHandler(err, req, res, next);
+  }
+};
+
+module.exports = {
+  error: () => new AppError,
+  success: successResponse,
+  global: globalErrorHandler,
+  production: productionErrorHandler,
+  development: developmentErrorHandler,
+  async: asyncHandler,
+  notFound: notFoundHandler
+}

package/libs/logger/index.js

@@ -0,0 +1,49 @@
+const winston = require('winston');
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4,
+}
+const level = () => {
+  const env = process.env.NODE_ENV || 'development'
+  const isDevelopment = env === 'development'
+  return isDevelopment ? 'debug' : 'warn'
+}
+const colors = {
+  error: 'red',
+  warn: 'yellow',
+  info: 'green',
+  http: 'magenta',
+  debug: 'white',
+}
+
+winston.addColors(colors)
+
+const format = winston.format.combine(
+  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+  winston.format.colorize({ all: true }),
+  winston.format.printf(
+    (info) => `${info.timestamp} ${info.level}: ${info.message}`,
+  ),
+)
+
+
+const transports = [
+  new winston.transports.Console(),
+ // new winston.transports.File({
+   // filename: 'logs/error.log',
+  //  level: 'error',
+ // }),
+ // new winston.transports.File({ filename: 'logs/all.log' }),
+]
+
+const logger = winston.createLogger({
+  level: level(),
+  levels,
+  format,
+  transports,
+})
+
+module.exports = logger

package/libs/logger/morgan.js

@@ -0,0 +1,24 @@
+const morgan = require("morgan");
+const logger = require("../logger");
+
+const stream = {
+  write: (message) => logger.http(message),
+};
+
+const skip = () => {
+  const env = process.env.NODE_ENV || "development";
+  return env !== "development";
+};
+
+const middleware = morgan(
+  // Define message format string (this is the default one).
+  // The message format is made from tokens, and each token is
+  // defined inside the Morgan library.
+  // You can create your custom token to show what do you want from a request.
+  ":remote-addr :method :url :status :res[content-length] - :response-time ms",
+  // Options: in this case, I overwrote the stream and the skip logic.
+  // See the methods above.
+  { stream, skip }
+);
+
+module.exports = middleware;

package/libs/passport/passport.js

@@ -0,0 +1,109 @@
+// needed for local authentication
+const passport = require("passport");
+const LocalStrategy = require("passport-local").Strategy;
+const FacebookStrategy = require("passport-facebook").Strategy;
+const secret = require("../config/secret");
+const User = require("../models/user");
+const async = require("async");
+const Cart = require("../models/cart");
+
+// serialize and deserialize
+passport.serializeUser((user, done) => {
+  done(null, user);
+});
+
+passport.deserializeUser((id, done) => {
+  User.findById(id, (err, user) => {
+    done(err, user);
+  });
+});
+
+// custom function validate
+exports.isAuthenticated = (req, res, next) => {
+  if (req.isAuthenticated()) {
+    return next();
+  }
+  res.redirect("/login");
+};
+// give the middleware a name, and create a new anonymous instance of LocalStrategy
+passport.use(
+  "login",
+  new LocalStrategy(
+    {
+      usernameField: "email",
+      passwordField: "password",
+      passReqToCallback: true,
+    },
+    (req, email, password, done) => {
+      // find a specific email
+      User.findOne({ email: email }, (err, user) => {
+        // incase of an error return a callback
+        if (err) return done(err);
+
+        if (!user) {
+          return done(
+            null,
+            false,
+            req.flash("loginMessage", "No user with such credentials found")
+          );
+        }
+
+        // compare user provided password and the database one
+        if (!user.comparePassword(password)) {
+          return done(
+            null,
+            false,
+            req.flash("loginMessage", "Oops! Wrong credentials")
+          );
+        }
+
+        // return user object
+        return done(null, user);
+      });
+    }
+  )
+);
+
+passport.use(
+  new FacebookStrategy(
+    secret.facebook,
+    (token, refreshToken, profile, done) => {
+      User.findOne({ facebook: profile.id }, (err, user) => {
+        if (err) return next(err);
+
+        if (user) {
+          return done(null, user);
+        } else {
+          async.waterfall([
+            (callback) => {
+              const newUser = new User();
+              newUser.email = profile._json.email;
+              newUser.facebook = profile.id;
+              newUser.tokens.push({ kind: "facebook", token: token });
+              newUser.profile.name = profile.displayName;
+              newUser.profile.picture =
+                "https://graph.facebook.com/" +
+                profile.id +
+                "/picture?type=large";
+
+              newUser.save((err) => {
+                if (err) return next(err);
+                callback(err, newUser._id);
+              });
+            },
+            (newUser) => {
+              const cart = new Cart();
+
+              cart.owner = newUser._id;
+              cart.save((err) => {
+                if (err) return done(err);
+                return done(err, newUser);
+              });
+            },
+          ]);
+        }
+      });
+    }
+  )
+);
+