@starklabs/backend-core 1.1.0 → 1.2.0

package/dist/js/core/auth/auth.service.js

@@ -0,0 +1,290 @@
+import registerModel from "../../lib/model.registry.js";
+import {
+  AppError,
+  hash,
+  verifyHash,
+  signJWT,
+  AppLog,
+} from "../../utils/index.js";
+import { getConfig } from "../../config/config.js";
+
+// custom imports
+import sendOTP from "./OTP.js";
+
+// signup
+const signup = async ({ body, Model, OTPModel }) => {
+  const foundUser = await Model.findOne({ email: body.email });
+  if (foundUser) {
+    if (foundUser.provider === "local")
+      throw new AppError(
+        "User with this email already exists. Please login.",
+        409,
+      );
+
+    if (foundUser.provider === "google")
+      throw new AppError(
+        "Please login with Google. User with this email already exists with Google provider.",
+        409,
+      );
+  }
+
+  const reqOTPUser = await OTPModel.findOne({ email: body.email });
+  if (reqOTPUser) throw new AppError("You already requested an OTP.");
+
+  const { OTP, otpExpiry } = await sendOTP(body.email);
+  if (getConfig().isOffline) {
+    console.log("OTP:", OTP);
+  }
+
+  const hashedPassword = await hash(body.password);
+  const hashedOTP = await hash(OTP);
+
+  body.password = hashedPassword;
+  body.role = "user";
+  body = { ...body, otp: hashedOTP, otpExpiry, provider: "local" };
+
+  await OTPModel.create(body);
+
+  return { msg: "OTP sent successfully" };
+};
+
+// twoFactorAuth
+const twoFactorAuth = async ({ body, Model, OTPModel }) => {
+  const { email, otp } = body;
+  const otpuser = await OTPModel.findOneAndUpdate(
+    { email },
+    { $inc: { otpCount: 1 } },
+    { returnDocument: "after" },
+  )
+    .select("+password")
+    .lean();
+
+  if (!otpuser)
+    throw new AppError(
+      "You didn't request OTP. Please try re-login, signup or check your email.",
+      409,
+    );
+
+  // ifExpire
+  if (Date.now() > otpuser.otpExpiry) {
+    throw new AppError("OTP expired. Please request another one.", 409);
+  }
+
+  // anti brute force
+  if (otpuser.otpCount >= 10)
+    throw new AppError(
+      "OTP verification limit reached. Please request another one.",
+      409,
+    );
+
+  // ifInValid
+  const isValid = await verifyHash(otp.toString(), otpuser.otp);
+  if (!isValid) throw new AppError("Invalid OTP", 409);
+
+  if (otpuser.type === "forgotPassword") {
+    await OTPModel.updateOne({ email }, { $set: { status: "verified" } });
+
+    return { msg: "Verified successfully" };
+  }
+
+  // insert in user
+  delete otpuser.otpExpiry;
+  delete otpuser.otp;
+  delete otpuser.otpCount;
+
+  const foundUser = await Model.findOne({ email });
+  if (!foundUser) {
+    await Model.create(otpuser);
+  }
+
+  [
+    "password",
+    "createdAt",
+    "updatedAt",
+    "__v",
+    "provider",
+    "type",
+    "status",
+  ].forEach((el) => {
+    delete otpuser[el];
+  });
+
+  const { jwtSecret, tokenExpiry, isOffline } = getConfig();
+  if (!jwtSecret) throw new AppError("jwtSecret is missing in StarkCore({})");
+  if (!tokenExpiry)
+    throw new AppError("jwtExpiry is missing in StarkCore.create({})");
+
+  const token = signJWT(
+    {
+      email: otpuser.email,
+      id: otpuser._id,
+      role: otpuser.role,
+    },
+    jwtSecret,
+    tokenExpiry,
+  );
+
+  await OTPModel.deleteOne({ email });
+
+  return { token, user: otpuser, msg: "Verified successfully" };
+};
+
+// resendOTP
+const resendOTP = async ({ body, OTPModel }) => {
+  const user = await OTPModel.findOne({ email: body.email });
+  if (!user)
+    throw new AppError(
+      "OTP can't be sent. Please try re-login or signup.",
+      409,
+    );
+
+  const { OTP, otpExpiry } = await sendOTP(body.email);
+  if (getConfig().isOffline) {
+    console.log("OTP: ", OTP);
+  }
+  const hashedOTP = await hash(OTP);
+
+  await OTPModel.updateOne(
+    { email: body.email },
+    {
+      otp: hashedOTP,
+      otpExpiry,
+      otpCount: 0,
+    },
+  );
+
+  return { msg: "OTP sent successfully" };
+};
+
+// login
+const login = async ({ body, Model, OTPModel }) => {
+  let user = await Model.findOne({ email: body.email })
+    .select("+password")
+    .lean();
+
+  const reqOTPUser = await OTPModel.findOne({ email: body.email });
+  if (reqOTPUser) throw new AppError("You already requested an OTP.");
+
+  if (!user)
+    throw new AppError(
+      "User with this email not found. Please create your account.",
+      404,
+    );
+
+  if (user.provider === "google")
+    throw new AppError(
+      "Please login with Google. User with this email already exists with Google provider.",
+      409,
+    );
+
+  const isValid = await verifyHash(body.password, user.password);
+  if (!isValid) throw new AppError("Invalid password", 409);
+
+  const { OTP, otpExpiry } = await sendOTP(body.email);
+  if (getConfig().isOffline) {
+    console.log("OTP: ", OTP);
+  }
+  const hashedOTP = await hash(OTP);
+
+  user = { ...user, otp: hashedOTP, otpExpiry };
+
+  await OTPModel.create(user);
+
+  return { msg: "OTP sent successfully" };
+};
+
+// forgotPassword
+const forgotPassword = async ({ body, Model, OTPModel }) => {
+  let user = await Model.findOne({ email: body.email })
+    .select("+password")
+    .lean();
+  if (!user)
+    throw new AppError(
+      "User with this email not found. Please create your account.",
+      404,
+    );
+
+  const reqOTPUser = await OTPModel.findOne({ email: body.email });
+  if (reqOTPUser) {
+    if (reqOTPUser.type === "forgotPassword") {
+      throw new AppError("You already requested an OTP");
+    } else {
+      await OTPModel.deleteOne({ email: body.email });
+    }
+  }
+
+  const { OTP, otpExpiry } = await sendOTP(body.email);
+  if (getConfig().isOffline) {
+    console.log("OTP: ", OTP);
+  }
+  const hashedOTP = await hash(OTP);
+
+  await OTPModel.create({
+    ...user,
+    otp: hashedOTP,
+    otpExpiry,
+    type: "forgotPassword",
+  });
+
+  return { msg: "OTP sent successfully" };
+};
+
+// resetPassword
+const resetPassword = async ({ body, Model, OTPModel }) => {
+  const { email, password } = body;
+
+  const otpUser = await OTPModel.findOne({ email: body.email });
+  if (!otpUser)
+    throw new AppError(
+      "You didn't requested OTP. Please send request to forgot-password.",
+    );
+
+  if (otpUser.type !== "forgotPassword")
+    throw new AppError("Unauthorized. Please request to forgot-password");
+
+  if (otpUser.status === "pending")
+    throw new AppError(
+      "You haven't verfied your email yet. Please use the OTP we just sent on your email",
+    );
+
+  let user = await Model.findOne({ email: body.email }).select("+password");
+  if (!user)
+    throw new AppError(
+      "User with this email not found. Please create your account.",
+      404,
+    );
+
+  user.password = await hash(body.password);
+
+  await user.save();
+
+  await OTPModel.deleteOne({ email });
+
+  return { msg: "Password updated successfully" };
+};
+
+const deleteAccount = async ({ body, Model }) => {
+  const { email, password } = body;
+
+  let user = await Model.findOne({ email }).select("+password").lean();
+
+  if (!user)
+    throw new AppError("User not found. Please check your email.", 404);
+
+  const isValid = await verifyHash(body.password, user.password);
+  if (!isValid) throw new AppError("Invalid password", 409);
+
+  await Model.deleteOne({ email });
+
+  return { msg: "Account deleted successfully" };
+};
+
+export default {
+  login,
+  signup,
+  twoFactorAuth,
+  resendOTP,
+  forgotPassword,
+  resetPassword,
+  deleteAccount,
+};

