@dax-crafta/auth 1.1.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@dax-crafta/auth",
+  "version": "1.1.0",
+  "description": "Authentication plugin for crafta framework",
+  "main": "src/index.js",
+  "private": false,
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^7.6.3",
+    "validator": "^13.11.0"
+  },
+  "peerDependencies": {
+    "crafta": "^1.1.4"
+  }
+}

package/src/index.js

@@ -0,0 +1,205 @@
+const jwt = require('jsonwebtoken');
+const bcrypt = require('bcryptjs');
+const mongoose = require('mongoose');
+const validator = require('validator');
+
+// Default configuration
+const defaultConfig = {
+  strategy: 'jwt',
+  fields: ['email', 'password'],
+  routes: {
+    register: '/register',
+    login: '/login',
+    verify: '/verify'
+  },
+  mongoUrl: process.env.MONGODB_URI || 'mongodb://localhost:27017/forge-auth',
+  sendVerificationEmail: null,
+  db: null
+};
+
+// Create dynamic Mongoose schema based on fields
+function createUserSchema(fields) {
+  const schemaFields = fields.reduce((acc, field) => {
+    acc[field] = { 
+      type: String,
+      required: true,
+      ...(field === 'email' && { 
+        validate: {
+          validator: validator.isEmail,
+          message: 'Invalid email format'
+        }
+      })
+    };
+    return acc;
+  }, {});
+
+  return new mongoose.Schema(schemaFields, { timestamps: true });
+}
+
+function auth(config = {}) {
+  const finalConfig = { ...defaultConfig, ...config };
+  
+  // Validate JWT secret
+  if (!finalConfig.env?.JWT_SECRET) {
+    throw new Error('JWT_SECRET is required in environment configuration');
+  }
+
+  // Initialize MongoDB connection if custom DB handlers aren't provided
+  let User;
+  if (!finalConfig.db) {
+    mongoose.connect(finalConfig.mongoUrl, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true
+    });
+    
+    const userSchema = createUserSchema(finalConfig.fields);
+    User = mongoose.model('User', userSchema);
+  }
+
+  // Database operations
+  const dbOperations = finalConfig.db || {
+    saveUser: async (userData) => {
+      const user = new User(userData);
+      return await user.save();
+    },
+    getUserByEmail: async (email) => {
+      return await User.findOne({ email });
+    }
+  };
+
+  return function(app) {
+    // Register route
+    app.post(finalConfig.routes.register, async (req, res) => {
+      try {
+        // Validate required fields
+        const userData = {};
+        for (const field of finalConfig.fields) {
+          if (!req.body[field]) {
+            return res.status(400).json({ 
+              success: false, 
+              error: `${field} is required` 
+            });
+          }
+          userData[field] = req.body[field];
+        }
+
+        // Hash password
+        if (userData.password) {
+          userData.password = await bcrypt.hash(userData.password, 10);
+        }
+
+        // Save user
+        const savedUser = await dbOperations.saveUser(userData);
+
+        // Generate JWT
+        const token = jwt.sign(
+          { id: savedUser._id, email: savedUser.email },
+          finalConfig.env.JWT_SECRET,
+          { expiresIn: '24h' }
+        );
+
+        // Send verification email if configured
+        if (finalConfig.sendVerificationEmail) {
+          try {
+            await finalConfig.sendVerificationEmail(savedUser);
+          } catch (emailError) {
+            console.error('Email verification failed:', emailError);
+          }
+        }
+
+        res.status(201).json({ 
+          success: true,
+          token,
+          user: { ...savedUser.toJSON(), password: undefined }
+        });
+      } catch (error) {
+        if (error.code === 11000) {
+          return res.status(400).json({ 
+            success: false, 
+            error: 'Email already exists' 
+          });
+        }
+        res.status(400).json({ 
+          success: false, 
+          error: error.message 
+        });
+      }
+    });
+
+    // Login route
+    app.post(finalConfig.routes.login, async (req, res) => {
+      try {
+        const { email, password } = req.body;
+        
+        if (!email || !password) {
+          return res.status(400).json({ 
+            success: false, 
+            error: 'Email and password are required' 
+          });
+        }
+
+        const user = await dbOperations.getUserByEmail(email);
+        
+        if (!user) {
+          return res.status(404).json({ 
+            success: false, 
+            error: 'User not found' 
+          });
+        }
+
+        const isValid = await bcrypt.compare(password, user.password);
+        
+        if (!isValid) {
+          return res.status(401).json({ 
+            success: false, 
+            error: 'Invalid credentials' 
+          });
+        }
+
+        const token = jwt.sign(
+          { id: user._id, email: user.email },
+          finalConfig.env.JWT_SECRET,
+          { expiresIn: '24h' }
+        );
+
+        res.json({ 
+          success: true,
+          token,
+          user: { ...user.toJSON(), password: undefined }
+        });
+      } catch (error) {
+        res.status(400).json({ 
+          success: false, 
+          error: error.message 
+        });
+      }
+    });
+
+    // Verify route
+    app.get(finalConfig.routes.verify, (req, res) => {
+      const token = req.headers.authorization?.split(' ')[1];
+      
+      if (!token) {
+        return res.status(401).json({ 
+          success: false, 
+          error: 'No token provided' 
+        });
+      }
+
+      try {
+        const decoded = jwt.verify(token, finalConfig.env.JWT_SECRET);
+        res.json({ 
+          success: true,
+          user: decoded 
+        });
+      } catch (error) {
+        res.status(401).json({ 
+          success: false, 
+          error: 'Invalid token' 
+        });
+      }
+    });
+  };
+}
+
+module.exports = { auth };