Merge branch 'main' of https://github.com/codeaashu/DevDisplay

Author: codeaashu

.gitignore

@@ -1,15 +1,15 @@
 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
 # dependencies
-/node_modules
-/.pnp
+node_modules
+.pnp
 .pnp.js
 
 # testing
-/coverage
+coverage
 
 # production
-/build
+build
 
 # misc
 .DS_Store

backend/constants.js

@@ -0,0 +1,23 @@
+const Constants = {
+  PORT: process.env.PORT || 5000,
+  ORIGIN_URL: process.env.ORIGIN_URL || 'http://localhost:3000',
+  MONGODB_URL: process.env.MONGODB_URL || 'mongodb://localhost:27017/devdisplay',
+  JSON_LIMIT: '50mb',
+  ENV: process.env.NODE_ENV || 'development',
+  API_BASE: '/api/v1',
+  SALT_ROUNDS: 10,
+
+  // constraints
+  USERNAME_MINLEN: 3,
+  USERNAME_MAXLEN: 20,
+  FULLNAME_MAXLEN: 30,
+  FULLNAME_MINLEN: 2,
+  BIO_MAXLEN: 200,
+
+  // JWT
+  JWT_ALGORITHM: 'ES256',
+  REFRESH_TOKEN_MAXAGE: 60 * 60 * 24 * 7, // 1 week
+  ACCESS_TOKEN_MAXAGE: 60 * 20, // 20 minutes
+};
+
+export default Constants;

backend/database/connectToDatabase.js

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+import CONSTANTS from '../constants.js';
+
+async function connectToDatabase() {
+  try {
+    const uri = CONSTANTS.MONGODB_URL;
+    const { connection } = await mongoose.connect(uri);
+    if(CONSTANTS.ENV === 'development') {
+      console.log(`🗄️  Connected to: ${uri}`);
+    }
+    console.info(`⚙️  MongoDB connected, DB HOST: ${connection.host}`);
+  } catch (error) {
+    console.error("⚠️  Error connecting to the database:", error);
+    process.exit(1);
+  }
+}
+
+export default connectToDatabase;

backend/database/models/User.model.js

@@ -0,0 +1,61 @@
+import { Schema, model } from 'mongoose';
+import Constants from '../../constants.js';
+
+const UserSchema = new Schema({
+  // credentials
+  username: {
+    type: String,
+    required: [true, "Username is a required field"],
+    unique: true,
+    index: true,
+    trim: true,
+    minlength: Constants.USERNAME_MINLEN,
+    maxlength: Constants.USERNAME_MAXLEN,
+  },
+  email: {
+    type: String,
+    required: [true, "Email is a required field"],
+    unique: true,
+    trim: true,
+    index: true,
+  },
+  passwordHash: {
+    type: String,
+    required: [true, "Password is a required field"],
+  },
+
+  // profile
+  fullName: {
+    type: String,
+    required: [true, "Full name is a required field"],
+    trim: true,
+    minlength: Constants.FULLNAME_MINLEN,
+    maxlength: Constants.FULLNAME_MAXLEN,
+  },
+  location: {
+    type: String,
+    trim: true
+  },
+  bio: {
+    type: String,
+    trim: true,
+    maxlength: Constants.BIO_MAXLEN
+  },
+  avatar: { type: String },
+  portfolio: { type: String },
+  skills: [{ type: String, trim: true }],
+  social: {
+    GitHub: { type: String },
+    LinkedIn: { type: String },
+    Twitter: { type: String },
+    Instagram: { type: String },
+  },
+
+  // meta
+  emailVerified: { type: Boolean, default: false },
+  refreshToken: { type: String },
+}, {
+  timestamps: true,
+});
+
+export default model('User', UserSchema);

backend/helpers/ApiError.js

