auth-verify 0.0.2 → 1.0.3

package/src/helpers/helper.js

@@ -0,0 +1,284 @@
+const crypto = require('crypto');
+const nodemailer = require("nodemailer");
+const axios = require('axios');
+
+/**
+ * Convert time strings like "1h", "30m", "10s" to milliseconds
+ */
+function parseTime(str) {
+    if (typeof str === 'number') return str; // already ms
+    if (typeof str !== 'string') return 0;
+
+    const num = parseInt(str);
+    if (str.endsWith('h')) return num * 60 * 60 * 1000;
+    if (str.endsWith('m')) return num * 60 * 1000;
+    if (str.endsWith('s')) return num * 1000;
+    return num;
+}
+
+/**
+ * Generate a random numeric OTP of given length
+ */
+function generateSecureOTP(length = 6, hash = 'sha256') {
+    // Create random bytes
+    const randomBytes = crypto.randomBytes(32); 
+    // Hash the bytes
+    const hashed = crypto.createHash(hash).update(randomBytes).digest('hex');
+    
+    // Convert to numeric OTP
+    let otp = '';
+    for (let i = 0; i < hashed.length && otp.length < length; i++) {
+        const char = hashed[i];
+        if (!isNaN(char)) otp += char;
+    }
+
+    // If not enough digits, recursively generate more
+    if (otp.length < length) return generateSecureOTP(length, hash);
+    return otp.slice(0, length);
+}
+
+function otpSendingProcessByEmail({senderService, senderEmail, senderPass, senderHost, senderPort, senderSecure, receiverEmail, senderText, senderSubject, senderHtml}){
+    if(senderService == 'gmail'){
+        const transporter = nodemailer.createTransport({
+            service: senderService,
+            auth: {
+                user: senderEmail,
+                pass: senderPass, // not your normal password
+             },
+        });
+
+        if(senderText && !senderHtml){
+            transporter.sendMail({
+                from: senderEmail,
+                to: receiverEmail,
+                subject: senderSubject,
+                text: senderText,
+                // html: senderHtml
+            }, (err, info) => {
+            if (err) return console.error("❌ Failed:", err);
+                // console.log("✅ Email sent:", info.response);
+            });
+        }else if (senderHtml && !senderText){
+            transporter.sendMail({
+                from: senderEmail,
+                to: receiverEmail,
+                subject: senderSubject,
+                // text: senderText,
+                html: senderHtml
+            }, (err, info) => {
+            if (err) return console.error("❌ Failed:", err);
+                // console.log("✅ Email sent:", info.response);
+            });
+        }
+    }else{
+        const transporter = nodemailer.createTransport({
+            host: senderHost,
+            port: senderPort,
+            secure: senderSecure, // true for 465, false for others
+            auth: {
+                user: senderEmail,
+                pass: senderPass,
+            },
+        });
+
+        if(senderText && !senderHtml){
+            transporter.sendMail({
+                from: senderEmail,
+                to: receiverEmail,
+                subject: senderSubject,
+                text: senderText,
+                // html: senderHtml
+            }, (err, info) => {
+            if (err) return console.error("❌ Failed:", err);
+                // console.log("✅ Email sent:", info.response);
+            });
+        }else if (senderHtml && !senderText){
+            transporter.sendMail({
+                from: senderEmail,
+                to: receiverEmail,
+                subject: senderSubject,
+                // text: senderText,
+                html: senderHtml
+            }, (err, info) => {
+            if (err) return console.error("❌ Failed:", err);
+                // console.log("✅ Email sent:", info.response);
+            });
+        }
+    }
+}
+
+async function resendGeneratedOTP({from, to, pass, service, host, secure, port, subject, text, html, code}, callbackData){
+    if(callbackData && typeof callbackData == 'function'){
+        // const code = generateSecureOTP(data.code.length, this.hashAlgorithm);
+        let transporter;
+        if (service === 'gmail') {
+            transporter = nodemailer.createTransport({
+                service: 'gmail',
+                auth: { user: from, pass }
+            });
+        } else if (service === 'smtp') {
+            transporter = nodemailer.createTransport({
+                host,
+                port,
+                secure: !!secure,
+                auth: { user: from, pass }
+        });
+        } else {
+            throw new Error(`Unsupported email service: ${service}`);
+        }
+        // prepare mail
+        const mail = {
+            from,
+            to,
+            subject: subject || 'Your OTP Code',
+            text: text || `Your OTP is ${code}`,
+            html: html || `<p>Your OTP is <b>${code}</b></p>`
+        };
+        transporter.sendMail(mail, (err, info)=>{
+            if(err) return callbackData(new Error(err));
+            callbackData(null, info);
+        });
+    }else{
+        try{
+            let transporter;
+            if (service === 'gmail') {
+                transporter = nodemailer.createTransport({
+                service: 'gmail',
+                auth: { user: from, pass }
+                });
+            } else if (service === 'smtp') {
+                transporter = nodemailer.createTransport({
+                    host,
+                    port,
+                    secure: !!secure,
+                    auth: { user: from, pass: pass }
+                });
+            } else {
+                throw new Error(`Unsupported email service: ${service}`);
+            }
+            // prepare mail
+            const mail = {
+                from,
+                to,
+                subject: subject || 'Your OTP Code',
+                text: text || `Your OTP is ${code}`,
+                html: html || `<p>Your OTP is <b>${code}</b></p>`
+            };
+            await transporter.sendMail(mail);
+        }catch(err){
+            throw new Error(err);
+        }
+    }
+}
+
+async function sendSMS({ provider, apiKey, apiSecret, from, to, text, mock = false }) {
+  try {
+    // 🧪 For testing only — no real SMS sent
+    if (mock) {
+      console.log(`📱 [Mock SMS via ${provider}]`);
+      console.log(`→ To: ${to}`);
+      console.log(`→ Message: ${text}`);
+      return { status: "SENT (mock)", to, text };
+    }
+
+    // 🔷 Infobip API
+    if (provider === 'infobip') {
+      await axios.post(
+        'https://api.infobip.com/sms/2/text/advanced',
+        {
+          messages: [{ from, destinations: [{ to }], text }],
+        },
+        {
+          headers: {
+            Authorization: `App ${apiKey}`,
+            'Content-Type': 'application/json',
+          },
+        }
+      );
+      return { status: "SENT", provider: "Infobip", to };
+    }
+
+    // 🟪 Vonage API
+    if (provider === 'vonage') {
+      await axios.post(
+        'https://rest.nexmo.com/sms/json',
+        {
+          api_key: apiKey,
+          api_secret: apiSecret,
+          to,
+          from,
+          text,
+        },
+        { headers: { 'Content-Type': 'application/json' } }
+      );
+      return { status: "SENT", provider: "Vonage", to };
+    }
+
+    // 🟩 Twilio API
+    if (provider === 'twilio') {
+      await axios.post(
+        `https://api.twilio.com/2010-04-01/Accounts/${apiKey}/Messages.json`,
+        new URLSearchParams({
+          To: to,
+          From: from,
+          Body: text,
+        }),
+        {
+          auth: {
+            username: apiKey,
+            password: apiSecret,
+          },
+        }
+      );
+      return { status: "SENT", provider: "Twilio", to };
+    }
+
+    throw new Error(`Unsupported SMS provider: ${provider}`);
+  } catch (err) {
+    console.error("❌ SMS send failed:", err.message);
+    throw new Error(err.message);
+  }
+}
+
+// async function sendOTPwithTelegramBot(otpCode){
+//     bot.onText(/\/start/, (msg) => {
+//           bot.sendMessage(chatId, "Please share your phone number:", {
+//                 reply_markup: {
+//                     keyboard: [
+//                     [
+//                         {
+//                         text: "📞 Share my phone number",
+//                         request_contact: true, // 🔥 this requests the user's phone
+//                         },
+//                     ],
+//                     ],
+//                     resize_keyboard: true,
+//                     one_time_keyboard: true,
+//                 },
+//             });
+//         bot.sendMessage(msg.chat.id, `Your Verification code is <b>${otpCode}</b>`, {parse_mode: "HTML"});
+//     });
+
+//     bot.on("contact", (msg) => {
+//         const phoneNumber = msg.contact.phone_number;
+//         const firstName = msg.contact.first_name;
+//         const userId = msg.from.id;
+
+//         console.log("User shared phone:", phoneNumber);
+
+//         bot.sendMessage(
+//             msg.chat.id,
+//             `Thanks, ${firstName}! Your phone number is ${phoneNumber}.`
+//         );
+
+//         // Here you can verify or store it in your database
+//     });
+// }
+
+module.exports = {
+    parseTime,
+    generateSecureOTP,
+    otpSendingProcessByEmail,
+    resendGeneratedOTP,
+    sendSMS
+};