package/dist/js/core/auth/auth.validation.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { userIdSchema } from "../../utils/userIdValidation.js";
+
+const emailSchema = z
+  .string()
+  .trim()
+  .min(1, "Email is required")
+  .email("Invalid email");
+
+const passwordSchema = z
+  .string()
+  .min(12, "Password must be at least 12 characters");
+
+const providerSchema = z.string().min(1, "Provider is required");
+
+const nameSchema = (field) =>
+  z
+    .string()
+    .trim()
+    .min(1, `${field} is required`)
+    .min(3, `${field} must be at least 3 characters`)
+    .max(50, `${field} too long`);
+
+// signup schema
+const signupSchema = z
+  .object({
+    firstName: nameSchema("FirstName"),
+
+    lastName: nameSchema("LastName"),
+
+    email: emailSchema,
+
+    password: passwordSchema,
+
+    role: z.string().default("user"),
+  })
+  .strict();
+
+// 2fa schema
+const twoFactorAuthSchema = z
+  .object({
+    email: emailSchema,
+
+    otp: z.string().length(6, "OTP must be exactly 6 characters"),
+  })
+  .strict();
+
+// resend OTP schema
+const resendOTPSchema = z
+  .object({
+    email: emailSchema,
+  })
+  .strict();
+
+// login schema
+const loginSchema = z
+  .object({
+    email: emailSchema,
+    password: passwordSchema,
+  })
+  .strict();
+
+// forgot password schema
+const forgotPasswordSchema = z
+  .object({
+    email: emailSchema,
+  })
+  .strict();
+
+// reset password schema
+const resetPasswordSchema = z
+  .object({
+    email: emailSchema,
+    password: passwordSchema,
+  })
+  .strict();
+
+// logout schema
+const logoutSchema = z
+  .object({
+    email: emailSchema,
+    provider: providerSchema,
+    userId: userIdSchema,
+  })
+  .strict();
+
+export default {
+  loginSchema,
+  signupSchema,
+  twoFactorAuthSchema,
+  resendOTPSchema,
+  forgotPasswordSchema,
+  resetPasswordSchema,
+  logoutSchema,
+};

