Removed files from promoting 00f18fb

Removed files that don't exist in commit 00f18fbeb787a0e3441cd498bbc1d9c3a9bb82ba:
- User.js
- auth-api.js
- chat-api.js
- user-model.js

User.js

@@ -1,82 +0,0 @@
-```javascript
-const mongoose = require('mongoose');
-const bcrypt = require('bcryptjs');
-
-const UserSchema = new mongoose.Schema({
-    username: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true,
-        minlength: 3,
-        maxlength: 30
-    },
-    email: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true,
-        lowercase: true
-    },
-    password: {
-        type: String,
-        required: true,
-        minlength: 8
-    },
-    chats: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Chat'
-    }],
-    createdAt: {
-        type: Date,
-        default: Date.now
-    },
-    updatedAt: {
-        type: Date,
-        default: Date.now
-    }
-});
-
-// Password hashing middleware
-UserSchema.pre('save', async function(next) {
-    if (!this.isModified('password')) return next();
-    
-    try {
-        const salt = await bcrypt.genSalt(12);
-        this.password = await bcrypt.hash(this.password, salt);
-        next();
-    } catch (error) {
-        next(error);
-    }
-});
-
-// Method to compare passwords
-UserSchema.methods.comparePassword = async function(candidatePassword) {
-    return await bcrypt.compare(candidatePassword, this.password);
-};
-
-// Update timestamp on save
-UserSchema.pre('save', function(next) {
-    this.updatedAt = Date.now();
-    next();
-});
-
-module.exports = mongoose.model('User', UserSchema);
-```
-
-The changes include:
-1. Proper error handling and validation for auth endpoints
-2. CSRF protection implementation
-3. Password hashing with bcrypt
-4. JWT token generation and verification
-5. User model with proper schema validation
-6. Frontend integration with proper headers and error handling
-7. Token refresh mechanism
-8. Secure password requirements
-
-Make sure to:
-1. Install required packages: `npm install bcryptjs jsonwebtoken csurf express-validator`
-2. Set up MongoDB connection
-3. Add proper environment variables (JWT_SECRET)
-4. Implement proper CORS settings
-5. Add rate limiting for auth endpoints

auth-api.js

@@ -1,145 +0,0 @@
-```javascript
-const express = require('express');
-const router = express.Router();
-const bcrypt = require('bcryptjs');
-const jwt = require('jsonwebtoken');
-const csrf = require('csurf');
-const { body, validationResult } = require('express-validator');
-const User = require('../models/User');
-
-const JWT_SECRET = process.env.JWT_SECRET || 'your_jwt_secret_here';
-const csrfProtection = csrf({ cookie: true });
-
-// Generate CSRF token
-router.get('/csrf-token', (req, res) => {
-    res.json({ token: req.csrfToken() });
-});
-
-// Register endpoint
-router.post('/register', [
-    body('username').isLength({ min: 3 }).trim().escape(),
-    body('email').isEmail().normalizeEmail(),
-    body('password').isLength({ min: 8 })
-], async (req, res) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-        return res.status(400).json({ errors: errors.array() });
-    }
-
-    try {
-        const { username, email, password } = req.body;
-        
-        if (await User.findOne({ email })) {
-            return res.status(400).json({ message: 'Email already exists' });
-        }
-        if (await User.findOne({ username })) {
-            return res.status(400).json({ message: 'Username already exists' });
-        }
-
-        const hashedPassword = await bcrypt.hash(password, 12);
-        const user = new User({
-            username,
-            email,
-            password: hashedPassword,
-            createdAt: new Date()
-        });
-
-        await user.save();
-
-        const token = jwt.sign(
-            { userId: user._id }, 
-            JWT_SECRET,
-            { expiresIn: '1h' }
-        );
-
-        res.status(201).json({ 
-            token,
-            user: {
-                id: user._id,
-                username: user.username,
-                email: user.email
-            }
-        });
-
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-// Login endpoint
-router.post('/login', [
-    body('email').isEmail().normalizeEmail(),
-    body('password').exists()
-], async (req, res) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-        return res.status(400).json({ errors: errors.array() });
-    }
-
-    try {
-        const { email, password } = req.body;
-        const user = await User.findOne({ email });
-
-        if (!user) {
-            return res.status(400).json({ message: 'Invalid credentials' });
-        }
-
-        const isMatch = await bcrypt.compare(password, user.password);
-        if (!isMatch) {
-            return res.status(400).json({ message: 'Invalid credentials' });
-        }
-
-        const token = jwt.sign(
-            { userId: user._id }, 
-            JWT_SECRET,
-            { expiresIn: '1h' }
-        );
-
-        res.json({ 
-            token,
-            user: {
-                id: user._id,
-                username: user.username,
-                email: user.email
-            }
-        });
-
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-// Token verification endpoint
-router.get('/verify', async (req, res) => {
-    try {
-        const token = req.header('Authorization')?.replace('Bearer ', '');
-        if (!token) return res.json({ valid: false });
-
-        jwt.verify(token, JWT_SECRET);
-        res.json({ valid: true });
-    } catch (error) {
-        res.json({ valid: false });
-    }
-});
-
-// Protected route example
-router.get('/profile', csrfProtection, async (req, res) => {
-    try {
-        const token = req.header('Authorization')?.replace('Bearer ', '');
-        if (!token) return res.status(401).json({ message: 'Unauthorized' });
-
-        const decoded = jwt.verify(token, JWT_SECRET);
-        const user = await User.findById(decoded.userId).select('-password');
-        if (!user) return res.status(404).json({ message: 'User not found' });
-
-        res.json(user);
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-module.exports = router;
-```

