@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/addUserStatusFields-7-66sf45.cjs

@@ -1,86 +0,0 @@
-"use strict";
-const mongoose = require("mongoose");
-const addMembersQuantity = (user) => {
-  return {
-    $addFields: {
-      numberOfSubscribers: {
-        $size: {
-          $filter: {
-            input: "$memberships",
-            as: "membership",
-            cond: { $eq: ["$$membership.role", "subscriber"] }
-          }
-        }
-      },
-      numberOfMembers: {
-        $size: {
-          $filter: {
-            input: "$memberships",
-            as: "membership",
-            cond: { $not: { $in: ["$$membership.role", ["blocked", "subscriber"]] } }
-          }
-        }
-      }
-    }
-  };
-};
-const ObjectId = { Types: mongoose.Types }.Types.ObjectId;
-const addUserStatusFields = (user) => {
-  return {
-    $addFields: {
-      isSubscriber: {
-        $cond: [
-          {
-            $anyElementTrue: {
-              $map: {
-                input: "$memberships",
-                as: "membership",
-                in: {
-                  $and: [{ $eq: ["$$membership.user", new ObjectId(user)] }, { $eq: ["$$membership.role", "subscriber"] }]
-                }
-              }
-            }
-          },
-          true,
-          false
-        ]
-      },
-      isMember: {
-        $cond: [
-          {
-            $anyElementTrue: {
-              $map: {
-                input: "$memberships",
-                as: "membership",
-                in: {
-                  $and: [{ $eq: ["$$membership.user", new ObjectId(user)] }, { $not: [{ $in: ["$$membership.role", ["subscriber", "blocked"]] }] }]
-                }
-              }
-            }
-          },
-          true,
-          false
-        ]
-      },
-      isBlocked: {
-        $cond: [
-          {
-            $anyElementTrue: {
-              $map: {
-                input: "$memberships",
-                as: "membership",
-                in: {
-                  $and: [{ $eq: ["$$membership.user", new ObjectId(user)] }, { $eq: ["$$membership.role", "blocked"] }]
-                }
-              }
-            }
-          },
-          true,
-          false
-        ]
-      }
-    }
-  };
-};
-exports.addMembersQuantity = addMembersQuantity;
-exports.addUserStatusFields = addUserStatusFields;

package/dist/auth.server.cjs