package/dist/js/core/crud/crud.controller.js

@@ -0,0 +1,95 @@
+import { app } from "../app.js";
+import mongoose, { model } from "mongoose";
+import asyncHandler from "../../utils/asyncHandler.js";
+import crudService from "./crud.service.js";
+import registerModel from "../../lib/model.registry.js";
+import AppError from "../../utils/AppError.js";
+import zodValidations from "../../lib/zod.validations.js";
+import z from "zod";
+import protect from "../../middleware/auth.middleware.js";
+
+const validateCookie = async (validations, user, isValidCookie) => {
+  const zodCookieObj = z.object(validations.cookieValidation);
+  isValidCookie = await zodCookieObj.safeParse(user);
+
+  if (!isValidCookie.success) {
+    const issue = isValidCookie.error.issues[0];
+    if (issue.code === "invalid_type")
+      throw new AppError(`${issue.path.join(".")} is required`);
+
+    throw new AppError(issue.message, 409);
+  }
+
+  return isValidCookie;
+};
+
+const crud = (route, routes, modelName, validations, apiVersion) => {
+  routes.forEach((el) => {
+    const middlewares = [];
+    if (el.method !== "get" || el.path !== "/") middlewares.push(protect);
+    if (el.middleware) middlewares.push(el.middleware);
+    if (el.middlewares) middlewares.push(...el.middlewares);
+
+    app[el.method](
+      `/api/v${apiVersion}/${route}${el.path}`,
+      ...middlewares,
+      asyncHandler(async (req, res) => {
+        const Model = registerModel[modelName];
+        if (!Model && el.modelName)
+          throw new Error(`Model not found for endpoint: ${el.path}`);
+
+        // if not getAll and cookie - validation
+        let isValidCookie = undefined;
+        if (el.method !== "get" || el.path !== "/") {
+          isValidCookie = await validateCookie(
+            validations,
+            req.user,
+            isValidCookie,
+          );
+        }
+
+        // req.body - validation
+        const payload = {
+          ...req.body,
+          image: req.file,
+        };
+
+        const validationObj =
+          validations && validations[el.handler]
+            ? z.object(validations[el.handler])
+            : z.object({});
+
+        const zodBodyObj = validationObj;
+
+        const isValidBody = zodBodyObj.safeParse(payload || {});
+
+        if (!isValidBody.success) {
+          const issue = isValidBody.error.issues[0];
+          if (issue.code === "invalid_type")
+            throw new AppError(`${issue.path.join(".")} is required`);
+
+          throw new AppError(issue.message, 409);
+        }
+
+        // send data to service
+        const result = await crudService[el.handler]({
+          Model,
+          modelName,
+          body: isValidBody?.data,
+          userData: isValidCookie?.data,
+          id: req?.params?.id,
+          fileType: el?.fileType,
+          metaDataName: el?.metaDataName,
+        });
+
+        return res.json({
+          success: true,
+          data: result?.data,
+          message: result?.msg,
+        });
+      }),
+    );
+  });
+};
+
+export default crud;