jwtmoshiur 1.0.0

package/.env

@@ -0,0 +1,3 @@
+# JWT Moshiur Configuration
+JWT_SECRET=ljmsik0qrd6cg1h2kd3la
+JWT_EXPIRY=24h

package/bin/cli.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+const { initializeJwtMoshiur } = require('../dist/setup');
+
+console.log(' Initializing JWT Moshiur...');
+initializeJwtMoshiur();

package/dist/generateToken.d.ts

@@ -0,0 +1,8 @@
+interface TokenPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+    [key: string]: any;
+}
+export declare function generateToken(payload: TokenPayload): string;
+export {};

package/dist/generateToken.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToken = generateToken;
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+dotenv.config();
+const JWT_SECRET = (process.env.JWT_SECRET || 'fallback-secret');
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+function generateToken(payload) {
+    return jwt.sign(payload, JWT_SECRET, {
+        expiresIn: JWT_EXPIRY
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { initializeJwtMoshiur } from './setup';
+interface TokenPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+    [key: string]: any;
+}
+export declare function generateToken(payload: TokenPayload, options?: any): string;
+export declare function verifyToken(token: string): any;
+export declare function setup(): void;
+export { initializeJwtMoshiur };

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeJwtMoshiur = void 0;
+exports.generateToken = generateToken;
+exports.verifyToken = verifyToken;
+exports.setup = setup;
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+const setup_1 = require("./setup");
+Object.defineProperty(exports, "initializeJwtMoshiur", { enumerable: true, get: function () { return setup_1.initializeJwtMoshiur; } });
+dotenv.config();
+const JWT_SECRET = (process.env.JWT_SECRET || 'fallback-secret');
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '1h';
+function generateToken(payload, options) {
+    return jwt.sign(payload, JWT_SECRET, {
+        expiresIn: JWT_EXPIRY,
+        ...options
+    });
+}
+function verifyToken(token) {
+    try {
+        return jwt.verify(token, JWT_SECRET);
+    }
+    catch (error) {
+        throw new Error('Invalid or expired token');
+    }
+}
+function setup() {
+    return (0, setup_1.initializeJwtMoshiur)();
+}

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function initializeJwtMoshiur(): void;

package/dist/setup.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeJwtMoshiur = initializeJwtMoshiur;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+function initializeJwtMoshiur() {
+    const projectRoot = process.cwd();
+    // Generate a random secret if JWT_SECRET is not provided
+    const randomSecret = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+    // Create .env with JWT configuration
+    const envContent = `# JWT Moshiur Configuration
+JWT_SECRET=${randomSecret}
+JWT_EXPIRY=24h
+`;
+    // Check if .env exists, if not create it
+    const envPath = path_1.default.join(projectRoot, '.env');
+    if (!fs_1.default.existsSync(envPath)) {
+        fs_1.default.writeFileSync(envPath, envContent);
+        console.log('✓ .env file created with JWT configuration');
+    }
+    else {
+        // Check if JWT_SECRET already exists
+        const envData = fs_1.default.readFileSync(envPath, 'utf-8');
+        if (!envData.includes('JWT_SECRET')) {
+            fs_1.default.appendFileSync(envPath, `\n${envContent}`);
+            console.log('✓ JWT configuration added to existing .env');
+        }
+        else {
+            console.log('✓ JWT configuration already exists in .env');
+        }
+    }
+    // Create utils directory
+    const utilsDir = path_1.default.join(projectRoot, 'utils');
+    if (!fs_1.default.existsSync(utilsDir)) {
+        fs_1.default.mkdirSync(utilsDir);
+    }
+    // Determine if this is a TypeScript project
+    const isTypeScript = fs_1.default.existsSync(path_1.default.join(projectRoot, 'tsconfig.json'));
+    // Get the path to templates in the jwtmoshiur package
+    const packageDir = path_1.default.dirname(path_1.default.dirname(__filename)); // Go up from dist to package root
+    const templatesDir = path_1.default.join(packageDir, 'dist', 'templates');
+    // If templates not found in dist, try src (for development)
+    const actualTemplatesDir = fs_1.default.existsSync(templatesDir)
+        ? templatesDir
+        : path_1.default.join(packageDir, 'src', 'templates');
+    // Generate token function content
+    const generateTokenContent = `const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+function generateToken(payload) {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}
+
+module.exports = { generateToken };
+`;
+    // Generate token TS content
+    const generateTokenTsContent = `import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+interface TokenPayload {
+  userId: string;
+  email: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}
+`;
+    // Verify token function content
+    const verifyTokenContent = `const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+function verifyToken(token) {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}
+
+module.exports = { verifyToken };
+`;
+    // Verify token TS content
+    const verifyTokenTsContent = `import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}
+`;
+    // Create token files based on project type
+    if (isTypeScript) {
+        const generateTokenPath = path_1.default.join(utilsDir, 'generateToken.ts');
+        const verifyTokenPath = path_1.default.join(utilsDir, 'verifyToken.ts');
+        if (!fs_1.default.existsSync(generateTokenPath)) {
+            fs_1.default.writeFileSync(generateTokenPath, generateTokenTsContent);
+            console.log('✓ generateToken.ts created in utils folder');
+        }
+        if (!fs_1.default.existsSync(verifyTokenPath)) {
+            fs_1.default.writeFileSync(verifyTokenPath, verifyTokenTsContent);
+            console.log('✓ verifyToken.ts created in utils folder');
+        }
+    }
+    else {
+        const generateTokenPath = path_1.default.join(utilsDir, 'generateToken.js');
+        const verifyTokenPath = path_1.default.join(utilsDir, 'verifyToken.js');
+        if (!fs_1.default.existsSync(generateTokenPath)) {
+            fs_1.default.writeFileSync(generateTokenPath, generateTokenContent);
+            console.log('✓ generateToken.js created in utils folder');
+        }
+        if (!fs_1.default.existsSync(verifyTokenPath)) {
+            fs_1.default.writeFileSync(verifyTokenPath, verifyTokenContent);
+            console.log('✓ verifyToken.js created in utils folder');
+        }
+    }
+    // Install necessary packages if not already installed
+    console.log('📦 Checking dependencies...');
+    try {
+        const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            const hasJwt = packageJson.dependencies?.jsonwebtoken || packageJson.devDependencies?.jsonwebtoken;
+            const hasDotenv = packageJson.dependencies?.dotenv || packageJson.devDependencies?.dotenv;
+            if (!hasJwt || !hasDotenv) {
+                (0, child_process_1.execSync)('npm install jsonwebtoken dotenv', { stdio: 'inherit' });
+            }
+            if (isTypeScript) {
+                const hasTypes = packageJson.devDependencies?.['@types/jsonwebtoken'];
+                if (!hasTypes) {
+                    (0, child_process_1.execSync)('npm install --save-dev @types/jsonwebtoken', { stdio: 'inherit' });
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.log('⚠ Warning: Could not verify or install dependencies');
+    }
+    console.log('\n🎉 JWT Moshiur setup complete!');
+    console.log('📝 Next steps:');
+    console.log('   1. Edit .env and change JWT_SECRET to a strong secret key');
+    console.log('   2. Import and use generateToken() and verifyToken() from utils/');
+}

package/dist/templates/generateToken.template.d.ts

@@ -0,0 +1,8 @@
+interface TokenPayload {
+    userId?: string;
+    email?: string;
+    role?: string;
+    [key: string]: any;
+}
+export declare function generateToken(payload: TokenPayload): string;
+export {};

package/dist/templates/generateToken.template.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToken = generateToken;
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+dotenv.config();
+const JWT_SECRET = (process.env.JWT_SECRET || 'fallback-secret');
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+function generateToken(payload) {
+    return jwt.sign(payload, JWT_SECRET, {
+        expiresIn: JWT_EXPIRY
+    });
+}

package/dist/templates/verifyToken.template.d.ts

@@ -0,0 +1 @@
+export declare function verifyToken(token: string): any;

package/dist/templates/verifyToken.template.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyToken = verifyToken;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+function verifyToken(token) {
+    try {
+        return jsonwebtoken_1.default.verify(token, JWT_SECRET);
+    }
+    catch (error) {
+        throw new Error('Invalid or expired token');
+    }
+}

package/dist/verifyToken.d.ts

@@ -0,0 +1 @@
+export declare function verifyToken(token: string): any;

package/dist/verifyToken.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyToken = verifyToken;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+function verifyToken(token) {
+    try {
+        return jsonwebtoken_1.default.verify(token, JWT_SECRET);
+    }
+    catch (error) {
+        throw new Error('Invalid or expired token');
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "jwtmoshiur",
+  "version": "1.0.0",
+  "description": "JWT auto-setup package with token generation and verification",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "jwtmoshiur": "bin/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node bin/cli.js"
+  },
+  "keywords": ["jwtmoshiur","jwt", "authentication", "token", "security"],
+  "author": "Moshiur Rahman Deap",
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^17.4.2",
+    "jsonwebtoken": "^9.0.3"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^25.8.0",
+    "typescript": "^6.0.3"
+  }
+}

package/readme.md

@@ -0,0 +1,295 @@
+# 🔐 JWT Moshiur
+
+> Zero-configuration JWT token generator and verifier with automatic project setup.
+
+A lightweight, zero-configuration npm package that automatically sets up JWT authentication for your Node.js projects. Install once, get JWT utilities instantly!
+
+[![npm version](https://img.shields.io/npm/v/jwtmoshiur.svg)](https://www.npmjs.com/package/jwtmoshiur)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+- 🚀 **Zero Configuration** - Automatic setup on installation
+- 📁 **Auto Project Setup** - Generates `.env` and utility files
+- 🔑 **Generate Tokens** - Simple, intuitive token creation
+- ✅ **Verify Tokens** - Built-in token validation
+- 🛡️ **Secure** - Uses industry-standard `jsonwebtoken` library
+- 📦 **Lightweight** - Minimal dependencies
+- 🎯 **TypeScript Ready** - Full TypeScript support
+- ⚡ **Easy Integration** - Works with any Node.js project
+
+## 📦 Installation
+
+```bash
+npm install jwtmoshiur
+```
+
+That's it! The package automatically:
+- ✅ Creates a `.env` file with secure JWT configuration
+- ✅ Generates `utils/generateToken.js` (or `.ts` for TypeScript projects)
+- ✅ Generates `utils/verifyToken.js` (or `.ts`)
+- ✅ Installs all required dependencies
+
+## 🚀 Quick Start
+
+### 1. Generate a Token
+
+```javascript
+const { generateToken } = require('./utils/generateToken');
+
+const token = generateToken({
+  userId: '12345',
+  email: 'user@example.com',
+  role: 'admin'
+});
+
+console.log(token);
+// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+```
+
+### 2. Verify a Token
+
+```javascript
+const { verifyToken } = require('./utils/verifyToken');
+
+try {
+  const decoded = verifyToken(token);
+  console.log(decoded);
+  // { userId: '12345', email: 'user@example.com', role: 'admin', iat: 1715772..., exp: 1715858... }
+} catch (error) {
+  console.error('Token is invalid or expired');
+}
+```
+
+## 📚 Usage Examples
+
+### Express.js Authentication Middleware
+
+```javascript
+const express = require('express');
+const { verifyToken } = require('./utils/verifyToken');
+const { generateToken } = require('./utils/generateToken');
+
+const app = express();
+
+// Middleware to protect routes
+const authMiddleware = (req, res, next) => {
+  const token = req.headers.authorization?.split(' ')[1];
+  
+  if (!token) {
+    return res.status(401).json({ error: 'No token provided' });
+  }
+  
+  try {
+    req.user = verifyToken(token);
+    next();
+  } catch (error) {
+    res.status(401).json({ error: 'Invalid token' });
+  }
+};
+
+// Login endpoint
+app.post('/login', (req, res) => {
+  const user = { id: 1, email: 'user@example.com' };
+  const token = generateToken(user);
+  res.json({ token });
+});
+
+// Protected endpoint
+app.get('/profile', authMiddleware, (req, res) => {
+  res.json({ user: req.user });
+});
+
+app.listen(3000, () => console.log('Server running on port 3000'));
+```
+
+### Async/Await Pattern
+
+```javascript
+const { generateToken, verifyToken } = require('./utils');
+
+async function authenticateUser(credentials) {
+  try {
+    // Generate token for user
+    const token = generateToken({
+      userId: credentials.id,
+      email: credentials.email,
+      timestamp: Date.now()
+    });
+    
+    // Later, verify the token
+    const payload = verifyToken(token);
+    console.log('User authenticated:', payload.email);
+    
+    return payload;
+  } catch (error) {
+    console.error('Authentication failed:', error.message);
+    throw error;
+  }
+}
+```
+
+### Custom Token Expiry
+
+```javascript
+const { generateToken } = require('./utils/generateToken');
+
+// Create a token that expires in 1 hour
+const shortToken = generateToken(
+  { userId: '123' }
+);
+
+// The expiry is controlled by JWT_EXPIRY in .env
+// Default: 24h
+// Options: 1h, 7d, 30d, etc.
+```
+
+## ⚙️ Configuration
+
+Edit your `.env` file to customize JWT settings:
+
+```env
+# JWT Moshiur Configuration
+JWT_SECRET=your-super-secret-key-change-this-in-production
+JWT_EXPIRY=24h
+```
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `JWT_SECRET` | Generated | Secret key for signing tokens (change this!) |
+| `JWT_EXPIRY` | `24h` | Token expiration time (`1h`, `7d`, `30d`, etc.) |
+
+**⚠️ Important:** Always change `JWT_SECRET` to a strong, unique value in production!
+
+## 📖 API Reference
+
+### `generateToken(payload: object): string`
+
+Generates a signed JWT token.
+
+**Parameters:**
+- `payload` (object): Data to encode in the token
+
+**Returns:** JWT token string
+
+**Example:**
+```javascript
+const token = generateToken({ 
+  userId: '123', 
+  email: 'user@example.com',
+  role: 'user'
+});
+```
+
+### `verifyToken(token: string): object`
+
+Verifies and decodes a JWT token.
+
+**Parameters:**
+- `token` (string): JWT token to verify
+
+**Returns:** Decoded payload object
+
+**Throws:** Error if token is invalid or expired
+
+**Example:**
+```javascript
+try {
+  const payload = verifyToken(token);
+  console.log('Valid token:', payload);
+} catch (error) {
+  console.log('Invalid token:', error.message);
+}
+```
+
+## 🔄 Manual Setup
+
+If you need to re-run the setup process:
+
+```bash
+npx jwtmoshiur
+```
+
+This will regenerate the `.env` file and utility files if they don't exist.
+
+## 📁 Project Structure
+
+After installation, your project will have:
+
+```
+your-project/
+├── .env
+├── utils/
+│   ├── generateToken.js
+│   └── verifyToken.js
+├── node_modules/
+│   └── jwtmoshiur/
+└── package.json
+```
+
+## 🔐 Security Best Practices
+
+1. **Never commit `.env` to version control**
+   ```bash
+   # Add to .gitignore
+   .env
+   .env.local
+   ```
+
+2. **Use strong secrets**
+   ```bash
+   # Generate a strong secret (Linux/Mac)
+   openssl rand -base64 32
+   
+   # Or use a random string generator
+   node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+   ```
+
+3. **Rotate secrets regularly** in production
+
+4. **Use HTTPS** only in production
+
+5. **Set appropriate expiry times** for your use case
+
+## 🛠️ Troubleshooting
+
+### Issue: Token generation fails
+**Solution:** Ensure `JWT_SECRET` is set in `.env`
+
+### Issue: "Invalid token" error
+**Solution:** Verify the token hasn't expired or been tampered with
+
+### Issue: `.env` not created
+**Solution:** Run `npx jwtmoshiur` to manually trigger setup
+
+## 📋 Requirements
+
+- Node.js >= 14.0.0
+- npm >= 6.0.0
+
+## 📦 Dependencies
+
+- `jsonwebtoken` - JWT signing and verification
+- `dotenv` - Environment variable management
+
+## 📄 License
+
+MIT License - see LICENSE file for details
+
+## 👨‍💻 Author
+
+Created by **Moshiur Rahman Deap**
+
+## 🤝 Contributing
+
+Contributions are welcome! Feel free to submit issues and pull requests.
+
+## 📞 Support
+
+If you have any questions or issues, please open an issue on GitHub or contact the maintainer.
+
+---
+
+**Happy coding! 🎉**

package/src/generateToken.ts

@@ -0,0 +1,20 @@
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET: string = (process.env.JWT_SECRET || 'fallback-secret') as string;
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+interface TokenPayload {
+  userId?: string;
+  email?: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}

package/src/index.ts

@@ -0,0 +1,36 @@
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+import { initializeJwtMoshiur } from './setup';
+
+dotenv.config();
+
+const JWT_SECRET: string = (process.env.JWT_SECRET || 'fallback-secret') as string;
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '1h';
+
+interface TokenPayload {
+  userId?: string;
+  email?: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload, options?: any): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY,
+    ...options 
+  });
+}
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}
+
+export function setup() {
+  return initializeJwtMoshiur();
+}
+
+export { initializeJwtMoshiur };

package/src/setup.ts

@@ -0,0 +1,185 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+export function initializeJwtMoshiur() {
+  const projectRoot = process.cwd();
+  
+  // Generate a random secret if JWT_SECRET is not provided
+  const randomSecret = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+  
+  // Create .env with JWT configuration
+  const envContent = `# JWT Moshiur Configuration
+JWT_SECRET=${randomSecret}
+JWT_EXPIRY=24h
+`;
+  
+  // Check if .env exists, if not create it
+  const envPath = path.join(projectRoot, '.env');
+  if (!fs.existsSync(envPath)) {
+    fs.writeFileSync(envPath, envContent);
+    console.log('✓ .env file created with JWT configuration');
+  } else {
+    // Check if JWT_SECRET already exists
+    const envData = fs.readFileSync(envPath, 'utf-8');
+    if (!envData.includes('JWT_SECRET')) {
+      fs.appendFileSync(envPath, `\n${envContent}`);
+      console.log('✓ JWT configuration added to existing .env');
+    } else {
+      console.log('✓ JWT configuration already exists in .env');
+    }
+  }
+
+  // Create utils directory
+  const utilsDir = path.join(projectRoot, 'utils');
+  if (!fs.existsSync(utilsDir)) {
+    fs.mkdirSync(utilsDir);
+  }
+
+  // Determine if this is a TypeScript project
+  const isTypeScript = fs.existsSync(path.join(projectRoot, 'tsconfig.json'));
+  
+  // Get the path to templates in the jwtmoshiur package
+  const packageDir = path.dirname(path.dirname(__filename)); // Go up from dist to package root
+  const templatesDir = path.join(packageDir, 'dist', 'templates');
+  
+  // If templates not found in dist, try src (for development)
+  const actualTemplatesDir = fs.existsSync(templatesDir) 
+    ? templatesDir 
+    : path.join(packageDir, 'src', 'templates');
+
+  // Generate token function content
+  const generateTokenContent = `const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+function generateToken(payload) {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}
+
+module.exports = { generateToken };
+`;
+
+  // Generate token TS content
+  const generateTokenTsContent = `import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+interface TokenPayload {
+  userId: string;
+  email: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}
+`;
+
+  // Verify token function content
+  const verifyTokenContent = `const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+function verifyToken(token) {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}
+
+module.exports = { verifyToken };
+`;
+
+  // Verify token TS content
+  const verifyTokenTsContent = `import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}
+`;
+
+  // Create token files based on project type
+  if (isTypeScript) {
+    const generateTokenPath = path.join(utilsDir, 'generateToken.ts');
+    const verifyTokenPath = path.join(utilsDir, 'verifyToken.ts');
+    
+    if (!fs.existsSync(generateTokenPath)) {
+      fs.writeFileSync(generateTokenPath, generateTokenTsContent);
+      console.log('✓ generateToken.ts created in utils folder');
+    }
+    
+    if (!fs.existsSync(verifyTokenPath)) {
+      fs.writeFileSync(verifyTokenPath, verifyTokenTsContent);
+      console.log('✓ verifyToken.ts created in utils folder');
+    }
+  } else {
+    const generateTokenPath = path.join(utilsDir, 'generateToken.js');
+    const verifyTokenPath = path.join(utilsDir, 'verifyToken.js');
+    
+    if (!fs.existsSync(generateTokenPath)) {
+      fs.writeFileSync(generateTokenPath, generateTokenContent);
+      console.log('✓ generateToken.js created in utils folder');
+    }
+    
+    if (!fs.existsSync(verifyTokenPath)) {
+      fs.writeFileSync(verifyTokenPath, verifyTokenContent);
+      console.log('✓ verifyToken.js created in utils folder');
+    }
+  }
+
+  // Install necessary packages if not already installed
+  console.log('📦 Checking dependencies...');
+  try {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+      const hasJwt = packageJson.dependencies?.jsonwebtoken || packageJson.devDependencies?.jsonwebtoken;
+      const hasDotenv = packageJson.dependencies?.dotenv || packageJson.devDependencies?.dotenv;
+      
+      if (!hasJwt || !hasDotenv) {
+        execSync('npm install jsonwebtoken dotenv', { stdio: 'inherit' });
+      }
+      
+      if (isTypeScript) {
+        const hasTypes = packageJson.devDependencies?.['@types/jsonwebtoken'];
+        if (!hasTypes) {
+          execSync('npm install --save-dev @types/jsonwebtoken', { stdio: 'inherit' });
+        }
+      }
+    }
+  } catch (error) {
+    console.log('⚠ Warning: Could not verify or install dependencies');
+  }
+
+  console.log('\n🎉 JWT Moshiur setup complete!');
+  console.log('📝 Next steps:');
+  console.log('   1. Edit .env and change JWT_SECRET to a strong secret key');
+  console.log('   2. Import and use generateToken() and verifyToken() from utils/');
+}