@@ -1,529 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const profile_schema = require("./profile.schema-l0Dk4Ptu.cjs");
-const index = require("./index-BFxqqmgh.cjs");
-const bcrypt = require("bcryptjs");
-const jwt = require("jsonwebtoken");
-const mongoose = require("mongoose");
-const jwkToPem = require("jwk-to-pem");
-const mailing = require("./mailing-DCvDBHVh.cjs");
-const addUserStatusFields = require("./addUserStatusFields-7-66sf45.cjs");
-const credentials_schema = require("./credentials.schema-DVXaFnXl.cjs");
-const socials_schema = require("./socials.schema-CqEHax2w.cjs");
-async function verifyAppleIdToken(id_token) {
-  const decodedToken = jwt.decode(id_token, { complete: true });
-  if (!decodedToken) {
-    throw new Error("Failed to decode token.");
-  }
-  if (decodedToken.payload.iss !== "https://appleid.apple.com") {
-    throw new Error("Invalid issuer.");
-  }
-  if (decodedToken.payload.aud !== process.env.APPLE_CLIENTID) {
-    throw new Error("Invalid audience.");
-  }
-  const currentTimestamp = Math.floor(Date.now() / 1e3);
-  if (currentTimestamp > decodedToken.payload.exp) {
-    throw new Error("Token has expired.");
-  }
-  const applePublicKeys = await fetch("https://appleid.apple.com/auth/keys").then((response) => response.json()).catch((err) => {
-    throw new Error("Failed to fetch Apple public keys.");
-  });
-  const appleKey = applePublicKeys.keys.find((key) => key.kid === decodedToken.header.kid);
-  if (!appleKey) {
-    throw new Error("Invalid token key ID.");
-  }
-  const pem = jwkToPem(appleKey);
-  try {
-    jwt.verify(id_token, pem, {
-      algorithms: ["RS256"],
-      issuer: "https://appleid.apple.com"
-    });
-  } catch (err) {
-    console.log(err);
-    throw new Error("Token signature verification failed.");
-  }
-  return decodedToken.payload;
-}
-const ObjectId$1 = { Types: mongoose.Types }.Types.ObjectId;
-const controllerFactory$2 = (db) => {
-  const User = db.user;
-  const Membership = db.membership;
-  db.department;
-  db.organization;
-  const Invite = db.invite;
-  const Role = db.role;
-  const signin = async (req, res) => {
-    const { type, email, phone, authorization } = req.body;
-    let query;
-    let payload = null;
-    if (type === "phone" && phone) {
-      query = { phone };
-    }
-    if (type === "email" && email) {
-      query = { email };
-    }
-    if (type === "apple" && authorization.id_token) {
-      payload = await verifyAppleIdToken(authorization.id_token);
-      if (payload) {
-        query = { apple_id: payload.sub };
-      } else {
-        return res.status(401).send({ errorCode: "INVALID_APPLE_ID_TOKEN" });
-      }
-    }
-    try {
-      let user = await User.findOne(query).populate("roles").exec();
-      if (type !== "apple" && !user) {
-        return res.status(404).send({ errorCode: "USER_NOT_FOUND" });
-      }
-      if (type === "apple" && !user) {
-        const { firstName, lastName } = req.body.user.name;
-        const newUser = new User({
-          apple_id: payload.sub,
-          email: payload.email,
-          profile: { name: `${firstName} ${lastName}` }
-        });
-        await newUser.save();
-        user = newUser;
-      } else if (!user) {
-        return res.status(404).send({ errorCode: "USER_NOT_FOUND" });
-      }
-      if (type === "email" || type === "phone") {
-        const passwordIsValid = bcrypt.compareSync(req.body.password, user.password);
-        if (!passwordIsValid) {
-          return res.status(401).send({ errorCode: "INCORRECT_PASSWORD_ENTERED", accessToken: null });
-        }
-      }
-      const token = jwt.sign(
-        {
-          _id: user._id
-        },
-        process.env.SECRET_KEY,
-        {
-          expiresIn: 864e3
-        }
-      );
-      const authorities = user.roles.map((role) => `ROLE_${role.name.toUpperCase()}`);
-      res.status(200).send({
-        _id: user._id,
-        username: user.username,
-        avatar: user.profile.photo,
-        phone: user.phone,
-        email: user.email,
-        roles: authorities,
-        accessToken: token
-      });
-    } catch (err) {
-      console.error(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const signup = async (req, res) => {
-    const { type, email, phone, inviteCode } = req.body;
-    let invite = null;
-    if (inviteCode) {
-      try {
-        invite = await Invite.findOne({ code: inviteCode, status: "active" });
-        if (!invite) {
-          return res.status(400).json({ errorCode: "INVALID_INVITATION_CODE" });
-        }
-      } catch (err) {
-        return res.status(500).send({ message: err });
-      }
-    }
-    let userData = {
-      password: bcrypt.hashSync(req.body.password, 8)
-    };
-    if (type === "email") {
-      userData.email = email;
-    } else if (type === "phone") {
-      userData.phone = phone;
-    }
-    const user = new User(userData);
-    try {
-      await user.save();
-    } catch (err) {
-      console.log(err);
-      return res.status(500).send({ message: err });
-    }
-    try {
-      const role = await Role.findOne({ name: "user" });
-      user.roles = [role._id];
-      await user.save();
-    } catch (err) {
-      console.log(err);
-      return res.status(500).send({ message: err });
-    }
-    if (invite) {
-      invite.status = "used";
-      await invite.save();
-      const newMembership = new Membership({
-        type: "organization",
-        user: new ObjectId$1(user._id),
-        target: new ObjectId$1(invite.owner.target),
-        role: invite.role,
-        label: invite.role
-      });
-      try {
-        await newMembership.save();
-      } catch (err) {
-        console.log(err);
-      }
-    }
-    const token = jwt.sign(
-      {
-        _id: user._id,
-        organization: invite ? invite.organization : null
-      },
-      process.env.SECRET_KEY,
-      {
-        expiresIn: 86400
-      }
-    );
-    res.status(200).send({
-      _id: user._id,
-      phone: user.phone,
-      email: user.email,
-      accessToken: token,
-      organization: {
-        _id: invite ? invite.organization : null
-      }
-    });
-  };
-  const updatePassword = async (req, res) => {
-    try {
-      const { phone, email, password, type } = req.body;
-      let query;
-      if (type === "phone" && phone) {
-        query = { phone };
-      }
-      if (type === "email" && email) {
-        query = { email };
-      }
-      if (!query || !password) {
-        return res.status(400).send({ errorCode: "MISSING_REQUIRED_PARAMETERS" });
-      }
-      const salt = await bcrypt.genSalt(8);
-      const hashedPassword = await bcrypt.hash(password, salt);
-      const user = await User.findOneAndUpdate(query, {
-        password: hashedPassword
-      }).populate("roles").exec();
-      if (!user) {
-        return res.status(404).send({ errorCode: "ERROR_UPDATING_USER" });
-      }
-      const token = jwt.sign({ _id: user._id }, process.env.SECRET_KEY, {
-        expiresIn: 86400
-      });
-      const authorities = user.roles.map((role) => `ROLE_${role.name.toUpperCase()}`);
-      return res.status(200).send({
-        _id: user._id,
-        username: user.username,
-        avatar: user.profile.photo,
-        phone: user.phone,
-        email: user.email,
-        roles: authorities,
-        accessToken: token
-      });
-    } catch (err) {
-      return res.status(500).send({ message: err.message });
-    }
-  };
-  return {
-    signin,
-    signup,
-    updatePassword
-  };
-};
-const { sendEmail, sendSms } = mailing.mailing;
-const controllerFactory$1 = (db) => {
-  const sendcode = async (req, res) => {
-    const code = Math.floor(1e3 + Math.random() * 9e3);
-    const type = req.body.type;
-    const method = req.body.method;
-    if (type === "email") {
-      const emailSent = await sendEmail(req.body.email, `${process.env.APP_NAME} Verification Code`, `Your ${process.env.APP_NAME} verification code is ${code}`);
-      if (emailSent) {
-        res.send({ code, type, method });
-      } else {
-        console.log(emailSent);
-        res.status(500).send("Failed to send email");
-      }
-    } else if (type === "phone") {
-      const smsSent = await sendSms(req.body.phone, `Your ${process.env.APP_NAME} verification code: ${code}`);
-      if (smsSent) {
-        res.send({ code, type, method });
-      } else {
-        res.status(500).send("Failed to send SMS");
-      }
-    }
-  };
-  return {
-    sendcode
-  };
-};
-const authRoutes = (function(app, db, origins) {
-  const controller = controllerFactory$2(db);
-  const controllerTwofa = controllerFactory$1();
-  const { verifySignUp, verifyUser } = index.middlewareIndexFactory(db);
-  app.post(
-    "/api/auth/signup",
-    [
-      verifySignUp.checkDuplicateUsernameOrEmail
-      // verifySignUp.checkRolesExisted
-    ],
-    controller.signup
-  );
-  app.post("/api/auth/signin", controller.signin);
-  app.post("/api/auth/reset-password", [verifyUser.checkUserExist], controllerTwofa.sendcode);
-  app.post("/api/auth/update-password", controller.updatePassword);
-});
-const twofaRoutes = (function(app, db) {
-  const controller = controllerFactory$1();
-  const { verifySignUp, verifyUser } = index.middlewareIndexFactory(db);
-  app.post("/api/twofa/sendcode", [verifySignUp.checkDuplicateUsernameOrEmail], controller.sendcode);
-  app.post("/api/twofa/sendcodereset", [verifyUser.checkUserExist], controller.sendcode);
-});
-const ObjectId = { Types: mongoose.Types }.Types.ObjectId;
-const controllerFactory = (db) => {
-  const User = db.user;
-  const read = async (req, res) => {
-    let query = [];
-    let skip = parseInt(req.query.skip) || 0;
-    let limit = parseInt(req.query.limit) || 10;
-    let matchConditions = [];
-    if (req.query._id) {
-      const isValidObjectId = ObjectId.isValid(req.query._id);
-      if (isValidObjectId) {
-        matchConditions.push({ _id: new ObjectId(req.query._id) });
-      } else {
-        matchConditions.push({ username: req.query._id });
-      }
-    }
-    let search = req.query.search;
-    if (search) {
-      let regexPattern = "";
-      const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      if (escapedSearch.includes("@")) {
-        regexPattern = escapedSearch;
-      } else if (escapedSearch.match(/^\+?\d{0,14}$/)) {
-        regexPattern = escapedSearch;
-      } else {
-        regexPattern = `.*${escapedSearch}.*`;
-      }
-      matchConditions.push({
-        $or: [
-          { "profile.name": { $regex: regexPattern, $options: "i" } },
-          { email: { $regex: regexPattern, $options: "i" } },
-          { phone: { $regex: regexPattern, $options: "i" } },
-          { username: { $regex: regexPattern, $options: "i" } }
-        ]
-      });
-    }
-    if (matchConditions.length > 0) query.push({ $match: { $and: matchConditions } });
-    query.push({
-      $lookup: {
-        from: "orders",
-        localField: "_id",
-        foreignField: "user",
-        as: "orders"
-      }
-    });
-    query.push({
-      $lookup: {
-        from: "roles",
-        localField: "roles",
-        foreignField: "_id",
-        as: "roles"
-      }
-    });
-    query.push({
-      $lookup: {
-        from: "memberships",
-        localField: "_id",
-        foreignField: "target",
-        as: "memberships"
-      }
-    });
-    query.push(addUserStatusFields.addMembersQuantity());
-    if (req.query.user) query.push(addUserStatusFields.addUserStatusFields(req.query.user));
-    query.push({
-      $skip: skip
-    });
-    query.push({
-      $limit: limit
-    });
-    try {
-      const users = await User.aggregate(query);
-      if (!users) {
-        return res.status(404).send({ message: "Users not found." });
-      }
-      res.status(200).send(users);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const newUser = {
-        phone: req.body.phone,
-        email: req.body.email,
-        roles: req.body.roles ? req.body.roles : []
-      };
-      const user = await User.create(newUser);
-      if (!user) {
-        return res.status(404).send({ errorCode: "USER_NOT_CREATED", message: "User is not created." });
-      }
-      res.status(200).send(user);
-    } catch (err) {
-      return res.status(500).send({ errorCode: "INTERNAL_SERVER_ERROR", message: err });
-    }
-  };
-  const update = async (req, res) => {
-    try {
-      const user = await User.findOneAndUpdate({ _id: req.params._id }, req.body, { new: true });
-      if (!user) {
-        return res.status(404).send({ errorCode: "UPDATE_FAILED", message: "Something wrong when updating user." });
-      }
-      res.status(200).send(user);
-    } catch (err) {
-      return res.status(500).send({ errorCode: "INTERNAL_SERVER_ERROR", message: err });
-    }
-  };
-  const remove = async (req, res) => {
-    try {
-      const user = await User.findOneAndDelete({ phone: req.params.phone });
-      if (!user) {
-        return res.status(404).send({ errorCode: "DELETION_FAILED", message: "User is not deleted." });
-      }
-      res.status(200).send(user);
-    } catch (err) {
-      return res.status(500).send({ errorCode: "INTERNAL_SERVER_ERROR", message: err });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    remove
-  };
-};
-const usersRoutes = (function(app, db, origins) {
-  const controller = controllerFactory(db);
-  const { authJwt, verifyUser } = index.middlewareIndexFactory(db);
-  app.post("/api/users", [authJwt.verifyToken(), verifyUser.checkDuplicateUsername], controller.create);
-  app.get("/api/users", controller.read);
-  app.put("/api/users/:_id", [authJwt.verifyToken(), verifyUser.checkDuplicateUsername], controller.update);
-  app.delete("/api/users/:_id", [authJwt.verifyToken()], controller.remove);
-});
-const RequestModel = (db) => {
-  const RequestSchema = new db.mongoose.Schema({
-    visitor: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Visitor"
-    },
-    path: String,
-    method: String,
-    timestamp: { type: Date, default: Date.now }
-  });
-  RequestSchema.index({ visitor: 1 });
-  const Request = db.mongoose.model("Request", RequestSchema);
-  return Request;
-};
-const RoleModel = (db) => {
-  const RoleSchema = new db.mongoose.Schema({
-    name: String
-  });
-  const Role = db.mongoose.model("Role", RoleSchema);
-  return Role;
-};
-const UserModel = (db) => {
-  const UserSchema = new db.mongoose.Schema(
-    {
-      username: {
-        type: String,
-        sparse: true,
-        unique: true
-      },
-      password: {
-        type: String,
-        required: true
-      },
-      status: {
-        type: String,
-        enum: ["active", "banned", "removed", "inactive"],
-        default: "active",
-        required: true
-      },
-      birthday: {
-        type: Date,
-        default: null
-      },
-      roles: [
-        {
-          type: db.mongoose.Schema.Types.ObjectId,
-          ref: "Role"
-        }
-      ]
-    },
-    {
-      // Creation Date
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    }
-  );
-  profile_schema.applyProfileSchema(UserSchema);
-  socials_schema.applySocialsSchema(UserSchema);
-  credentials_schema.applyCredentialsSchema(UserSchema);
-  const User = db.mongoose.model("User", UserSchema);
-  return User;
-};
-const VisitorModel = (db) => {
-  const VisitorSchema = new db.mongoose.Schema({
-    ip: String,
-    userAgent: String,
-    acceptLanguage: String,
-    fingerprint: { type: String, unique: true }
-  });
-  const Visitor = db.mongoose.model("Visitor", VisitorSchema);
-  return Visitor;
-};
-function initializeAuth(app, db, origins, publicPath) {
-  db.role = RoleModel(db);
-  db.user = UserModel(db);
-  db.visitor = VisitorModel(db);
-  db.request = RequestModel(db);
-  if (app) {
-    authRoutes(app, db);
-    twofaRoutes(app, db);
-    usersRoutes(app, db);
-    const visitorModule = profile_schema.modelsFactory(db);
-    app.use(visitorModule.visitorLogger);
-  }
-}
-const models = {
-  RoleModel,
-  UserModel,
-  VisitorModel
-};
-const routes = {
-  authRoutes,
-  twofaRoutes,
-  usersRoutes
-};
-const controllers = {
-  AuthController: controllerFactory$2,
-  TwoFaController: controllerFactory$1,
-  UsersController: controllerFactory
-};
-const auth_server = {
-  initialize: initializeAuth,
-  models,
-  routes,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = auth_server;
-exports.initialize = initializeAuth;
-exports.models = models;
-exports.routes = routes;

package/dist/authJwt-BIZ2GIfT.cjs

@@ -1,75 +0,0 @@
-"use strict";
-const jwt = require("jsonwebtoken");
-const middlewareFactory = (db) => {
-  const User = db.user;
-  const Role = db.role;
-  const verifyToken = (continueOnFail = false) => {
-    return async (req, res, next) => {
-      try {
-        let token = req.headers["x-access-token"];
-        if (!token && req.cookies && req.cookies.user) {
-          let user = JSON.parse(req.cookies.user);
-          token = user.accessToken;
-        }
-        if (req.headers["x-service-key"]) {
-          const serviceKey = req.headers["x-service-key"];
-          const validServiceKey = process.env.SERVICE_KEY;
-          if (serviceKey !== validServiceKey) {
-            return res.status(403).send({ message: "Unauthorized: Invalid service key" });
-          }
-          req.isServiceRequest = true;
-          return next();
-        }
-        if (!token) {
-          req.userId = null;
-          if (continueOnFail) {
-            return next();
-          } else {
-            return res.status(401).send({ message: "Unauthorized: No token provided" });
-          }
-        }
-        const decoded = jwt.verify(token, process.env.SECRET_KEY);
-        req.userId = decoded._id;
-        req.user = {
-          _id: decoded._id
-        };
-        next();
-      } catch (err) {
-        req.userId = null;
-        if (continueOnFail) {
-          next();
-        } else {
-          res.status(401).send({ message: "Unauthorized: Invalid token" });
-        }
-      }
-    };
-  };
-  const checkRole = (roleToCheck) => async (req, res, next) => {
-    try {
-      const user = await User.findById(req.userId).exec();
-      if (!user) {
-        console.log("[CheckRole] User not found");
-        return res.status(404).send({ message: "User Not found." });
-      }
-      const roles = await Role.find({ _id: { $in: user.roles } }).exec();
-      for (let role of roles) {
-        if (role.name === roleToCheck) {
-          next();
-          return;
-        }
-      }
-      res.status(403).send({ message: `Require ${roleToCheck} Role!` });
-    } catch (err) {
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const isAdmin = checkRole("admin");
-  const isModerator = checkRole("moderator");
-  const authJwt = {
-    verifyToken,
-    isAdmin,
-    isModerator
-  };
-  return authJwt;
-};
-exports.middlewareFactory = middlewareFactory;