@ozdao/prometheus-framework 0.2.252 → 0.2.254

package/dist/auth.server.mjs

@@ -1,10 +1,72 @@
 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 require$$0 from "jsonwebtoken";
 import require$$1$1 from "bcryptjs";
 import require$$0$1 from "mongoose";
 import require$$1 from "jwk-to-pem";
 import { m as mailing } from "./mailing-C3VD4l0h.mjs";
 import { m as middlewares } from "./index-UIHE6Rk3.mjs";
+import "uuid";
+import { a as addUserStatusFields_1, b as addMembersQuantity_1 } from "./addMembersQuantity-BXp_LeQd.mjs";
+import require$$0$2 from "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;
+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
@@ -12,6 +74,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) {
@@ -51,9 +138,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;
@@ -162,8 +249,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
       });
@@ -290,9 +377,9 @@ const controllerFactory$3 = (db) => {
     checkAccesses
   };
 };
-var auth_service = controllerFactory$3;
+var auth_service = controllerFactory$5;
 const { sendEmail, sendSms } = 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;
@@ -319,12 +406,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 = 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(
@@ -358,10 +445,10 @@ var auth_routes = function(app, db, origins) {
     controller.checkAccesses
   );
 };
-const controllerFactory = twofa_service;
+const controllerFactory$2 = twofa_service;
 const middlewareFactory = middlewares;
 var twofa_routes = function(app, db) {
-  const controller = controllerFactory();
+  const controller = controllerFactory$2();
   const { verifySignUp, verifyUser } = middlewareFactory(db);
   app.post(
     "/api/twofa/sendcode",
@@ -378,30 +465,227 @@ var twofa_routes = function(app, db) {
     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;
+    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__ */ getDefaultExportFromCjs(auth_server);

package/dist/builder.js

@@ -599,7 +599,7 @@ var webpack_config_client = (projectRoot) => {
     mode: !isProd2 ? "development" : "production",
     devtool: !isProd2 ? "inline-source-map" : "source-map",
     entry: {
-      main: !isProd2 ? [path$3.resolve("../utils/hot-reload.js"), path$3.resolve(projectRoot, "src/index.js")] : path$3.resolve(projectRoot, "src/index.js")
+      main: !isProd2 ? [path$3.resolve("../utils/hot-reload.js"), path$3.resolve(projectRoot, "src/client.js")] : path$3.resolve(projectRoot, "src/client.js")
     },
     module: {
       rules: []
@@ -670,7 +670,7 @@ var webpack_config_server = (projectRoot) => {
     mode: "development",
     entry: [
       "webpack/hot/poll?1000",
-      path$2.resolve(projectRoot, "server/server.js")
+      path$2.resolve(projectRoot, "src/server.js")
     ],
     output: {
       filename: "server.[fullhash].js",
@@ -707,7 +707,7 @@ var webpack_config_spa = (projectRoot) => {
     mode: !isProd ? "development" : "production",
     devtool: "source-map",
     entry: {
-      main: path$1.resolve(projectRoot, "src/index.js")
+      main: path$1.resolve(projectRoot, "src/client.js")
     },
     output: {
       filename: "main.js",
@@ -768,7 +768,7 @@ var webpack_config_ssr = (projectRoot) => {
     target: "node",
     mode: !isProd2 ? "development" : "production",
     entry: {
-      main: path.resolve(projectRoot, "src/index.js")
+      main: path.resolve(projectRoot, "src/client.js")
     },
     output: {
       filename: "main.[fullhash].js",

package/dist/builder.mjs

@@ -576,7 +576,7 @@ var webpack_config_client = (projectRoot) => {
     mode: !isProd2 ? "development" : "production",
     devtool: !isProd2 ? "inline-source-map" : "source-map",
     entry: {
-      main: !isProd2 ? [path$3.resolve("../utils/hot-reload.js"), path$3.resolve(projectRoot, "src/index.js")] : path$3.resolve(projectRoot, "src/index.js")
+      main: !isProd2 ? [path$3.resolve("../utils/hot-reload.js"), path$3.resolve(projectRoot, "src/client.js")] : path$3.resolve(projectRoot, "src/client.js")
     },
     module: {
       rules: []
@@ -647,7 +647,7 @@ var webpack_config_server = (projectRoot) => {
     mode: "development",
     entry: [
       "webpack/hot/poll?1000",
-      path$2.resolve(projectRoot, "server/server.js")
+      path$2.resolve(projectRoot, "src/server.js")
     ],
     output: {
       filename: "server.[fullhash].js",
@@ -684,7 +684,7 @@ var webpack_config_spa = (projectRoot) => {
     mode: !isProd ? "development" : "production",
     devtool: "source-map",
     entry: {
-      main: path$1.resolve(projectRoot, "src/index.js")
+      main: path$1.resolve(projectRoot, "src/client.js")
     },
     output: {
       filename: "main.js",
@@ -745,7 +745,7 @@ var webpack_config_ssr = (projectRoot) => {
     target: "node",
     mode: !isProd2 ? "development" : "production",
     entry: {
-      main: path.resolve(projectRoot, "src/index.js")
+      main: path.resolve(projectRoot, "src/client.js")
     },
     output: {
       filename: "main.[fullhash].js",

package/dist/chats.server.js

@@ -0,0 +1,110 @@
+"use strict";
+const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
+require("./mailing-BQKyTI-q.js");
+const index = require("./index-CsS7qx1d.js");
+const controllerFactory$1 = (db) => {
+  const ChatMessage = db.ChatMessage;
+  const saveMessage = async (msg) => {
+    try {
+      const message = new ChatMessage(msg);
+      await message.save();
+      return message;
+    } catch (error) {
+      console.error("Error saving message to database:", error);
+    }
+  };
+  const getMessages = async (chatId) => {
+    try {
+      const messages = await ChatMessage.find({ chatId }).sort({ createdAt: 1 });
+      return messages;
+    } catch (error) {
+      console.error("Error retrieving messages from database:", error);
+    }
+  };
+  return {
+    saveMessage,
+    getMessages
+  };
+};
+var chats_controller = controllerFactory$1;
+const controllerFactory = chats_controller;
+const middlewareFactory = index.middlewares;
+var chats_routes = function(app, db, wss) {
+  const controller = controllerFactory(db);
+  middlewareFactory(db);
+  wss.on("connection", (ws) => {
+    console.log("ws connecting...");
+    ws.on("message", async (message) => {
+      const msg = JSON.parse(message);
+      if (msg.type === "joinChat") {
+        ws.chatId = msg.chatId;
+        console.log(`Client joined chat: ${msg.chatId}`);
+      } else {
+        const savedMessage = await controller.saveMessage(msg);
+        wss.clients.forEach((client) => {
+          if (client.chatId && client.chatId.toString() === msg.chatId) {
+            client.send(JSON.stringify(savedMessage));
+          }
+        });
+      }
+    });
+  });
+  app.use(function(req, res, next) {
+    res.header(
+      "Access-Control-Allow-Headers",
+      "Access-Control-Allow-Origin: *",
+      "x-access-token, Origin, Content-Type, Accept"
+    );
+    next();
+  });
+  app.get("/messages/:chatId", async (req, res) => {
+    const { chatId } = req.params;
+    const messages = await controller.getMessages(chatId);
+    res.json(messages);
+  });
+};
+var chat_model = (db) => {
+  const ChatMessageSchema = new db.mongoose.Schema({
+    username: {
+      type: String,
+      required: true
+    },
+    chatId: {
+      type: String,
+      required: true
+    },
+    text: {
+      type: String,
+      required: true
+    },
+    createdAt: {
+      type: Date,
+      default: Date.now
+    }
+  });
+  const ChatMessage = db.mongoose.model("ChatMessage", ChatMessageSchema);
+  return ChatMessage;
+};
+const ChatsController = chats_controller;
+const chatsRoutes = chats_routes;
+const ChatModel = chat_model;
+function initializeChats(app, db, wss, origins, publicPath) {
+  db.chat = ChatModel(db);
+  if (app) {
+    chatsRoutes(app, db, wss);
+  }
+}
+var chats_server = {
+  initialize: initializeChats,
+  models: {
+    ChatModel
+  },
+  routes: {
+    chatsRoutes
+  },
+  controllers: {
+    ChatsController
+  }
+};
+const chats_server$1 = /* @__PURE__ */ _commonjsHelpers.getDefaultExportFromCjs(chats_server);
+module.exports = chats_server$1;

package/dist/chats.server.mjs

@@ -0,0 +1,111 @@
+import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
+import "./mailing-C3VD4l0h.mjs";
+import { m as middlewares } from "./index-UIHE6Rk3.mjs";
+const controllerFactory$1 = (db) => {
+  const ChatMessage = db.ChatMessage;
+  const saveMessage = async (msg) => {
+    try {
+      const message = new ChatMessage(msg);
+      await message.save();
+      return message;
+    } catch (error) {
+      console.error("Error saving message to database:", error);
+    }
+  };
+  const getMessages = async (chatId) => {
+    try {
+      const messages = await ChatMessage.find({ chatId }).sort({ createdAt: 1 });
+      return messages;
+    } catch (error) {
+      console.error("Error retrieving messages from database:", error);
+    }
+  };
+  return {
+    saveMessage,
+    getMessages
+  };
+};
+var chats_controller = controllerFactory$1;
+const controllerFactory = chats_controller;
+const middlewareFactory = middlewares;
+var chats_routes = function(app, db, wss) {
+  const controller = controllerFactory(db);
+  middlewareFactory(db);
+  wss.on("connection", (ws) => {
+    console.log("ws connecting...");
+    ws.on("message", async (message) => {
+      const msg = JSON.parse(message);
+      if (msg.type === "joinChat") {
+        ws.chatId = msg.chatId;
+        console.log(`Client joined chat: ${msg.chatId}`);
+      } else {
+        const savedMessage = await controller.saveMessage(msg);
+        wss.clients.forEach((client) => {
+          if (client.chatId && client.chatId.toString() === msg.chatId) {
+            client.send(JSON.stringify(savedMessage));
+          }
+        });
+      }
+    });
+  });
+  app.use(function(req, res, next) {
+    res.header(
+      "Access-Control-Allow-Headers",
+      "Access-Control-Allow-Origin: *",
+      "x-access-token, Origin, Content-Type, Accept"
+    );
+    next();
+  });
+  app.get("/messages/:chatId", async (req, res) => {
+    const { chatId } = req.params;
+    const messages = await controller.getMessages(chatId);
+    res.json(messages);
+  });
+};
+var chat_model = (db) => {
+  const ChatMessageSchema = new db.mongoose.Schema({
+    username: {
+      type: String,
+      required: true
+    },
+    chatId: {
+      type: String,
+      required: true
+    },
+    text: {
+      type: String,
+      required: true
+    },
+    createdAt: {
+      type: Date,
+      default: Date.now
+    }
+  });
+  const ChatMessage = db.mongoose.model("ChatMessage", ChatMessageSchema);
+  return ChatMessage;
+};
+const ChatsController = chats_controller;
+const chatsRoutes = chats_routes;
+const ChatModel = chat_model;
+function initializeChats(app, db, wss, origins, publicPath) {
+  db.chat = ChatModel(db);
+  if (app) {
+    chatsRoutes(app, db, wss);
+  }
+}
+var chats_server = {
+  initialize: initializeChats,
+  models: {
+    ChatModel
+  },
+  routes: {
+    chatsRoutes
+  },
+  controllers: {
+    ChatsController
+  }
+};
+const chats_server$1 = /* @__PURE__ */ getDefaultExportFromCjs(chats_server);
+export {
+  chats_server$1 as default
+};