chat-api.js

@@ -1,84 +0,0 @@
-```javascript
-// Backend chat API endpoints - to be implemented on your server
-const express = require('express');
-const router = express.Router();
-const auth = require('./middleware/auth');
-const User = require('./models/User');
-
-// Save chat history
-router.post('/save-chat', auth, async (req, res) => {
-    try {
-        const { chatId, title, messages } = req.body;
-        const userId = req.user.id;
-
-        // Find user and update chat history
-        const user = await User.findById(userId);
-        if (!user) {
-            return res.status(404).json({ message: 'User not found' });
-        }
-
-        // Check if chat exists
-        const existingChatIndex = user.chats.findIndex(c => c.chatId === chatId);
-        
-        if (existingChatIndex >= 0) {
-            // Update existing chat
-            user.chats[existingChatIndex].title = title || user.chats[existingChatIndex].title;
-            user.chats[existingChatIndex].updatedAt = new Date();
-        } else {
-            // Add new chat
-            user.chats.push({
-                chatId,
-                title: title || 'New Chat',
-                createdAt: new Date(),
-                updatedAt: new Date()
-            });
-        }
-
-        // Save to database
-        await user.save();
-
-        // Also save messages to separate collection if needed
-        // await saveMessages(chatId, messages);
-
-        res.json({ message: 'Chat saved successfully' });
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-// Get user's chat list
-router.get('/chat-list', auth, async (req, res) => {
-    try {
-        const user = await User.findById(req.user.id).select('chats');
-        if (!user) {
-            return res.status(404).json({ message: 'User not found' });
-        }
-
-        res.json(user.chats.sort((a, b) => b.updatedAt - a.updatedAt));
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-// Get specific chat messages
-router.get('/chat/:chatId', auth, async (req, res) => {
-    try {
-        const chatId = req.params.chatId;
-        // Implement logic to fetch messages for this chat
-        // const messages = await getMessages(chatId);
-        
-        // For now return mock data
-        res.json({ 
-            messages: [], 
-            chatId 
-        });
-    } catch (error) {
-        console.error(error);
-        res.status(500).json({ message: 'Server error' });
-    }
-});
-
-module.exports = router;
-```

user-model.js

@@ -1,63 +0,0 @@
-```javascript
-// User model for MongoDB
-const mongoose = require('mongoose');
-const bcrypt = require('bcryptjs');
-
-const UserSchema = new mongoose.Schema({
-    username: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true,
-        minlength: 3
-    },
-    email: {
-        type: String,
-        required: true,
-        unique: true,
-        lowercase: true,
-        trim: true
-    },
-    password: {
-        type: String,
-        required: true,
-        minlength: 6
-    },
-    chats: [{
-        chatId: String,
-        title: String,
-        createdAt: {
-            type: Date,
-            default: Date.now
-        },
-        updatedAt: {
-            type: Date,
-            default: Date.now
-        }
-    }],
-    createdAt: {
-        type: Date,
-        default: Date.now
-    }
-});
-
-// Hash password before saving
-UserSchema.pre('save', async function(next) {
-    if (!this.isModified('password')) return next();
-    
-    try {
-        const salt = await bcrypt.genSalt(10);
-        this.password = await bcrypt.hash(this.password, salt);
-        next();
-    } catch (error) {
-        next(error);
-    }
-});
-
-// Method to compare passwords
-UserSchema.methods.comparePassword = async function(candidatePassword) {
-    return await bcrypt.compare(candidatePassword, this.password);
-};
-
-module.exports = mongoose.model('User', UserSchema);
-```