@ozdao/martyrs 0.2.477 → 0.2.479

package/src/modules/auth/controllers/services/auth.service.js

@@ -1,82 +1,67 @@
-const jwt = require("jsonwebtoken");
-const bcrypt = require("bcryptjs");
-const ObjectId = require('mongoose').Types.ObjectId;
-// Utils
-const { verifyAppleIdToken } = require('../utils/verifyAppleIdToken')
+import bcrypt from 'bcryptjs';
+import jwt from 'jsonwebtoken';
+import { Types } from 'mongoose';
+import { verifyAppleIdToken } from '../utils/verifyAppleIdToken.js';
+const ObjectId = { Types }.Types.ObjectId;
 // Factory
-const controllerFactory = (db) => {
-
+const controllerFactory = db => {
   const User = db.user;
   const Membership = db.membership;
   const Department = db.department;
   const Organization = 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" });
+        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" });
+        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, 
+          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" });
+        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 });
+          return res.status(401).send({ errorCode: 'INCORRECT_PASSWORD_ENTERED', accessToken: null });
         }
       }
-      
-      const token = jwt.sign({ 
-        _id: user._id, 
-      }, process.env.SECRET_KEY, { 
-        expiresIn: 864000 
-      });
-      
+      const token = jwt.sign(
+        {
+          _id: user._id,
+        },
+        process.env.SECRET_KEY,
+        {
+          expiresIn: 864000,
+        }
+      );
       const authorities = user.roles.map(role => `ROLE_${role.name.toUpperCase()}`);
-      
       res.status(200).send({
         _id: user._id,
         username: user.username,
@@ -91,121 +76,105 @@ const controllerFactory = (db) => {
       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" });
+          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)
+      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)
+      console.log(err);
       return res.status(500).send({ message: err });
     }
-
     try {
-      const role = await Role.findOne({ name: "user" });
+      const role = await Role.findOne({ name: 'user' });
       user.roles = [role._id];
       await user.save();
     } catch (err) {
-      console.log(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(user._id),
         target: new ObjectId(invite.owner.target),
         role: invite.role,
-        label: 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
-    });
-    
+    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
-      }
+        _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" });
+        return res.status(400).send({ errorCode: 'MISSING_REQUIRED_PARAMETERS' });
       }
-
       const salt = await bcrypt.genSalt(8); // Generating a salt asynchronously
       const hashedPassword = await bcrypt.hash(password, salt); // Hashing the password asynchronously
-
       const user = await User.findOneAndUpdate(query, {
         password: hashedPassword,
-      }).populate("roles").exec();
-
+      })
+        .populate('roles')
+        .exec();
       if (!user) {
-        return res.status(404).send({ errorCode: "ERROR_UPDATING_USER" });
+        return res.status(404).send({ errorCode: 'ERROR_UPDATING_USER' });
       }
-
       const token = jwt.sign({ _id: user._id }, process.env.SECRET_KEY, {
-        expiresIn: 86400
+        expiresIn: 86400,
       });
-
       const authorities = user.roles.map(role => `ROLE_${role.name.toUpperCase()}`);
-
       return res.status(200).send({
         _id: user._id,
         username: user.username,
@@ -213,18 +182,16 @@ const controllerFactory = (db) => {
         phone: user.phone,
         email: user.email,
         roles: authorities,
-        accessToken: token
+        accessToken: token,
       });
     } catch (err) {
       return res.status(500).send({ message: err.message });
     }
   };
-
   return {
     signin,
     signup,
-    updatePassword
+    updatePassword,
   };
 };
-
-module.exports = controllerFactory;
+export default controllerFactory;

package/src/modules/auth/controllers/services/twofa.service.js

@@ -1,26 +1,21 @@
-const { sendEmail, sendSms } = require('@martyrs/src/modules/globals/controllers/utils/mailing');
-
-const controllerFactory = (db) => {
+import mailing from '@martyrs/src/modules/globals/controllers/utils/mailing.js';
+const { sendEmail, sendSms } = mailing;
+const controllerFactory = db => {
   const sendcode = async (req, res) => {
     const code = Math.floor(1000 + Math.random() * 9000);
-
     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)
+        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 {
@@ -28,10 +23,8 @@ const controllerFactory = (db) => {
       }
     }
   };
-
   return {
-    sendcode
+    sendcode,
   };
 };
-
-module.exports = controllerFactory;
+export default controllerFactory;

package/src/modules/auth/controllers/services/users.service.js