package/src/templates/env.template

@@ -0,0 +1,3 @@
+# JWT Moshiur Configuration
+JWT_SECRET=your-super-secret-key-change-this-placeholder
+JWT_EXPIRY=24h

package/src/templates/generateToken.template.ts

@@ -0,0 +1,20 @@
+const jwt = require('jsonwebtoken');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const JWT_SECRET: string = (process.env.JWT_SECRET || 'fallback-secret') as string;
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+interface TokenPayload {
+  userId?: string;
+  email?: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}

package/src/templates/verifyToken.template.ts

@@ -0,0 +1,14 @@
+import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}

package/src/verifyToken.ts

@@ -0,0 +1,14 @@
+import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/utils/generateToken.ts

@@ -0,0 +1,20 @@
+import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+const JWT_EXPIRY = process.env.JWT_EXPIRY || '24h';
+
+interface TokenPayload {
+  userId: string;
+  email: string;
+  role?: string;
+  [key: string]: any;
+}
+
+export function generateToken(payload: TokenPayload): string {
+  return jwt.sign(payload, JWT_SECRET, { 
+    expiresIn: JWT_EXPIRY 
+  });
+}

package/utils/verifyToken.ts

@@ -0,0 +1,14 @@
+import jwt from 'jsonwebtoken';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const JWT_SECRET = process.env.JWT_SECRET || 'fallback-secret';
+
+export function verifyToken(token: string): any {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    throw new Error('Invalid or expired token');
+  }
+}