@ozdao/prometheus-framework 0.2.330 → 0.2.331

package/dist/auth.server.mjs

@@ -1,606 +1,699 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { p as profile_schema } from "./profile.schema-24ZpZQJe.mjs";
-import { c as credentials_schema } from "./credentials.schema-C9dmNy7o.mjs";
+import { r as requireProfile_schema } from "./profile.schema-kP_zKXNt.mjs";
+import { r as requireCredentials_schema } from "./credentials.schema-oOC8B5KL.mjs";
 import require$$0 from "jsonwebtoken";
 import require$$2 from "bcryptjs";
 import require$$0$1 from "mongoose";
 import require$$1 from "jwk-to-pem";
-import { m as mailing } from "./mailing-D1cjLmTB.mjs";
-import { m as middlewares } from "./index-CW2mOwo8.mjs";
-import "uuid";
-import { a as addUserStatusFields_1, b as addMembersQuantity_1 } from "./addMembersQuantity-BXp_LeQd.mjs";
+import { r as requireMailing } from "./mailing-C8zqHzvG.mjs";
+import { r as requireMiddlewares } from "./index-Ctf6Y61O.mjs";
+import require$$0$2 from "uuid";
+import { r as requireAddUserStatusFields, a as requireAddMembersQuantity } from "./addMembersQuantity-DBfuUEx_.mjs";
 import "crypto";