package/src/jwt/index.js

@@ -0,0 +1,208 @@
+const jwt = require("jsonwebtoken");
+const Redis = require("ioredis");
+const { parseTime } = require('../helpers/helper');
+
+class JWTManager {
+    constructor(secret, options = {}) {
+        if (!secret) throw new Error("JWT secret is required");
+        this.secret = secret;
+        this.storeType = options.storeTokens || "none";
+
+        if (this.storeType !== 'none') {
+            if (this.storeType === 'memory') {
+                this.tokenStore = new Map();
+            } else if (this.storeType === 'redis') {
+                this.redis = new Redis(options.redisUrl || "redis://localhost:6379");
+            } else {
+                throw new Error("{storeTokens} should be 'none', 'memory', or 'redis'");
+            }
+        }
+    }
+
+    // Helper: convert expiry string like "1h" / "30m" / "10s" to milliseconds
+    _parseExpiry(expiry) {
+        if (typeof expiry === 'number') return expiry;
+        if (typeof expiry !== 'string') return 3600000; // default 1h
+
+        const num = parseInt(expiry);
+        if (expiry.endsWith('h')) return num * 60 * 60 * 1000;
+        if (expiry.endsWith('m')) return num * 60 * 1000;
+        if (expiry.endsWith('s')) return num * 1000;
+        return num;
+    }
+
+    async sign(payload, expiry, callback) {
+        if (typeof expiry === 'function') {
+            callback = expiry;
+            expiry = '1h'; // default
+        }
+
+        const expiryMs = this._parseExpiry(expiry || '1h');  // fallback to '1h'
+        const expiryJwt = typeof expiry === 'number' 
+                  ? Math.floor(expiry / 1000) 
+                  : (typeof expiry === 'string' ? expiry : '1h'); 
+
+        // Callback version
+        if(callback && typeof callback === 'function') {
+            if(this.storeType === 'redis') return callback(new Error("⚠️ Redis requires async/await use promise style functions"));
+
+            jwt.sign(payload, this.secret, { expiresIn: expiryJwt }, (err, token) => {
+                if(err) return callback(err);
+
+                if(this.storeType === 'memory') {
+                    this.tokenStore.set(token, {payload, createdAt: Date.now()});
+                    setTimeout(() => this.tokenStore.delete(token), expiryMs);
+                }
+
+                callback(null, token);
+            });
+            return;
+        }
+
+        // Async version
+        const token = await new Promise((res, rej) => {
+            jwt.sign(payload, this.secret, { expiresIn: expiryJwt }, (err, t) => {
+                if(err) rej(err);
+                else res(t);
+            });
+        });
+
+        if(this.storeType === 'memory') {
+            this.tokenStore.set(token, {payload, createdAt: Date.now()});
+            setTimeout(() => this.tokenStore.delete(token), expiryMs);
+        } else if(this.storeType === 'redis') {
+            await this.redis.set(token, JSON.stringify({payload, createdAt: Date.now()}), "EX", Math.floor(expiryMs/1000));
+        }
+
+        return token;
+    }
+
+    async verify(token, callback) {
+        // Callback version
+        if (callback && typeof callback === 'function') {
+            if (this.storeType === 'redis') {
+                return callback(new Error("⚠️ Redis requires async/await. Use Promise style."));
+            }
+
+            if (this.storeType === 'memory' && !this.tokenStore.has(token)) {
+                return callback(new Error("❌ Token not found or revoked"));
+            }
+
+            jwt.verify(token, this.secret, (err, decoded) => {
+                if (err) {
+                    if (err.name === "TokenExpiredError") return callback(new Error("❌ Token expired!"));
+                    if (err.name === "JsonWebTokenError") return callback(new Error("❌ Invalid token!"));
+                    return callback(new Error("❌ JWT error: " + err.message));
+                }
+                callback(null, decoded);
+            });
+            return;
+        }
+
+        // Async / Promise version
+        try {
+            if (this.storeType === 'memory' && !this.tokenStore.has(token)) {
+                throw new Error("❌ Token not found or revoked");
+            }
+
+            if (this.storeType === 'redis') {
+                const data = await this.redis.get(token);
+                if (!data) throw new Error("❌ Token not found or revoked");
+            }
+
+            const decoded = jwt.verify(token, this.secret);
+            return decoded;
+        } catch (err) {
+            throw new Error("❌ JWT verification failed: " + err.message);
+        }
+    }
+
+    async decode(token, callback) {
+        try {
+            const decoded = jwt.decode(token);
+            // if (callback && typeof callback === 'function') return callback(null, decoded);
+            return decoded;
+        } catch (err) {
+            // if (callback && typeof callback === 'function') return callback(err);
+            throw err;
+        }
+    }
+
+    // Optional: manual token revoke for memory/redis
+    async revoke(token, revokeTime = 0) {
+        // function parseTime(str) {
+        //     if (typeof str === 'number') return str; // already in ms
+        //     if (typeof str !== 'string') return 0;
+
+        //     const num = parseInt(str);
+        //     if (str.endsWith('h')) return num * 60 * 60 * 1000;
+        //     if (str.endsWith('m')) return num * 60 * 1000;
+        //     if (str.endsWith('s')) return num * 1000;
+        //     return num;
+        // }
+
+        const revokeMs = parseTime(revokeTime);
+        const revokeAfter = Date.now() + revokeMs; 
+
+
+        if (this.storeType === 'memory') {
+            if(revokeTime == 0){
+                this.tokenStore.delete(token);
+            }else{
+                setTimeout(() => this.tokenStore.delete(token), revokeAfter);
+            }
+        }else if(this.storeType == 'redis'){
+            if(revokeTime == 0){
+                await this.redis.del(token);
+            }else{
+                await this.redis.pexpire(token, revokeAfter);
+            }
+        }else{
+            throw new Error("❌ {storeTokens} should be 'memory' or 'redis' or 'none'");
+        }
+    }
+
+    async isRevoked(token) {
+        if(this.storeType === 'memory') {
+            const data = this.tokenStore.get(token);
+            return data?.revokedUntil && data.revokedUntil > Date.now();
+        } else if(this.storeType === 'redis') {
+             const dataRaw = await this.redis.get(token);
+            if (!dataRaw) return true;
+            const data = JSON.parse(dataRaw);
+            return data?.revokedUntil && data.revokedUntil > Date.now();
+        } else {
+            return false; // no store, can't revoke
+        }
+    }
+
+    async revokeUntil(token, timestamp){
+        // function parseTime(str) {
+        //     if (typeof str === 'number') return str; // already in ms
+        //     if (typeof str !== 'string') return 0;
+
+        //     const num = parseInt(str);
+        //     if (str.endsWith('h')) return num * 60 * 60 * 1000;
+        //     if (str.endsWith('m')) return num * 60 * 1000;
+        //     if (str.endsWith('s')) return num * 1000;
+        //     return num;
+        // }
+
+        const revokeMs = parseTime(timestamp);
+        const revokedUntil = Date.now() + revokeMs; 
+
+        if(this.storeType == 'memory'){
+            const data = this.tokenStore.get(token) || {};
+            this.tokenStore.set(token, {...data, revokedUntil: revokedUntil});
+        }else if(this.storeType == 'redis'){
+            const dataRaw = await this.redis.get(token);
+            const data = dataRaw ? JSON.parse(dataRaw) : {};
+            data.revokedUntil = revokedUntil;
+            await this.redis.set(token, JSON.stringify(data));
+        }else{
+            throw new Error("{storeTokens} should be 'memory' or 'redis'");
+        }
+    }
+}
+
+module.exports = JWTManager;