auth-verify 0.0.2 → 1.1.0

package/src/session/index.js

@@ -0,0 +1,81 @@
+const Redis = require("ioredis");
+const { v4: uuidv4 } = require("uuid");
+
+class SessionManager {
+    constructor(options = {}) {
+        this.storeType = options.storeTokens || 'memory'; // 'memory' or 'redis'
+
+        if (this.storeType === 'memory') {
+            this.sessions = new Map();
+        } else if (this.storeType === 'redis') {
+            this.redis = new Redis(options.redisUrl || "redis://localhost:6379");
+        } else {
+            throw new Error("{storeTokens} should be 'memory' or 'redis'");
+        }
+    }
+
+    // Create a session
+    async create(userId, options = {}) {
+        const sessionId = uuidv4();
+        const expiresIn = options.expiresIn || 3600; // default 1 hour
+        if (typeof expiresIn === "string") {
+        const timeValue = parseInt(expiresIn);
+            if (expiresIn.endsWith("s")) expiresIn = timeValue;
+            else if (expiresIn.endsWith("m")) expiresIn = timeValue * 60;
+            else if (expiresIn.endsWith("h")) expiresIn = timeValue * 60 * 60;
+            else if (expiresIn.endsWith("d")) expiresIn = timeValue * 60 * 60 * 24;
+            else throw new Error("Invalid expiresIn format (use s, m, h, d)");
+        }
+        const now = Date.now();
+
+        const sessionData = {
+            userId,
+            createdAt: now,
+            expiresAt: now + expiresIn * 1000
+        };
+
+        if (this.storeType === 'memory') {
+            this.sessions.set(sessionId, sessionData);
+        } else if (this.storeType === 'redis') {
+            await this.redis.set(
+                sessionId,
+                JSON.stringify(sessionData),
+                "EX",
+                expiresIn
+            );
+        }
+
+        return sessionId;
+    }
+
+    // Verify a session
+    async verify(sessionId) {
+        let data;
+        if (this.storeType === 'memory') {
+            data = this.sessions.get(sessionId);
+        } else if (this.storeType === 'redis') {
+            const raw = await this.redis.get(sessionId);
+            data = raw ? JSON.parse(raw) : null;
+        }
+
+        if (!data) throw new Error("Session not found or expired");
+
+        if (Date.now() > data.expiresAt) {
+            await this.destroy(sessionId);
+            throw new Error("Session expired");
+        }
+
+        return data.userId;
+    }
+
+    // Destroy a session
+    async destroy(sessionId) {
+        if (this.storeType === 'memory') {
+            this.sessions.delete(sessionId);
+        } else if (this.storeType === 'redis') {
+            await this.redis.del(sessionId);
+        }
+    }
+}
+
+module.exports = SessionManager;

package/test.js