-var socials_schema = function applySocialsSchema(schema, db) {
-  schema.add({
-    socials: {
-      telegram: {
+var socials_schema;
+var hasRequiredSocials_schema;
+function requireSocials_schema() {
+  if (hasRequiredSocials_schema) return socials_schema;
+  hasRequiredSocials_schema = 1;
+  socials_schema = function applySocialsSchema(schema, db) {
+    schema.add({
+      socials: {
+        telegram: {
+          type: String,
+          default: ""
+        },
+        twitter: {
+          type: String,
+          default: ""
+        },
+        facebook: {
+          type: String,
+          default: ""
+        },
+        instagram: {
+          type: String,
+          default: ""
+        }
+      }
+    });
+  };
+  return socials_schema;
+}
+var user_model;
+var hasRequiredUser_model;
+function requireUser_model() {
+  if (hasRequiredUser_model) return user_model;
+  hasRequiredUser_model = 1;
+  const applyProfileSchema = requireProfile_schema();
+  const applySocialsSchema = requireSocials_schema();
+  const applyCredentialsSchema = requireCredentials_schema();
+  user_model = (db) => {
+    const UserSchema = new db.mongoose.Schema({
+      username: {
         type: String,
-        default: ""
+        unique: true
       },
-      twitter: {
+      password: {
         type: String,
-        default: ""
+        required: true
       },
-      facebook: {
+      status: {
         type: String,
-        default: ""
+        enum: ["active", "banned", "removed", "inactive"],
+        default: "active",
+        required: true
       },
-      instagram: {
-        type: String,
-        default: ""
+      roles: [{
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Role"
+      }]
+    }, {
+      // Creation Date
+      timestamps: {
+        currentTime: () => Date.now()
       }
-    }
-  });
-};
-const applyProfileSchema = profile_schema;
-const applySocialsSchema2 = socials_schema;
-const applyCredentialsSchema = credentials_schema;
-var user_model = (db) => {
-  const UserSchema = new db.mongoose.Schema({
-    username: {
-      type: String,
-      unique: true
-    },
-    password: {
-      type: String,
-      required: true
-    },
-    status: {
-      type: String,
-      enum: ["active", "banned", "removed", "inactive"],
-      default: "active",
-      required: true
-    },
-    roles: [{
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Role"
-    }]
-  }, {
-    // Creation Date
-    timestamps: {
-      currentTime: () => Date.now()
-    }
-  });
-  applyProfileSchema(UserSchema);
-  applySocialsSchema2(UserSchema);
-  applyCredentialsSchema(UserSchema);
-  const User = db.mongoose.model("User", UserSchema);
-  return User;
-};
-var role_model = (db) => {
-  const RoleSchema = new db.mongoose.Schema({
-    name: String
-  });
-  const Role = db.mongoose.model("Role", RoleSchema);
-  return Role;
-};
-var visitor_model = (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;
-};
-var request_model = (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 jwt$1 = require$$0;
-const jwkToPem = require$$1;
-async function verifyAppleIdToken$1(id_token) {
-  const decodedToken = jwt$1.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$1.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;
+    applyProfileSchema(UserSchema, db);
+    applySocialsSchema(UserSchema, db);
+    applyCredentialsSchema(UserSchema, db);
+    const User = db.mongoose.model("User", UserSchema);
+    return User;
+  };
+  return user_model;
+}
+var role_model;
+var hasRequiredRole_model;
+function requireRole_model() {
+  if (hasRequiredRole_model) return role_model;
+  hasRequiredRole_model = 1;
+  role_model = (db) => {
+    const RoleSchema = new db.mongoose.Schema({
+      name: String
+    });
+    const Role = db.mongoose.model("Role", RoleSchema);
+    return Role;
+  };
+  return role_model;
 }
-var verifyAppleIdToken_1 = { verifyAppleIdToken: verifyAppleIdToken$1 };
-const jwt = require$$0;
-const bcrypt = require$$2;
-const ObjectId$1 = require$$0$1.Types.ObjectId;
-const { verifyAppleIdToken } = verifyAppleIdToken_1;
-const controllerFactory$5 = (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 };
+var visitor_model;
+var hasRequiredVisitor_model;
+function requireVisitor_model() {
+  if (hasRequiredVisitor_model) return visitor_model;
+  hasRequiredVisitor_model = 1;
+  visitor_model = (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;
+  };
+  return visitor_model;
+}
+var request_model;
+var hasRequiredRequest_model;
+function requireRequest_model() {
+  if (hasRequiredRequest_model) return request_model;
+  hasRequiredRequest_model = 1;
+  request_model = (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;
+  };
+  return request_model;
+}
+var verifyAppleIdToken_1;
+var hasRequiredVerifyAppleIdToken;
+function requireVerifyAppleIdToken() {
+  if (hasRequiredVerifyAppleIdToken) return verifyAppleIdToken_1;
+  hasRequiredVerifyAppleIdToken = 1;
+  const jwt = require$$0;
+  const jwkToPem = require$$1;
+  async function verifyAppleIdToken(id_token) {
+    const decodedToken = jwt.decode(id_token, { complete: true });
+    if (!decodedToken) {
+      throw new Error("Failed to decode token.");
     }
-    if (type === "email" && email) {
-      query = { email };
+    if (decodedToken.payload.iss !== "https://appleid.apple.com") {
+      throw new Error("Invalid issuer.");
     }
-    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" });
-      }
+    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 {
-      let user = await User.findOne(query).populate("roles").exec();
-      if (type !== "apple" && !user) {
-        return res.status(404).send({ errorCode: "USER_NOT_FOUND" });
+      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;
+  }
+  verifyAppleIdToken_1 = { verifyAppleIdToken };
+  return verifyAppleIdToken_1;
+}
+var auth_service;
+var hasRequiredAuth_service;
+function requireAuth_service() {
+  if (hasRequiredAuth_service) return auth_service;
+  hasRequiredAuth_service = 1;
+  const jwt = require$$0;
+  const bcrypt = require$$2;
+  const ObjectId = require$$0$1.Types.ObjectId;
+  const { verifyAppleIdToken } = requireVerifyAppleIdToken();
+  const controllerFactory = (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 === "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" && email) {
+        query = { email };
       }
-      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 });
+      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" });
         }
       }
-      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" });
+        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) {
-        return res.status(500).send({ message: err });
+        console.error(err);
+        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
-      });
+    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 newMembership.save();
+        await user.save();
       } catch (err) {
         console.log(err);
+        return res.status(500).send({ message: 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" });
+      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 });
       }
-      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" });
+      if (invite) {
+        invite.status = "used";
+        await invite.save();
+        const newMembership = new Membership({
+          type: "organization",
+          user: new ObjectId(user._id),
+          target: new ObjectId(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 }, process.env.SECRET_KEY, {
+      const token = jwt.sign({
+        _id: user._id,
+        organization: invite ? invite.organization : null
+      }, process.env.SECRET_KEY, {
         expiresIn: 86400
       });
-      const authorities = user.roles.map((role) => `ROLE_${role.name.toUpperCase()}`);
-      return res.status(200).send({
+      res.status(200).send({
         _id: user._id,
-        username: user.username,
-        avatar: user.profile.photo,
         phone: user.phone,
         email: user.email,
-        roles: authorities,
-        accessToken: token
+        accessToken: token,
+        organization: {
+          _id: invite ? invite.organization : null
+        }
       });
-    } catch (err) {
-      return res.status(500).send({ message: err.message });
-    }
-  };
-  return {
-    signin,
-    signup,
-    updatePassword
+    };
+    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
+    };
   };
-};
-var auth_service = controllerFactory$5;
-const { sendEmail, sendSms } = mailing;
-const controllerFactory$4 = (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");
+  auth_service = controllerFactory;
+  return auth_service;
+}
+var twofa_service;
+var hasRequiredTwofa_service;
+function requireTwofa_service() {
+  if (hasRequiredTwofa_service) return twofa_service;
+  hasRequiredTwofa_service = 1;
+  const { sendEmail, sendSms } = requireMailing();
+  const controllerFactory = (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");
+        }
       }
-    }
-    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");
+      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
+    };
   };
-  return {
-    sendcode
+  twofa_service = controllerFactory;
+  return twofa_service;
+}
+var auth_routes;
+var hasRequiredAuth_routes;
+function requireAuth_routes() {
+  if (hasRequiredAuth_routes) return auth_routes;
+  hasRequiredAuth_routes = 1;
+  const controllerFactory = requireAuth_service();
+  const controllerFactoryTwofa = requireTwofa_service();
+  const middlewareFactory = requireMiddlewares();
+  auth_routes = function(app, db, origins) {
+    const controller = controllerFactory(db);
+    const controllerTwofa = controllerFactoryTwofa(db);
+    const { verifySignUp, verifyUser, authJwt } = middlewareFactory(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
+    );
   };
-};
-var twofa_service = controllerFactory$4;
-const controllerFactory$3 = auth_service;
-const controllerFactoryTwofa = twofa_service;
-const middlewareFactory$2 = middlewares;
-var auth_routes = function(app, db, origins) {
-  const controller = controllerFactory$3(db);
-  const controllerTwofa = controllerFactoryTwofa();
-  const { verifySignUp, verifyUser, authJwt } = middlewareFactory$2(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 controllerFactory$2 = twofa_service;
-const middlewareFactory$1 = middlewares;
-var twofa_routes = function(app, db) {
-  const controller = controllerFactory$2();
-  const { verifySignUp, verifyUser } = middlewareFactory$1(db);
-  app.post(
-    "/api/twofa/sendcode",
-    [
-      verifySignUp.checkDuplicateUsernameOrEmail
-    ],
-    controller.sendcode
-  );
-  app.post(
-    "/api/twofa/sendcodereset",
-    [
-      verifyUser.checkUserExist
-    ],
-    controller.sendcode
-  );
-};
-const ObjectId = require$$0$1.Types.ObjectId;
-const addUserStatusFields = addUserStatusFields_1;
-const addMembersQuantity = addMembersQuantity_1;
-const controllerFactory$1 = (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 });
+  return auth_routes;
+}
+var twofa_routes;
+var hasRequiredTwofa_routes;
+function requireTwofa_routes() {
+  if (hasRequiredTwofa_routes) return twofa_routes;
+  hasRequiredTwofa_routes = 1;
+  const controllerFactory = requireTwofa_service();
+  const middlewareFactory = requireMiddlewares();
+  twofa_routes = function(app, db) {
+    const controller = controllerFactory(db);
+    const { verifySignUp, verifyUser } = middlewareFactory(db);
+    app.post(
+      "/api/twofa/sendcode",
+      [
+        verifySignUp.checkDuplicateUsernameOrEmail
+      ],
+      controller.sendcode
+    );
+    app.post(
+      "/api/twofa/sendcodereset",
+      [
+        verifyUser.checkUserExist
+      ],
+      controller.sendcode
+    );
+  };
+  return twofa_routes;
+}
+var users_service;
+var hasRequiredUsers_service;
+function requireUsers_service() {
+  if (hasRequiredUsers_service) return users_service;
+  hasRequiredUsers_service = 1;
+  const { v4: uuidv4 } = require$$0$2;
+  const ObjectId = require$$0$1.Types.ObjectId;
+  const addUserStatusFields = requireAddUserStatusFields();
+  const addMembersQuantity = requireAddMembersQuantity();
+  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}.*`;
+      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" } }
+          ]
+        });
       }
-      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"
+        }
       });
-    }
-    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(addMembersQuantity());
+      if (req.query.user) query.push(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 });
       }
-    });
-    query.push({
-      $lookup: {
-        from: "roles",
-        localField: "roles",
-        foreignField: "_id",
-        as: "roles"
+    };
+    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 });
       }
-    });
-    query.push({
-      $lookup: {
-        from: "memberships",
-        localField: "_id",
-        foreignField: "target",
-        as: "memberships"
+    };
+    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 });
       }
-    });
-    query.push(addMembersQuantity());
-    if (req.query.user) query.push(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." });
+    };
+    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 });
       }
-      res.status(200).send(users);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: err });
-    }
+    };
+    return {
+      read,
+      create,
+      update,
+      remove
+    };
   };
-  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 });
-    }
+  users_service = controllerFactory;
+  return users_service;
+}
+var users_routes;
+var hasRequiredUsers_routes;
+function requireUsers_routes() {
+  if (hasRequiredUsers_routes) return users_routes;
+  hasRequiredUsers_routes = 1;
+  const controllerFactory = requireUsers_service();
+  const middlewareFactory = requireMiddlewares();
+  users_routes = function(app, db, origins) {
+    const controller = controllerFactory(db);
+    const { authJwt, verifyUser } = middlewareFactory(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 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 });
+  return users_routes;
+}
+var auth_server$1;
+var hasRequiredAuth_server;
+function requireAuth_server() {
+  if (hasRequiredAuth_server) return auth_server$1;
+  hasRequiredAuth_server = 1;
+  const UserModel = requireUser_model();
+  const RoleModel = requireRole_model();
+  const VisitorModel = requireVisitor_model();
+  const RequestModel = requireRequest_model();
+  const authRoutes = requireAuth_routes();
+  const twofaRoutes = requireTwofa_routes();
+  const usersRoutes = requireUsers_routes();
+  const AuthController = requireAuth_service();
+  const TwoFaController = requireTwofa_service();
+  const UsersController = requireUsers_service();
+  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, origins, publicPath);
+      twofaRoutes(app, db, origins, publicPath);
+      usersRoutes(app, db, origins, publicPath);
     }
-  };
-  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 });
+  }
+  auth_server$1 = {
+    initialize: initializeAuth,
+    models: {
+      RoleModel,
+      UserModel,
+      VisitorModel
+    },
+    routes: {
+      authRoutes,
+      twofaRoutes,
+      usersRoutes
+    },
+    controllers: {
+      AuthController,
+      TwoFaController,
+      UsersController
     }
   };
-  return {
-    read,
-    create,
-    update,
-    remove
-  };
-};
-var users_service = controllerFactory$1;
-const controllerFactory = users_service;
-const middlewareFactory = middlewares;
-var users_routes = function(app, db, origins) {
-  const controller = controllerFactory(db);
-  const { authJwt, verifyUser } = middlewareFactory(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 UserModel = user_model;
-const RoleModel = role_model;
-const VisitorModel = visitor_model;
-const RequestModel = request_model;
-const authRoutes = auth_routes;
-const twofaRoutes = twofa_routes;
-const usersRoutes = users_routes;
-const AuthController = auth_service;
-const TwoFaController = twofa_service;
-const UsersController = users_service;
-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);
-  }
+  return auth_server$1;
 }
-var auth_server = {
-  initialize: initializeAuth,
-  models: {
-    RoleModel,
-    UserModel,
-    VisitorModel
-  },
-  routes: {
-    authRoutes,
-    twofaRoutes,
-    usersRoutes
-  },
-  controllers: {
-    AuthController,
-    TwoFaController,
-    UsersController
-  }
-};
-const auth_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(auth_server);
+var auth_serverExports = requireAuth_server();
+const auth_server = /* @__PURE__ */ getDefaultExportFromCjs(auth_serverExports);
 export {
-  auth_server$1 as default
+  auth_server as default
 };