@@ -1,25 +1,19 @@
-const { v4: uuidv4 } = require('uuid');
-const ObjectId = require('mongoose').Types.ObjectId;
-
-const addUserStatusFields = require('@martyrs/src/modules/organizations/controllers/utils/addUserStatusFields');
-const addMembersQuantity = require('@martyrs/src/modules/organizations/controllers/utils/addMembersQuantity');
-
-const controllerFactory = (db) => {
+import addMembersQuantity from '@martyrs/src/modules/organizations/controllers/utils/addMembersQuantity.js';
+import addUserStatusFields from '@martyrs/src/modules/organizations/controllers/utils/addUserStatusFields.js';
+import { Types } from 'mongoose';
+const ObjectId = { Types }.Types.ObjectId;
+const controllerFactory = db => {
   const User = db.user;
-
   const read = async (req, res) => {
     let query = [];
     let match = {};
     let skip = parseInt(req.query.skip) || 0;
     let limit = parseInt(req.query.limit) || 10;
-
     let matchConditions = [];
-    
     // Модифицированная проверка _id
     if (req.query._id) {
       // Проверяем, является ли _id валидным ObjectId
       const isValidObjectId = ObjectId.isValid(req.query._id);
-      
       if (isValidObjectId) {
         matchConditions.push({ _id: new ObjectId(req.query._id) });
       } else {
@@ -27,15 +21,11 @@ const controllerFactory = (db) => {
         matchConditions.push({ username: req.query._id });
       }
     }
-    
     let search = req.query.search;
-
     if (search) {
       let regexPattern = '';
-
       // Экранирование специальных символов в строке поиска
       const escapedSearch = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
       // Проверка, является ли строка поиска потенциальным email
       if (escapedSearch.includes('@')) {
         regexPattern = escapedSearch;
@@ -48,72 +38,59 @@ const controllerFactory = (db) => {
       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' } }
-        ]
+          { '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'
-      }
+        as: 'orders',
+      },
     });
-
     query.push({
       $lookup: {
         from: 'roles',
         localField: 'roles',
         foreignField: '_id',
-        as: 'roles'
-      }
+        as: 'roles',
+      },
     });
-
     query.push({
       $lookup: {
-        from: "memberships",
-        localField: "_id",
-        foreignField: "target",
-        as: "memberships"
-      }
+        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
+      $skip: skip,
     });
-
     query.push({
-      $limit: limit
+      $limit: limit,
     });
-
     try {
       const users = await User.aggregate(query);
-
       if (!users) {
-        return res.status(404).send({ message: "Users not found." });
+        return res.status(404).send({ message: 'Users not found.' });
       }
-
       res.status(200).send(users);
     } catch (err) {
-      console.log(err)
+      console.log(err);
       res.status(500).send({ message: err });
     }
   };
-
   const create = async (req, res) => {
     try {
       const newUser = {
@@ -121,58 +98,42 @@ const controllerFactory = (db) => {
         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." });
+        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 });
+      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." });
+        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 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." });
+        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 res.status(500).send({ errorCode: 'INTERNAL_SERVER_ERROR', message: err });
     }
   };
-
-
   return {
     read,
     create,
     update,
-    remove
+    remove,
   };
 };
-
-module.exports = controllerFactory;
+export default controllerFactory;

package/src/modules/auth/controllers/utils/verifyAppleIdToken.js

@@ -1,56 +1,49 @@
-const jwt = require('jsonwebtoken');
-const jwkToPem = require('jwk-to-pem');
-
+import jwt from 'jsonwebtoken';
+import jwkToPem from 'jwk-to-pem';
 async function verifyAppleIdToken(id_token) {
-    // Decode the token (without verification)
-    const decodedToken = jwt.decode(id_token, { complete: true });
-    if (!decodedToken) {
-        throw new Error('Failed to decode token.');
-    }
-
-    // Check iss claim
-    if (decodedToken.payload.iss !== 'https://appleid.apple.com') {
-        throw new Error('Invalid issuer.');
-    }
-
-    // Check aud claim - Replace YOUR_APP_CLIENT_ID with your client ID
-    if (decodedToken.payload.aud !== process.env.APPLE_CLIENTID) {
-        throw new Error('Invalid audience.');
-    }
-
-    // Ensure the token has not expired
-    const currentTimestamp = Math.floor(Date.now() / 1000);
-    if (currentTimestamp > decodedToken.payload.exp) {
-        throw new Error('Token has expired.');
-    }
-
-    // Fetch Apple's public keys
-    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.');
-    }
-
-    // Convert JWK to PEM
-    const pem = jwkToPem(appleKey);
-
-    // Verify the token's signature using the PEM
-    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; // or return the entire payload, depending on your needs
+  // Decode the token (without verification)
+  const decodedToken = jwt.decode(id_token, { complete: true });
+  if (!decodedToken) {
+    throw new Error('Failed to decode token.');
+  }
+  // Check iss claim
+  if (decodedToken.payload.iss !== 'https://appleid.apple.com') {
+    throw new Error('Invalid issuer.');
+  }
+  // Check aud claim - Replace YOUR_APP_CLIENT_ID with your client ID
+  if (decodedToken.payload.aud !== process.env.APPLE_CLIENTID) {
+    throw new Error('Invalid audience.');
+  }
+  // Ensure the token has not expired
+  const currentTimestamp = Math.floor(Date.now() / 1000);
+  if (currentTimestamp > decodedToken.payload.exp) {
+    throw new Error('Token has expired.');
+  }
+  // Fetch Apple's public keys
+  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.');
+  }
+  // Convert JWK to PEM
+  const pem = jwkToPem(appleKey);
+  // Verify the token's signature using the PEM
+  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; // or return the entire payload, depending on your needs
 }
-
-module.exports = { verifyAppleIdToken };
+export { verifyAppleIdToken };
+export default {
+  verifyAppleIdToken,
+};

package/src/modules/auth/models/request.model.js

@@ -1,18 +1,14 @@
-module.exports = (db) => {
-
+export default db => {
   const RequestSchema = new db.mongoose.Schema({
     visitor: {
       type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Visitor"
+      ref: 'Visitor',
     },
     path: String,
     method: String,
-    timestamp: { type: Date, default: Date.now }
+    timestamp: { type: Date, default: Date.now },
   });
-
   RequestSchema.index({ visitor: 1 });
-
-  const Request = db.mongoose.model("Request", RequestSchema);
-
+  const Request = db.mongoose.model('Request', RequestSchema);
   return Request;
-}
+};

package/src/modules/auth/models/role.model.js

@@ -1,11 +1,7 @@
-module.exports = (db) => {
-
+export default db => {
   const RoleSchema = new db.mongoose.Schema({
-    name: String
+    name: String,
   });
-
-  const Role = db.mongoose.model("Role", RoleSchema);
-
+  const Role = db.mongoose.model('Role', RoleSchema);
   return Role;
 };
-