@@ -1,34 +1,181 @@
-const Verifier = require("./Verifier"); // or "./index.js" if you renamed it
-
-const verifier = new Verifier({
-    serv: "Gmail",
-    sender: "your_email@gmail.com",
-    pass: "your_app_password",
-    otp: {
-        length: 6,
-        expMin: 5,
-        limit: 5,
-        cooldown: 60
+// const AuthVerify = require('./index'); // your library entry
+// const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory', otpExpiry: 300 });
+// const TelegramBot = require("node-telegram-bot-api");
+
+// auth.otp.setSender({
+//   via: 'telegram'
+// });
+
+// // callback flow (nested, but correct)
+// // auth.otp.generate(6, (err, code) => {
+// //   if (err) return console.error('generate err', err);
+
+// //   auth.otp.set('jahongir.sobirov.2007@mail.ru', (err) => {
+// //     if (err) return console.error('set err', err);
+// //     console.log('OTP stored in memory:', auth.otp.otpCode);
+
+// //     auth.otp.message({
+// //       to: 'jahongir.sobirov.2007@mail.ru',
+// //       subject: 'Your OTP',
+// //       text: `Your OTP is ${auth.otp.otpCode}`
+// //     }, (err, info) => {
+// //       if (err) return console.error('message err', err);
+// //       console.log('message sent ok', info && info.messageId);
+
+// //       // now verify
+// //       auth.otp.verify({ check: 'jahongir.sobirov.2007@mail.ru', code: "auth.otp.otpCode" }, (err, ok) => {
+// //         if (err){
+// //           // Resend OTP
+// //           auth.otp.resend("jahongir.sobirov.2007@mail.ru", (err, info) => {
+// //             if(err) return console.log("Resend failed:", err);
+// //             console.log("New OTP sent!");
+// //           });
+// //         };
+
+// //         console.log('Verified:', ok);
+// //       });
+// //     });
+// //   });
+// // });
+
+// // (async () => {
+// //   // try {
+// //     // 1️⃣ Generate OTP
+// //     auth.otp.generate(5).set('+998934313977'); // or auth.otp.code
+// //   //   // 2️⃣ Store OTP
+// //   //   await auth.otp.set('jahongir.sobirov.2007@mail.ru');
+// //   //   console.log('OTP stored in memory:', auth.otp.code);
+
+// //   //   // 3️⃣ Send OTP via email
+// //   //   const info = await auth.otp.message({
+// //   //     to: 'jahongir.sobirov.2007@mail.ru',
+// //   //     subject: 'Your OTP',
+// //   //     html: `Your OTP is ${auth.otp.code}`,
+// //   //   });
+// //   //   console.log('Message sent OK:', info && info.messageId);
+
+// //   //   // 4️⃣ Verify OTP
+// //   //   try {
+// //   //     const verified = await auth.otp.verify({
+// //   //       check: 'jahongir.sobirov.2007@mail.ru',
+// //   //       code: '123456', // user's input
+// //   //     });
+// //   //     console.log('Verified:', verified);
+// //   //   } catch (verifyErr) {
+// //   //     console.log('Verification failed:', verifyErr.message);
+
+// //   //     // 5️⃣ Resend OTP if verification fails
+// //   //     try {
+// //   //       const newCode = await auth.otp.resend('jahongir.sobirov.2007@mail.ru');
+// //   //       console.log('New OTP sent:', newCode);
+// //   //     } catch (resendErr) {
+// //   //       console.log('Resend failed:', resendErr.message);
+// //   //     }
+// //   //   }
+// //   // } catch (err) {
+// //   //   console.error('Error:', err);
+// //   // }
+// //   await auth.otp.message({
+// //     to: '+998934313977',
+// //   });
+// //   console.log(`OTP was sent`);
+// // })();
+
+// // Set custom logger
+// auth.setLogger(console);
+
+// // Access developer tools
+// auth.dev.sender(async ({to, code})=>{
+//   const token = '6657700716:AAGW3s5Yxk5SrRH7yRqrgG-kVrG9a6PXBxk';
+//   const bot = new TelegramBot(token, {polling: false});
+//   bot.onText(/\/start/, async (msg)=>{
+//     const chatId = msg.chat.id;
+//     await bot.sendMessage(chatId, `🔐 Your verification code is: <b>${code}</b>`, {parse_mode: "HTML"})
+//     console.log(`✅ OTP ${code} sent to Telegram chat ${chatId}`);
+//   });
+// });
+
+// (async ()=>{
+//   try{
+
+//   }catch(err){}
+// })();
+
+// const TelegramBot = require("node-telegram-bot-api");
+const express = require('express');
+const AuthVerify = require("./index"); // your library
+const app = express();
+app.use(express.json());
+// // Your bot token from BotFather
+// const BOT_TOKEN = "6657700716:AAGW3s5Yxk5SrRH7yRqrgG-kVrG9a6PXBxk";
+
+// // Step 1: Create a Telegram bot with polling enabled (to listen to /start)
+// const bot = new TelegramBot(BOT_TOKEN, { polling: true });
+
+// // Step 2: Create AuthVerify instance
+// const auth = new AuthVerify({ jwtSecret: "super_secret_key" , storeTokens: 'memory'});
+
+// // Step 3: Setup dev sender (so OTP messages are sent through Telegram)
+// auth.dev.sender({
+//   send: async ({ to, code }) => {
+//     await bot.sendMessage(to, `🔑 Your OTP code is: ${code}`);
+//   },
+// });
+
+// // Step 4: When user sends /start, bot saves their chatId and sends an OTP
+// bot.onText(/\/start/, async (msg) => {
+//   const chatId = msg.chat.id;
+//   const username = msg.from.username || msg.from.first_name;
+
+//   await bot.sendMessage(chatId, `👋 Hello ${username}! We'll send you an OTP now.`);
+
+//   // Generate and send OTP using auth.otp
+//   const otpCode = await auth.otp.generate(chatId); // you can customize
+//   await auth.otp.send(chatId); // uses our custom sender!
+// });
+
+// // Step 5: Listen for OTP input
+// bot.on("message", async (msg) => {
+//   const chatId = msg.chat.id;
+//   const text = msg.text;
+
+//   // Ignore /start
+//   if (text.startsWith("/")) return;
+
+//   // Check if entered OTP is valid
+//   const isValid = await auth.otp.verify(chatId, text);
+//   if (isValid) {
+//     bot.sendMessage(chatId, "✅ OTP verified successfully!");
+//   } else {
+//     bot.sendMessage(chatId, "❌ Invalid or expired OTP. Try again!");
+//   }
+// });
+
+const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory'});
+
+app.get('/', async (req, res) => {
+    const token = await auth.jwt.sign({ id: 1, role: 'user' }, '1h', { res });
+    res.send(`JWT saved in cookie!`);
+});
+
+app.get('/verify', async (req, res) => {
+    try {
+        const data = await auth.jwt.verify({ headers: req.headers });
+        res.json({ valid: true, data });
+    } catch (err) {
+        res.status(401).json({ valid: false, error: err.message });
     }
 });
 
-// Test sending OTP
-verifier
-    .subject("Your OTP: {otp}")
-    .text("Your OTP code is {otp}")
-    .html("<h1>{otp}</h1>")
-    .sendTo("test_user@example.com", (err, success) => {
-        if (err) return console.error("Send failed:", err.message);
-        console.log("✅ OTP sent successfully!");
-
-        // Test verifying the same OTP
-        verifier.getOTP("test_user@example.com", (err, data) => {
-            if (err) return console.error(err);
-            console.log("Current OTP in DB:", data);
-
-            verifier.code(data.code).verifyFor("test_user@example.com", (err, verified) => {
-                if (err) return console.error(err);
-                console.log("Verified?", verified);
-            });
-        });
-    });
+app.listen(3000, ()=>{
+    console.log('App is running')
+});
+
+// auth.register.sender("consoleOtp", async ({ to, code }) => {
+//     console.log(`🔑 Sending OTP ${code} to ${to}`);
+//     return true;
+// });
+
+// (async () => {
+//     await auth.use("consoleOtp").send({ to: "+998901234567", code: "654321" });
+// })();

package/auth-verify.js

@@ -1,182 +0,0 @@
-const sqlite3 = require("sqlite3").verbose();
-const nodemailer = require('nodemailer')
-const crypto = require('crypto');
-const { request } = require("http");
-
-class Verifier {
-    constructor(sender = {}){
-        this.otpLen = sender.otp?.leng || 6;
-        this.expMin = sender.otp?.expMin || 3;
-        this.limit = sender.otp?.limit || 5;
-        this.cooldown = sender.otp?.cooldown || 60;
-        // Setup SMTP
-        this.transport = nodemailer.createTransport({
-            service: `${sender.serv}`,
-            auth: {
-                user: `${sender.sender}`,
-                pass: sender.pass
-            }
-        });
-
-        this.sender = `${sender.smtp?.sender}`
-
-        //making a db for saving otp codes
-        this.db = new sqlite3.Database('./authverify.db');
-        this.db.serialize(()=>{
-            // creating a table
-            this.db.run(`
-                CREATE TABLE IF NOT EXISTS verifications (
-                email TEXT PRIMARY KEY,
-                code TEXT,
-                expiresAt TEXT,
-                requests INTEGER DEFAULT 0,
-                lastRequest TEXT 
-                )
-            `);
-        });
-
-    }
-
-     // Generate OTP securely
-    generateOTP() {
-        const buffer = crypto.randomBytes(this.otpLen);
-        const number = parseInt(buffer.toString('hex'), 16)
-        .toString()
-        .slice(0, this.otpLen);
-        return number.padStart(this.otpLen, '0');
-    }
-
-    html(html){
-        this.htmlContent = html;
-        return this;
-    }
-
-    subject(subject){
-        this.mailSubject = subject;
-        return this;
-    }
-
-    text(text){
-        this.mailText = text;
-        return this;
-    }
-
-    sendTo(email, callback){
-    
-        this.recieverEmail = email;
-        const code = this.generateOTP();
-        const expAt = new Date(Date.now() + this.expMin * 60 * 1000).toISOString();
-
-        this.db.get(`SELECT * FROM verifications WHERE email = ?`, [email], (err, row)=>{
-            if(err) return callback(err);
-
-            const now = new Date();
-            let requests = 1;
-
-            if(row){
-                const lastRequest = row.lastRequest ? new Date(row.lastRequest) : null;
-
-                if(lastRequest && now.toDateString() === lastRequest.toDateString()){
-                    requests = row.requests + 1;
-                    if(requests > this.limit){
-                        return callback(new Error("Too many OTP requests today"));
-                    }
-
-                    const diff = (now - lastRequest) / 1000;
-                    if(diff < this.cooldown){
-                        return callback(new Error(`Please wait ${Math.ceil(this.cooldown - diff)} seconds before requesting a new OTP.`));
-                    }
-                }
-            }
-
-            this.db.run(`INSERT INTO verifications (email, code, expiresAt, requests, lastRequest) VALUES (?, ?, ?, ?, ?)
-                ON CONFLICT(email) DO UPDATE SET
-                code = excluded.code, 
-                expiresAt = excluded.expiresAt, 
-                requests = excluded.requests, 
-                lastRequest = excluded.lastRequest`, [email, code, expAt, requests, now.toISOString()], (DBerr)=>{
-                if(DBerr) return callback(DBerr);
-
-                this.otpOptions = {
-                    from: this.sender,
-                    to: `${email}`,
-                    subject: this.mailSubject ? this.mailSubject.replace("{otp}", code) : undefined,
-                    text: this.mailText ? this.mailText.replace("{otp}", code) : undefined,
-                    html: this.htmlContent ? this.htmlContent.replace("{otp}", code) : undefined 
-                }
-
-                this.transport.sendMail(this.otpOptions, (emailErr, info)=>{
-                    if(emailErr) return callback(emailErr);
-
-                    // console.log('📨 Email sent:', info.response);
-                    callback(null, true); 
-                });
-
-                // console.log('💾 Code saved to DB');
-            });
-        });
-
-        return this;
-
-    }
-
-    code(userCode){
-        this.userCode = userCode
-        return this;
-    }
-
-    verifyFor(email, callback){
-        const now = new Date().toISOString();
-
-        this.db.get(`SELECT * FROM verifications WHERE email = ? AND expiresAt > ?`, [email, now], (DBerr, row)=>{
-            if(DBerr) return callback(DBerr);
-
-            // console.log(`Code was got`);
-
-            if(!row){
-                // console.log(this.recieverEmail);
-                callback(null, false)
-            }else{
-                if(row.code === this.userCode){
-                    // console.log('✅ User verified');
-                    callback(null, true);
-                }else{
-                    // console.log("❌ Code isn't correct")
-                    callback(null, false);
-                }
-            }
-        });
-    }
-
-    makeOTP(length){
-        const buffer = crypto.randomBytes(length);
-        const number = parseInt(buffer.toString('hex'), 16)
-        .toString()
-        .slice(0, length);
-        return number.padStart(length, '0');
-    }
-
-    getOTP(email, callback){
-        this.db.get(`SELECT * FROM verifications WHERE email = ?`, [email], (err, row)=>{
-            if(err) return callback(err);
-            if(!row) return callback(null, null);
-
-            callback(null, { code: row.code, expiresAt: row.expiresAt });
-        });
-    }
-
-    cleanExpired() {
-    const now = new Date().toISOString();
-    this.db.run(
-        `DELETE FROM verifications WHERE expiresAt <= ?`,
-        [now],
-        function(err) {
-            if (err) console.error("Error cleaning expired OTPs:", err.message);
-            // Optional: console.log(`${this.changes} expired OTPs removed`);
-        }
-    );
-}
-    
-}
-
-module.exports = Verifier;