auth-verify 1.0.3 → 1.2.0

package/index.js

@@ -1,6 +1,7 @@
 const JWTManager = require("./src/jwt");
 const OTPManager = require("./src/otp");
 const SessionManager = require("./src/session");
+const OAuthManager = require("./src/oauth")
 
 class AuthVerify {
   constructor(options = {}) {
@@ -39,6 +40,8 @@ class AuthVerify {
     //   }
     // }
     // ✅ No getters — directly reference otp.dev (it's a plain object)
+
+    this.oauth = new OAuthManager();
   }
   
   // Session helpers

package/package.json

@@ -2,6 +2,7 @@
   "dependencies": {
     "axios": "^1.12.2",
     "crypto": "^1.0.1",
+    "express": "^5.1.0",
     "ioredis": "^5.8.1",
     "jsonwebtoken": "^9.0.2",
     "node-telegram-bot-api": "^0.66.0",
@@ -11,7 +12,7 @@
     "uuid": "^13.0.0"
   },
   "name": "auth-verify",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "A simple Node.js library for sending and verifying OTP via email",
   "main": "index.js",
   "scripts": {
@@ -43,6 +44,5 @@
   "bugs": {
     "url": "https://github.com/jahongir2007/auth-verify/issues"
   },
-  "homepage": "https://jahongir2007.github.io/auth-verify/",
-  "devDependencies": {}
+  "homepage": "https://jahongir2007.github.io/auth-verify/"
 }

package/readme.md

@@ -1,17 +1,15 @@
 # auth-verify
 
 **auth-verify** is a Node.js authentication utility that provides:
-- Secure OTP (one-time password) generation and verification
-- Sending OTPs via Email, SMS (pluggable helpers), and Telegram bot
-- JWT creation, verification and optional token revocation with memory/Redis storage
-- Session management (in-memory or Redis)
-- Developer extensibility: custom senders and `auth.register.sender()` / `auth.use(name).send(...)`
-
-> This README documents the code structure and APIs found in the library files you provided (OTPManager, JWTManager, SessionManager, AuthVerify).
-
+- ✅ Secure OTP (one-time password) generation and verification
+- ✅ Sending OTPs via Email, SMS (pluggable helpers), and Telegram bot
+- ✅ JWT creation, verification and optional token revocation with memory/Redis storage
+- ✅ Session management (in-memory or Redis)
+- ✅ New: OAuth 2.0 integration for Google, Facebook, GitHub, and X (Twitter)
+- ⚙️ Developer extensibility: custom senders and `auth.register.sender()` / `auth.use(name).send(...)`
 ---
 
-## Installation
+## 🧩 Installation
 
 ```bash
 # from npm (when published)
@@ -23,16 +21,16 @@ npm install auth-verify
 
 ---
 
-## Quick overview
+## ⚙️ Quick overview
 
 - `AuthVerify` (entry): constructs and exposes `.jwt`, `.otp`, and (optionally) `.session` managers.
 - `JWTManager`: sign, verify, decode, revoke tokens. Supports `storeTokens: "memory" | "redis" | "none"`.
 - `OTPManager`: generate, store, send, verify, resend OTPs. Supports `storeTokens: "memory" | "redis" | "none"`. Supports email, SMS helper, Telegram bot, and custom dev senders.
 - `SessionManager`: simple session creation/verification/destroy with memory or Redis backend.
-
+- `OAuthManager`: Handle OAuth 2.0 logins for Google, Facebook, GitHub, X
 ---
 
-## Example: Initialize library (CommonJS)
+## 🚀 Example: Initialize library (CommonJS)
 
 ```js
 const AuthVerify = require('auth-verify');
@@ -48,7 +46,7 @@ const auth = new AuthVerify({
 
 ---
 
-## JWT usage
+## 🔐 JWT Usage
 
 ```js
 // create JWT
@@ -71,15 +69,49 @@ await auth.jwt.revokeUntil(token, '10m');
 // check if token is revoked (returns boolean)
 const isRevoked = await auth.jwt.isRevoked(token);
 ```
+### 🍪 Automatic Cookie Handling (v1.1.0+)
+
+You can now automatically store and verify JWTs via HTTP cookies — no need to manually send them!
+```js
+const AuthVerify = require("auth-verify");
+const express = require("express");
+const app = express();
+
+const auth = new AuthVerify({
+  jwtSecret: "supersecret", storeTokens: "memory"
+});
+
+app.post("/login", async (req, res) => {
+  const token = await auth.jwt.sign({ userId: 1 }, "5s", { res });
+  res.json({ token }); // token is also set as cookie automatically
+});
+
+app.get("/verify", async (req, res) => {
+  try {
+    const data = await auth.jwt.verify(req); // auto reads from cookie
+    res.json({ valid: true, data });
+  } catch (err) {
+    res.json({ valid: false, error: err.message });
+  }
+});
+
+app.listen(3000, () => console.log("🚀 Server running at http://localhost:3000"));
+```
+
+What it does automatically:
+
+ - Saves token in a secure HTTP-only cookie
+ - Reads and verifies token from cookies
+ - Supports both async/await and callback styles
 
 Notes:
 - `sign` and `verify` support callback and promise styles in the implementation. When `storeTokens` is `"redis"` you should use the promise/async style (callback mode returns an error for redis in the current implementation).
 
 ---
 
-## OTP (email / sms / telegram / custom sender)
+## 🔢 OTP (email / sms / telegram / custom sender)
 
-### Configure sender
+### 🤝 Configure sender
 
 You can set the default sender (email/sms/telegram):
 
@@ -111,7 +143,7 @@ auth.otp.setSender({
 });
 ```
 
-### Generate → Save → Send (chainable)
+### ⛓️ Generate → Save → Send (chainable)
 
 OTP generation is chainable: `generate()` returns the OTP manager instance.
 
@@ -142,7 +174,7 @@ await auth.otp.message({
 });
 ```
 
-### Verify
+### ✔️ Verify
 
 ```js
 // Promise style
@@ -164,6 +196,128 @@ try {
 
 `resend` returns the new code (promise style) or calls callback.
 
+---
+## 🌍 OAuth 2.0 Integration (New in v1.2.0)
+`auth.oauth` supports login via Google, Facebook, GitHub, and X (Twitter).
+### Example (Google Login with Express)
+```js
+const express = require('express');
+const AuthVerify = require("auth-verify");
+const app = express();
+app.use(express.json());
+const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory'});
+
+const google = auth.oauth.google({clientId: 'YOUR_CLIENT_ID', clientSecret: 'YOUR_CLIENT_SECRET', redirectUri: 'http://localhost:3000/auth/google/callback'});
+app.get('/', async (req, res) => {
+      res.send(`
+    <h1>Login with Google</h1>
+    <a href="/auth/google">Login</a>
+  `);
+});
+
+
+app.get('/auth/google', (req, res) => google.redirect(res));
+
+app.get('/auth/google/callback', async (req, res)=>{
+    const code = req.query.code;
+    try {
+        const user = await google.callback(code);
+        res.send(`
+            <h2>Welcome, ${user.name}!</h2>
+            <img src="${user.picture}" width="100" style="border-radius:50%">
+            <p>Email: ${user.email}</p>
+            <p>Access Token: ${user.access_token.slice(0, 20)}...</p>
+        `);
+    } catch(err){
+        res.status(500).send("Error: " + err.message);
+    }
+});
+
+app.listen(3000, ()=>{
+    console.log('Server is running...');
+});
+```
+---
+### API documentation for OAuth
+ - `auth.oauth.google({...})` for making connection to your Google cloud app.
+ - `google.redirect(res)` for sending user/client to the Google OAuth page for verifying and selecting his accaount
+ - `google.callback(code)` for exchanging server code to the user/client token.
+
+### Other examples with other platforms
+```js
+const express = require('express');
+const AuthVerify = require("auth-verify");
+const app = express();
+app.use(express.json());
+const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory'});
+
+// --- Example: FACEBOOK LOGIN ---
+const facebook = auth.oauth.facebook({
+  clientId: "YOUR_FB_APP_ID",
+  clientSecret: "YOUR_FB_APP_SECRET",
+  redirectUri: "http://localhost:3000/auth/facebook/callback",
+});
+
+// --- Example: GITHUB LOGIN ---
+const github = auth.oauth.github({
+  clientId: "YOUR_GITHUB_CLIENT_ID",
+  clientSecret: "YOUR_GITHUB_CLIENT_SECRET",
+  redirectUri: "http://localhost:3000/auth/github/callback",
+});
+
+// --- Example: X (Twitter) LOGIN ---
+const twitter = auth.oauth.x({
+  clientId: "YOUR_TWITTER_CLIENT_ID",
+  clientSecret: "YOUR_TWITTER_CLIENT_SECRET",
+  redirectUri: "http://localhost:3000/auth/x/callback",
+});
+
+
+// ===== FACEBOOK ROUTES =====
+app.get("/auth/facebook", (req, res) => facebook.redirect(res));
+
+app.get("/auth/facebook/callback", async (req, res) => {
+  try {
+    const { code } = req.query;
+    const user = await facebook.callback(code);
+    res.json({ success: true, provider: "facebook", user });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+
+// ===== GITHUB ROUTES =====
+app.get("/auth/github", (req, res) => github.redirect(res));
+
+app.get("/auth/github/callback", async (req, res) => {
+  try {
+    const { code } = req.query;
+    const user = await github.callback(code);
+    res.json({ success: true, provider: "github", user });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+
+// ===== X (TWITTER) ROUTES =====
+app.get("/auth/x", (req, res) => twitter.redirect(res));
+
+app.get("/auth/x/callback", async (req, res) => {
+  try {
+    const { code } = req.query;
+    const user = await twitter.callback(code);
+    res.json({ success: true, provider: "x", user });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+
+app.listen(PORT, () => console.log(`🚀 Server running at http://localhost:${PORT}`));
+
+```   
 ---
 
 ## Telegram integration
@@ -247,9 +401,12 @@ auth-verify/
 ├─ package.json
 ├─ src/
 │  ├─ index.js         // exports AuthVerify
-│  ├─ jwt.js
-│  ├─ otp.js
-│  ├─ session.js
+│  ├─ jwt/
+|  |  ├─ index.js
+|  |  ├─ cookie/index.js
+│  ├─ /otp/index.js
+│  ├─ /session/index.js
+|  ├─ /oauth/index.js
 │  └─ helpers/helper.js
 ```
 

package/src/jwt/cookie/index.js

@@ -0,0 +1,29 @@
+class CookieManager {
+  static setCookie(res, name, value, options = {}) {
+    if (!res || typeof res.setHeader !== 'function') {
+      throw new Error("Response object must have setHeader() method");
+    }
+
+    let cookieStr = `${name}=${encodeURIComponent(value)}; Path=/;`;
+
+    if (options.httpOnly) cookieStr += " HttpOnly;";
+    if (options.secure) cookieStr += " Secure;";
+    if (options.maxAge) cookieStr += ` Max-Age=${Math.floor(options.maxAge / 1000)};`;
+    if (options.sameSite) cookieStr += ` SameSite=${options.sameSite};`;
+    if (options.domain) cookieStr += ` Domain=${options.domain};`;
+
+    const existing = res.getHeader('Set-Cookie') || [];
+    const newCookies = Array.isArray(existing) ? [...existing, cookieStr] : [cookieStr];
+    res.setHeader('Set-Cookie', newCookies);
+  }
+
+  static getCookie(req, name) {
+    const cookieHeader = req.headers?.cookie;
+    if (!cookieHeader) return null;
+    const cookies = cookieHeader.split(';').map(c => c.trim());
+    const found = cookies.find(c => c.startsWith(name + '='));
+    return found ? decodeURIComponent(found.split('=')[1]) : null;
+  }
+}
+
+module.exports = CookieManager;

package/src/jwt/index.js

@@ -1,6 +1,250 @@
+// const jwt = require("jsonwebtoken");
+// const Redis = require("ioredis");
+// const { parseTime } = require('../helpers/helper');
+// const CookieManager = require('./cookie');
+
+// 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, options = {}, 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'); 
+
+//          // Auto-set cookie if res provided
+//         if(typeof options == 'function'){
+//             callback = options;
+//         }
+
+        
+//         // 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 (options.res) {
+//                     CookieManager.setCookie(options.res, 'jwt_token', token, {
+//                         httpOnly: true,
+//                         secure: options.secure ?? true,
+//                         sameSite: 'Strict',
+//                         maxAge: this._parseTime(expiresIn),
+//                     });
+//                 }else 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 (options.res) {
+//             CookieManager.setCookie(options.res, 'jwt_token', token, {
+//                 httpOnly: true,
+//                 secure: options.secure ?? true,
+//                 sameSite: 'Strict',
+//                 maxAge: this._parseExpiry(expiresIn),
+//             });
+//         }else 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) {
+
+//         let cookieToken;
+//         if(typeof token == 'object' && token.headers){
+//             cookieToken = CookieManager.getCookie(token, 'jwt_token');
+//             if (!token) throw new Error('JWT not found in cookies');
+
+//             try{
+//                 const decoded = jwt.verify(cookieToken, this.secret);
+//                 return decoded;
+//             }catch(err){
+//                 throw new Error('Invalid or expired token');
+//             }
+//         }
+
+//         // 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;
+
 const jwt = require("jsonwebtoken");
 const Redis = require("ioredis");
-const { parseTime } = require('../helpers/helper');
+const CookieManager = require("./cookie");
 
 class JWTManager {
     constructor(secret, options = {}) {
@@ -8,199 +252,139 @@ class JWTManager {
         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'");
-            }
+        if (this.storeType === "memory") {
+            this.tokenStore = new Map();
+        } else if (this.storeType === "redis") {
+            this.redis = new Redis(options.redisUrl || "redis://localhost:6379");
+        } else if (this.storeType !== "none") {
+            throw new Error("{storeTokens} must 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
-
+        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;
+        if (expiry.endsWith("h")) return num * 3600000;
+        if (expiry.endsWith("m")) return num * 60000;
+        if (expiry.endsWith("s")) return num * 1000;
         return num;
     }
 
-    async sign(payload, expiry, callback) {
-        if (typeof expiry === 'function') {
+    async sign(payload, expiry = "1h", options = {}, callback) {
+        if (typeof expiry === "function") {
             callback = expiry;
-            expiry = '1h'; // default
+            expiry = "1h";
+        }
+        if (typeof options === "function") {
+            callback = options;
+            options = {};
         }
 
-        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"));
+        const expiryMs = this._parseExpiry(expiry);
+        const expiryJwt = typeof expiry === "number"
+            ? Math.floor(expiry / 1000)
+            : expiry;
 
-            jwt.sign(payload, this.secret, { expiresIn: expiryJwt }, (err, token) => {
-                if(err) return callback(err);
+        const createToken = () =>
+            new Promise((resolve, reject) => {
+                jwt.sign(payload, this.secret, { expiresIn: expiryJwt }, (err, token) => {
+                    if (err) return reject(err);
+                    resolve(token);
+                });
+            });
 
-                if(this.storeType === 'memory') {
-                    this.tokenStore.set(token, {payload, createdAt: Date.now()});
-                    setTimeout(() => this.tokenStore.delete(token), expiryMs);
-                }
+        const token = await createToken();
 
-                callback(null, token);
-            });
-            return;
+        // Save token if needed
+        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));
         }
 
-        // 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);
+        // Auto cookie support
+        if (options.res) {
+            CookieManager.setCookie(options.res, "jwt_token", token, {
+                httpOnly: true,
+                secure: options.secure ?? true,
+                sameSite: "Strict",
+                maxAge: expiryMs,
             });
-        });
-
-        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));
         }
 
+        if (callback) return callback(null, token);
         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."));
-            }
+    async verify(input, callback) {
+        let token = input;
 
-            if (this.storeType === 'memory' && !this.tokenStore.has(token)) {
-                return callback(new Error("❌ Token not found or revoked"));
-            }
+        // If request object provided
+        if (typeof input === "object" && input.headers) {
+            token =
+                CookieManager.getCookie(input, "jwt_token") ||
+                (input.headers.authorization
+                    ? input.headers.authorization.replace("Bearer ", "")
+                    : null);
 
-            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;
+            if (!token) throw new Error("JWT not found in cookies or headers");
         }
 
-        // Async / Promise version
         try {
-            if (this.storeType === 'memory' && !this.tokenStore.has(token)) {
-                throw new Error("❌ Token not found or revoked");
-            }
+            const decoded = jwt.verify(token, this.secret);
+
+            if (this.storeType === "memory" && !this.tokenStore.has(token))
+                throw new Error("Token not found or revoked");
 
-            if (this.storeType === 'redis') {
+            if (this.storeType === "redis") {
                 const data = await this.redis.get(token);
-                if (!data) throw new Error("❌ Token not found or revoked");
+                if (!data) throw new Error("Token not found or revoked");
             }
 
-            const decoded = jwt.verify(token, this.secret);
+            if (callback) return callback(null, decoded);
             return decoded;
         } catch (err) {
-            throw new Error("❌ JWT verification failed: " + err.message);
+            if (callback) return callback(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;
-        }
+    async decode(token) {
+        return jwt.decode(token);
     }
 
-    // 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'");
+        const revokeMs = this._parseExpiry(revokeTime);
+
+        if (this.storeType === "memory") {
+            if (revokeTime === 0) this.tokenStore.delete(token);
+            else setTimeout(() => this.tokenStore.delete(token), revokeMs);
+        } else if (this.storeType === "redis") {
+            if (revokeTime === 0) await this.redis.del(token);
+            else await this.redis.pexpire(token, revokeMs);
         }
     }
 
     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
-        }
+        if (this.storeType === "memory") return !this.tokenStore.has(token);
+        if (this.storeType === "redis") return !(await this.redis.get(token));
+        return false;
     }
 
-    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; 
+    async revokeUntil(token, timestamp) {
+        const revokeMs = this._parseExpiry(timestamp);
+        const revokedUntil = Date.now() + revokeMs;
 
-        if(this.storeType == 'memory'){
+        if (this.storeType === "memory") {
             const data = this.tokenStore.get(token) || {};
-            this.tokenStore.set(token, {...data, revokedUntil: revokedUntil});
-        }else if(this.storeType == 'redis'){
+            this.tokenStore.set(token, { ...data, 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'");
         }
     }
 }

package/src/oauth/index.js

@@ -0,0 +1,180 @@
+// src/managers/oauth.js
+
+class OAuthManager {
+    constructor(config = {}) {
+        this.providers = config.providers || {};
+    }
+
+    // --- GOOGLE LOGIN ---
+    google({ clientId, clientSecret, redirectUri }) {
+        return {
+            redirect(res) {
+                const googleURL =
+                    "https://accounts.google.com/o/oauth2/v2/auth?" +
+                    new URLSearchParams({
+                        client_id: clientId,
+                        redirect_uri: redirectUri,
+                        response_type: "code",
+                        scope: "openid email profile",
+                        access_type: "offline",
+                        prompt: "consent",
+                    });
+                res.redirect(googleURL);
+            },
+
+            async callback(code) {
+                // Step 1: Exchange code for access token
+                const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+                    body: new URLSearchParams({
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                        code,
+                        redirect_uri: redirectUri,
+                        grant_type: "authorization_code",
+                    }),
+                });
+
+                const tokenData = await tokenRes.json();
+                if (tokenData.error) throw new Error("OAuth Error: " + tokenData.error);
+
+                // Step 2: Get user info
+                const userRes = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+                    headers: { Authorization: `Bearer ${tokenData.access_token}` },
+                });
+                const user = await userRes.json();
+
+                return { ...user, access_token: tokenData.access_token };
+            },
+        };
+    }
+
+     // --- FACEBOOK LOGIN ---
+    facebook({ clientId, clientSecret, redirectUri }) {
+        return {
+            redirect(res) {
+                const fbURL =
+                    "https://www.facebook.com/v19.0/dialog/oauth?" +
+                    new URLSearchParams({
+                        client_id: clientId,
+                        redirect_uri: redirectUri,
+                        scope: "email,public_profile",
+                        response_type: "code",
+                    });
+                res.redirect(fbURL);
+            },
+
+            async callback(code) {
+                const tokenRes = await fetch(
+                    `https://graph.facebook.com/v19.0/oauth/access_token?` +
+                        new URLSearchParams({
+                            client_id: clientId,
+                            client_secret: clientSecret,
+                            redirect_uri: redirectUri,
+                            code,
+                        })
+                );
+
+                const tokenData = await tokenRes.json();
+                if (tokenData.error) throw new Error("OAuth Error: " + tokenData.error.message);
+
+                const userRes = await fetch(
+                    `https://graph.facebook.com/me?fields=id,name,email,picture&access_token=${tokenData.access_token}`
+                );
+                const user = await userRes.json();
+
+                return { ...user, access_token: tokenData.access_token };
+            },
+        };
+    }
+
+    // --- GITHUB LOGIN ---
+    github({ clientId, clientSecret, redirectUri }) {
+        return {
+            redirect(res) {
+                const githubURL =
+                    "https://github.com/login/oauth/authorize?" +
+                    new URLSearchParams({
+                        client_id: clientId,
+                        redirect_uri: redirectUri,
+                        scope: "user:email",
+                        allow_signup: "true",
+                    });
+                res.redirect(githubURL);
+            },
+
+            async callback(code) {
+                const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Accept: "application/json" },
+                    body: JSON.stringify({
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                        code,
+                        redirect_uri: redirectUri,
+                    }),
+                });
+
+                const tokenData = await tokenRes.json();
+                if (tokenData.error) throw new Error("OAuth Error: " + tokenData.error);
+
+                const userRes = await fetch("https://api.github.com/user", {
+                    headers: { Authorization: `Bearer ${tokenData.access_token}` },
+                });
+                const user = await userRes.json();
+
+                return { ...user, access_token: tokenData.access_token };
+            },
+        };
+    }
+
+    // --- X (TWITTER) LOGIN ---
+    x({ clientId, clientSecret, redirectUri }) {
+        return {
+            redirect(res) {
+                const twitterURL =
+                    "https://twitter.com/i/oauth2/authorize?" +
+                    new URLSearchParams({
+                        response_type: "code",
+                        client_id: clientId,
+                        redirect_uri: redirectUri,
+                        scope: "tweet.read users.read offline.access",
+                        state: "state123",
+                        code_challenge: "challenge",
+                        code_challenge_method: "plain",
+                    });
+                res.redirect(twitterURL);
+            },
+
+            async callback(code) {
+                const tokenRes = await fetch("https://api.twitter.com/2/oauth2/token", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/x-www-form-urlencoded",
+                        Authorization:
+                            "Basic " + Buffer.from(`${clientId}:${clientSecret}`).toString("base64"),
+                    },
+                    body: new URLSearchParams({
+                        code,
+                        grant_type: "authorization_code",
+                        redirect_uri: redirectUri,
+                        code_verifier: "challenge",
+                    }),
+                });
+
+                const tokenData = await tokenRes.json();
+                if (tokenData.error) throw new Error("OAuth Error: " + tokenData.error);
+
+                const userRes = await fetch("https://api.twitter.com/2/users/me", {
+                    headers: { Authorization: `Bearer ${tokenData.access_token}` },
+                });
+                const user = await userRes.json();
+
+                return { ...user, access_token: tokenData.access_token };
+            },
+        };
+    }
+}
+
+module.exports = OAuthManager;

package/test.js

@@ -101,9 +101,11 @@
 //   }catch(err){}
 // })();
 
-const TelegramBot = require("node-telegram-bot-api");
+// 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";
 
@@ -149,7 +151,49 @@ const AuthVerify = require("./index"); // your library
 //   }
 // });
 
-const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory', otpExpiry: '5m' });
+const auth = new AuthVerify({ jwtSecret: 's', storeTokens: 'memory'});
+
+const google = auth.oauth.google({clientId: '145870939941-qgeskqo8qlaqqm1osed6f5r8bhl866qk.apps.googleusercontent.com', clientSecret: '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', redirectUri: 'http://localhost:3000/auth/google/callback'});
+app.get('/', async (req, res) => {
+      res.send(`
+    <h1>Login with Google</h1>
+    <a href="/auth/google">Login</a>
+  `);
+});
+
+
+app.get('/auth/google', (req, res) => google.redirect(res));
+
+app.get('/auth/google/callback', async (req, res)=>{
+    const code = req.query.code;
+    try {
+        const user = await google.callback(code);
+        res.send(`
+            <h2>Welcome, ${user.name}!</h2>
+            <img src="${user.picture}" width="100" style="border-radius:50%">
+            <p>Email: ${user.email}</p>
+            <p>Access Token: ${user.access_token.slice(0, 20)}...</p>
+        `);
+    } catch(err){
+        res.status(500).send("Error: " + err.message);
+    }
+});
+
+app.listen(3000, ()=>{
+    console.log('Server is running...');
+});
+// 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 });
+//     }
+// });
+
+// app.listen(3000, ()=>{
+//     console.log('App is running')
+// });
 
 // auth.register.sender("consoleOtp", async ({ to, code }) => {
 //     console.log(`🔑 Sending OTP ${code} to ${to}`);