@@ -0,0 +1,24 @@
+// API error helper functions
+import { errorResponse } from './ApiResponse.js';
+
+const badRequest = (message, error) => errorResponse(400, message, error);
+const validationError = (message, error) => errorResponse(400, message, error);
+const semanticError = (message, error) => errorResponse(422, message, error);
+const unauthorized = (message, error) => errorResponse(401, message, error);
+const forbidden = (message, error) => errorResponse(403, message, error);
+const notFound = (message, error) => errorResponse(404, message, error);
+const conflict = (message, error) => errorResponse(409, message, error);
+const internalServerError = (message, error) => errorResponse(500, message, error);
+const unsupportedMediaType = (message, error) => errorResponse(415, message, error);
+
+export {
+  badRequest,
+  unauthorized,
+  forbidden,
+  notFound,
+  conflict,
+  internalServerError,
+  validationError,
+  semanticError,
+  unsupportedMediaType,
+};

backend/helpers/ApiResponse.js

@@ -0,0 +1,69 @@
+// standardized API response format
+import Constants from "../constants.js";
+
+class ApiResponse {
+  constructor(status, message, data = null, errorType = 'UNSPECIFIED', error = null) {
+    this.success = status < 300 ? true : false; // Boolean value indicating whether the request was successful or not
+    this.message = message, // Brief description of the result
+    this.data = data || null, // Contains the actual response data (if any)
+    this.status = status || 200 // HTTP status code
+
+    // If the environment is development, include the error details in the response
+    // POLICY DECISION ?? Only include error details in response if in development mode
+    if(!this.success) {
+      this.error = Constants.ENV === 'development' ? error : null;
+      this.errorType = Constants.ENV === 'development' ? errorType : null;
+    }
+
+    // Log the response details to the console
+    // DEVELOPMENT ONLY
+    if (Constants.ENV === 'development') {
+      console.log("[API RESPONSE START]");
+      console.log(`[API RESPONSE] ${this.success ? 'SUCCESS' : 'FAILURE'}`);
+      console.log(`[API RESPONSE] STATUS: ${this.status}`);
+      console.log(`[API RESPONSE] MESSAGE: ${this.message}`);
+      console.log("[API RESPONSE] DATA:-");
+      console.dir(this.data);
+      if(!this.success) {
+        console.log("[API RESPONSE] ERROR:-");
+        console.dir(this.error);
+        console.log(`[API RESPONSE] ERROR TYPE: ${this.errorType}`);
+      }
+      console.log(`[API RESPONSE] TIMESTAMP: ${new Date().toISOString()}`);
+      console.log("[API RESPONSE END]");
+    }
+  }
+}
+
+// Helper functions to send API responses
+/** successResponse(res, data, message) => void */
+const successResponse = (res, data, message) => {
+  res.status(200).json(new ApiResponse(200, message, data));
+}
+
+/** successResponseWithCookies(res, data, message, cookies) => void */
+const successResponseWithCookies = (res, data, message, cookies) => {
+  const options = { httpOnly: true, secure: true, sameSite: "strict" };
+
+  if(cookies) {
+    if(cookies.accessToken) {
+      res
+      .status(200)
+      .cookie("accessToken", cookies.accessToken, options)
+      .json(new ApiResponse(200, message, data));
+    }
+    if(cookies.refreshToken) {
+      res
+      .status(200)
+      .cookie("refreshToken", cookies.refreshToken, options)
+      .json(new ApiResponse(200, message, data));
+    }
+  }
+}
+
+/** errorResponse(res, status, message, errorType, error) => void */
+const errorResponse = (res, status, message, errorType, error) => {
+  res.status(status).json(new ApiResponse(status, message, null, errorType, error));
+}
+
+export { successResponse, errorResponse, successResponseWithCookies };

backend/helpers/AsyncHandler.js

@@ -0,0 +1,12 @@
+// a promise block wrapper, helps to reduce the try-catch blocks in controllers
+// also standardizes the error handling by forwarding the error to the error-handling middleware
+
+const asyncHandler = (fn) => {
+  return (req, res, next) => {
+    Promise
+      .resolve(fn(req, res, next)) // converts the sync function into a async promise
+      .catch((err) => next(err)); // pass the error to the error-handling middleware
+  };
+};
+
+export default asyncHandler;