@ozdao/prometheus-framework 0.2.252 → 0.2.254

package/dist/auth.server.js

@@ -1,11 +1,73 @@
 "use strict";
 const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
+const profile_schema = require("./profile.schema-CkOhhf37.js");
+const credentials_schema = require("./credentials.schema-B-KD_ozQ.js");
 const require$$0 = require("jsonwebtoken");
 const require$$1$1 = require("bcryptjs");
 const require$$0$1 = require("mongoose");
 const require$$1 = require("jwk-to-pem");
 const mailing = require("./mailing-BQKyTI-q.js");
 const index = require("./index-CsS7qx1d.js");
+require("uuid");
+const addMembersQuantity$1 = require("./addMembersQuantity-B8UgqlUM.js");
+const require$$0$2 = require("crypto");
+var 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: ""
+      }
+    }
+  });
+};
+const applyProfileSchema = profile_schema.profile_schema;
+const applySocialsSchema2 = socials_schema;
+const applyCredentialsSchema = credentials_schema.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
@@ -13,6 +75,31 @@ var role_model = (db) => {
   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 }
+  });
+  VisitorSchema.index({ fingerprint: 1 });
+  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) {
@@ -52,9 +139,9 @@ async function verifyAppleIdToken$1(id_token) {
 var verifyAppleIdToken_1 = { verifyAppleIdToken: verifyAppleIdToken$1 };
 const jwt = require$$0;
 const bcrypt = require$$1$1;
-const ObjectId = require$$0$1.Types.ObjectId;
+const ObjectId$1 = require$$0$1.Types.ObjectId;
 const { verifyAppleIdToken } = verifyAppleIdToken_1;
-const controllerFactory$3 = (db) => {
+const controllerFactory$5 = (db) => {
   const User = db.user;
   const Membership = db.membership;
   const Department = db.department;
@@ -163,8 +250,8 @@ const controllerFactory$3 = (db) => {
       await invite.save();
       const newMembership = new Membership({
         type: "organization",
-        user: new ObjectId(user._id),
-        target: new ObjectId(invite.owner.target),
+        user: new ObjectId$1(user._id),
+        target: new ObjectId$1(invite.owner.target),
         role: invite.role,
         label: invite.role
       });
@@ -291,9 +378,9 @@ const controllerFactory$3 = (db) => {
     checkAccesses
   };
 };
-var auth_service = controllerFactory$3;
+var auth_service = controllerFactory$5;
 const { sendEmail, sendSms } = mailing.mailing;
-const controllerFactory$2 = (db) => {
+const controllerFactory$4 = (db) => {
   const sendcode = async (req, res) => {
     const code = Math.floor(1e3 + Math.random() * 9e3);
     const type = req.body.type;
@@ -320,12 +407,12 @@ const controllerFactory$2 = (db) => {
     sendcode
   };
 };
-var twofa_service = controllerFactory$2;
-const controllerFactory$1 = auth_service;
+var twofa_service = controllerFactory$4;
+const controllerFactory$3 = auth_service;
 const controllerFactoryTwofa = twofa_service;
 const middlewareFactory$1 = index.middlewares;
 var auth_routes = function(app, db, origins) {
-  const controller = controllerFactory$1(db);
+  const controller = controllerFactory$3(db);
   const controllerTwofa = controllerFactoryTwofa();
   const { verifySignUp, verifyUser, authJwt } = middlewareFactory$1(db);
   app.post(
@@ -359,10 +446,10 @@ var auth_routes = function(app, db, origins) {
     controller.checkAccesses
   );
 };
-const controllerFactory = twofa_service;
+const controllerFactory$2 = twofa_service;
 const middlewareFactory = index.middlewares;
 var twofa_routes = function(app, db) {
-  const controller = controllerFactory();
+  const controller = controllerFactory$2();
   const { verifySignUp, verifyUser } = middlewareFactory(db);
   app.post(
     "/api/twofa/sendcode",
@@ -379,30 +466,227 @@ var twofa_routes = function(app, db) {
     controller.sendcode
   );
 };
+const ObjectId = require$$0$1.Types.ObjectId;
+const addUserStatusFields = addMembersQuantity$1.addUserStatusFields_1;
+const addMembersQuantity = addMembersQuantity$1.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;
+    console.log(req.query);
+    const matchConditions = [
+      ...req.query._id ? [{ _id: new ObjectId(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(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 });
+    }
+  };
+  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
+  };
+};
+var users_service = controllerFactory$1;
+const controllerFactory = users_service;
+var users_routes = function(app, db, origins) {
+  const controller = controllerFactory(db);
+  app.post("/api/users", controller.create);
+  app.get("/api/users", controller.read);
+  app.put("/api/users/:_id", controller.update);
+  app.delete("/api/users/:_id", controller.remove);
+};
+const crypto = require$$0$2;
+const fingerprintCache = /* @__PURE__ */ new Map();
+const generateFingerprint = (req) => {
+  const { ip, headers } = req;
+  const userAgent = headers["user-agent"];
+  const acceptLanguage = headers["accept-language"];
+  const key = `${ip}-${userAgent}-${acceptLanguage}`;
+  if (fingerprintCache.has(key)) {
+    return fingerprintCache.get(key);
+  }
+  const hash = crypto.createHash("sha256");
+  hash.update(key);
+  const digest = hash.digest("hex");
+  fingerprintCache.set(key, digest);
+  return digest;
+};
+const modelsFactory = (db) => {
+  const Visitor = db.visitor;
+  const Request = db.request;
+  const visitorLogger = async (req, res, next) => {
+    const fingerprint = generateFingerprint(req);
+    try {
+      let visitor = await Visitor.findOne({ fingerprint });
+      if (!visitor) {
+        visitor = new Visitor({
+          ip: req.ip,
+          userAgent: req.headers["user-agent"],
+          acceptLanguage: req.headers["accept-language"],
+          fingerprint
+        });
+        await visitor.save();
+      }
+      const newRequest = new Request({
+        visitor: visitor._id,
+        path: req.path,
+        method: req.method,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      await newRequest.save();
+      next();
+    } catch (error) {
+      console.error("Error processing visitor and request data:", error);
+      next();
+    }
+  };
+  return {
+    visitorLogger
+  };
+};
+var visitor_logger = modelsFactory;
+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;
+const visitors = visitor_logger;
 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 = visitors(db);
+    app.use(visitorModule.visitorLogger);
   }
 }
 var auth_server = {
   initialize: initializeAuth,
   models: {
-    RoleModel
+    RoleModel,
+    UserModel,
+    VisitorModel
   },
   routes: {
     authRoutes,
-    twofaRoutes
+    twofaRoutes,
+    usersRoutes
   },
   controllers: {
     AuthController,
-    TwoFaController
+    TwoFaController,
+    UsersController
   }
 };
 const auth_server$1 = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(auth_server);