create full stack e commerce website
- User
create full stack e commerce website
Assistant
I'll help you create a full-stack e-commerce website. I'll build a modern solution using React for the frontend, Node.js/Express for the backend, and MongoDB for the database.
Project Structure
ecommerce-website/ ├── client/ # React frontend ├── server/ # Node.js backend ├── shared/ # Shared types/utilities └── README.mdBackend Setup
First, let's create the server structure:
server/package.json
{ "name": "ecommerce-server", "version": "1.0.0", "main": "server.js", "scripts": { "start": "node server.js", "dev": "nodemon server.js" }, "dependencies": { "express": "^4.18.2", "mongoose": "^7.5.0", "cors": "^2.8.5", "dotenv": "^16.3.1", "bcryptjs": "^2.4.3", "jsonwebtoken": "^9.0.2", "multer": "^1.4.5", "stripe": "^13.6.0" }, "devDependencies": { "nodemon": "^3.0.1" } }server/.env
PORT=5000 MONGODB_URI=mongodb://localhost:27017/ecommerce JWT_SECRET=your_jwt_secret_here STRIPE_SECRET_KEY=your_stripe_secret_keyserver/models/User.js
const mongoose = require('mongoose'); const bcrypt = require('bcryptjs'); const userSchema = new mongoose.Schema({ name: { type: String, required: true, trim: true }, email: { type: String, required: true, unique: true, lowercase: true }, password: { type: String, required: true, minlength: 6 }, role: { type: String, enum: ['user', 'admin'], default: 'user' }, address: { street: String, city: String, state: String, zipCode: String, country: String } }, { timestamps: true }); userSchema.pre('save', async function(next) { if (!this.isModified('password')) return next(); this.password = await bcrypt.hash(this.password, 12); next(); }); userSchema.methods.comparePassword = async function(password) { return await bcrypt.compare(password, this.password); }; module.exports = mongoose.model('User', userSchema);server/models/Product.js
const mongoose = require('mongoose'); const productSchema = new mongoose.Schema({ name: { type: String, required: true, trim: true }, description: { type: String, required: true }, price: { type: Number, required: true, min: 0 }, category: { type: String, required: true }, brand: { type: String, required: true }, images: [{ type: String, required: true }], stock: { type: Number, required: true, min: 0, default: 0 }, rating: { type: Number, default: 0, min: 0, max: 5 }, numReviews: { type: Number, default: 0 }, reviews: [{ user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, name: { type: String, required: true }, rating: { type: Number, required: true, min: 1, max: 5 }, comment: { type: String, required: true }, createdAt: { type: Date, default: Date.now } }], featured: { type: Boolean, default: false } }, { timestamps: true }); module.exports = mongoose.model('Product', productSchema);server/models/Order.js
const mongoose = require('mongoose'); const orderSchema = new mongoose.Schema({ user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, orderItems: [{ product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true }, name: { type: String, required: true }, quantity: { type: Number, required: true, min: 1 }, price: { type: Number, required: true }, image: { type: String, required: true } }], shippingAddress: { street: { type: String, required: true }, city: { type: String, required: true }, state: { type: String, required: true }, zipCode: { type: String, required: true }, country: { type: String, required: true } }, paymentMethod: { type: String, required: true, default: 'stripe' }, paymentResult: { id: String, status: String, update_time: String, email_address: String }, itemsPrice: { type: Number, required: true, default: 0.0 }, taxPrice: { type: Number, required: true, default: 0.0 }, shippingPrice: { type: Number, required: true, default: 0.0 }, totalPrice: { type: Number, required: true, default: 0.0 }, isPaid: { type: Boolean, required: true, default: false }, paidAt: { type: Date }, isDelivered: { type: Boolean, required: true, default: false }, deliveredAt: { type: Date }, status: { type: String, enum: ['pending', 'processing', 'shipped', 'delivered', 'cancelled'], default: 'pending' } }, { timestamps: true }); module.exports = mongoose.model('Order', orderSchema);server/middleware/auth.js
const jwt = require('jsonwebtoken'); const User = require('../models/User'); const auth = async (req, res, next) => { try { const token = req.header('Authorization')?.replace('Bearer ', ''); if (!token) { return res.status(401).json({ message: 'No token, authorization denied' }); } const decoded = jwt.verify(token, process.env.JWT_SECRET); const user = await User.findById(decoded.id).select('-password'); if (!user) { return res.status(401).json({ message: 'Token is not valid' }); } req.user = user; next(); } catch (error) { res.status(401).json({ message: 'Token is not valid' }); } }; const adminAuth = async (req, res, next) => { try { await auth(req, res, () => { if (req.user && req.user.role === 'admin') { next(); } else { res.status(403).json({ message: 'Admin access required' }); } }); } catch (error) { res.status(401).json({ message: 'Authorization failed' }); } }; module.exports = { auth, adminAuth };server/routes/auth.js
const express = require('express'); const jwt = require('jsonwebtoken'); const User = require('../models/User'); const { auth } = require('../middleware/auth'); const router = express.Router(); // Register router.post('/register', async (req, res) => { try { const { name, email, password } = req.body; const existingUser = await User.findOne({ email }); if (existingUser) { return res.status(400).json({ message: 'User already exists' }); } const user = new User({ name, email, password }); await user.save(); const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '30d' }); res.status(201).json({ token, user: { id: user._id, name: user.name, email: user.email, role: user.role } }); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Login router.post('/login', async (req, res) => { 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 user.comparePassword(password); if (!isMatch) { return res.status(400).json({ message: 'Invalid credentials' }); } const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '30d' }); res.json({ token, user: { id: user._id, name: user.name, email: user.email, role: user.role } }); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Get current user router.get('/me', auth, async (req, res) => { try { res.json({ user: { id: req.user._id, name: req.user.name, email: req.user.email, role: req.user.role, address: req.user.address } }); } catch (error) { res.status(500).json({ message: 'Server error' }); } }); module.exports = router;server/routes/products.js
const express = require('express'); const Product = require('../models/Product'); const { auth, adminAuth } = require('../middleware/auth'); const router = express.Router(); // Get all products with filtering and pagination router.get('/', async (req, res) => { try { const page = parseInt(req.query.page) || 1; const limit = parseInt(req.query.limit) || 12; const skip = (page - 1) * limit; let query = {}; // Search by name or description if (req.query.search) { query.$or = [ { name: { $regex: req.query.search, $options: 'i' } }, { description: { $regex: req.query.search, $options: 'i' } } ]; } // Filter by category if (req.query.category) { query.category = req.query.category; } // Filter by brand if (req.query.brand) { query.brand = req.query.brand; } // Price range filter if (req.query.minPrice || req.query.maxPrice) { query.price = {}; if (req.query.minPrice) query.price.$gte = parseFloat(req.query.minPrice); if (req.query.maxPrice) query.price.$lte = parseFloat(req.query.maxPrice); } // Sort options let sort = {}; if (req.query.sort) { switch (req.query.sort) { case 'price_asc': sort.price = 1; break; case 'price_desc': sort.price = -1; break; case 'rating': sort.rating = -1; break; case 'newest': sort.createdAt = -1; break; default: sort.createdAt = -1; } } const products = await Product.find(query) .sort(sort) .skip(skip) .limit(limit); const total = await Product.countDocuments(query); res.json({ products, currentPage: page, totalPages: Math.ceil(total / limit), totalProducts: total }); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Get single product router.get('/:id', async (req, res) => { try { const product = await Product.findById(req.params.id).populate('reviews.user', 'name'); if (!product) { return res.status(404).json({ message: 'Product not found' }); } res.json(product); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Create product (Admin only) router.post('/', adminAuth, async (req, res) => { try { const product = new Product(req.body); await product.save(); res.status(201).json(product); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Update product (Admin only) router.put('/:id', adminAuth, async (req, res) => { try { const product = await Product.findByIdAndUpdate( req.params.id, req.body, { new: true, runValidators: true } ); if (!product) { return res.status(404).json({ message: 'Product not found' }); } res.json(product); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Delete product (Admin only) router.delete('/:id', adminAuth, async (req, res) => { try { const product = await Product.findByIdAndDelete(req.params.id); if (!product) { return res.status(404).json({ message: 'Product not found' }); } res.json({ message: 'Product deleted successfully' }); } catch (error) { res.status(500).json({ message: 'Server error', error: error.message }); } }); // Add product review router.post('/:id/reviews', auth, async (req, res) => { try { const { rating, comment } = req.body; const product = await Product.findById(req.params.id); if (!product) { return res.status(404).json({ message: 'Product not found' }); } // Check if user already reviewed const existingReview = product.reviews.find( review => review.user.toString() === req.user._id.toString() ); if (existingReview) { return res.status(400).json({ message:- User
full working and responsive website and no error no nothing full fledged website and 3d 4k and i can review it full ai
Assistant
I'll create a complete, fully functional e-commerce website with modern 3D/4K design elements. This will be a comprehensive solution with all features working.
Complete Project Structure
ecommerce-3d/ ├── client/ # React frontend with 3D elements ├── server/ # Node.js backend ├── uploads/ # Image uploads └── README.mdBackend Implementation
server/package.json
{ "name": "ecommerce-3d-server", "version": "1.0.0", "main": "server.js", "scripts": { "start": "node server.js", "dev": "nodemon server.js", "seed": "node seedData.js" }, "dependencies": { "express": "^4.18.2", "mongoose": "^7.5.0", "cors": "^2.8.5", "dotenv": "^16.3.1", "bcryptjs": "^2.4.3", "jsonwebtoken": "^9.0.2", "multer": "^1.4.5", "stripe": "^13.6.0", "express-rate-limit": "^6.10.0", "helmet": "^7.0.0", "compression": "^1.7.4" }, "devDependencies": { "nodemon": "^3.0.1" } }server/.env
PORT=5000 MONGODB_URI=mongodb://localhost:27017/ecommerce3d JWT_SECRET=your_super_secret_jwt_key_here_make_it_long_and_secure STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key NODE_ENV=developmentserver/server.js
const express = require('express'); const mongoose = require('mongoose'); const cors = require('cors'); const helmet = require('helmet'); const compression = require('compression'); const rateLimit = require('express-rate-limit'); require('dotenv').config(); const authRoutes = require('./routes/auth'); const productRoutes = require('./routes/products'); const orderRoutes = require('./routes/orders'); const uploadRoutes = require('./routes/upload'); const paymentRoutes = require('./routes/payment'); const app = express(); // Security middleware app.use(helmet()); app.use(compression()); // Rate limiting const limiter = rateLimit({ windowMs: 15 * 60 * 1000, // 15 minutes max: 100 // limit each IP to 100 requests per windowMs }); app.use(limiter); // CORS configuration app.use(cors({ origin: process.env.NODE_ENV === 'production' ? 'https://your-domain.com' : 'http://localhost:3000', credentials: true })); app.use(express.json({ limit: '10mb' })); app.use(express.urlencoded({ extended: true, limit: '10mb' })); // Serve static files app.use('/uploads', express.static('uploads')); // Routes app.use('/api/auth', authRoutes); app.use('/api/products', productRoutes); app.use('/api/orders', orderRoutes); app.use('/api/upload', uploadRoutes); app.use('/api/payment', paymentRoutes); // Health check app.get('/api/health', (req, res) => { res.json({ status: 'OK', timestamp: new Date().toISOString() }); }); // Error handling middleware app.use((err, req, res, next) => { console.error(err.stack); res.status(500).json({ message: 'Something went wrong!', error: process.env.NODE_ENV === 'development' ? err.message : {} }); }); // 404 handler app.use('*', (req, res) => { res.status(404).json({ message: 'Route not found' }); }); // Database connection mongoose.connect(process.env.MONGODB_URI, { useNewUrlParser: true, useUnifiedTopology: true, }) .then(() => { console.log('✅ Connected to MongoDB'); const PORT = process.env.PORT || 5000; app.listen(PORT, () => { console.log(`🚀 Server running on port ${PORT}`); console.log(`📱 Environment: ${process.env.NODE_ENV}`); }); }) .catch((error) => { console.error('❌ MongoDB connection error:', error); process.exit(1); }); // Graceful shutdown process.on('SIGTERM', () => { console.log('SIGTERM received. Shutting down gracefully...'); mongoose.connection.close(() => { console.log('MongoDB connection closed.'); process.exit(0); }); });server/models/User.js
const mongoose = require('mongoose'); const bcrypt = require('bcryptjs'); const userSchema = new mongoose.Schema({ name: { type: String, required: [true, 'Name is required'], trim: true, maxlength: [50, 'Name cannot exceed 50 characters'] }, email: { type: String, required: [true, 'Email is required'], unique: true, lowercase: true, match: [/^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/, 'Please enter a valid email'] }, password: { type: String, required: [true, 'Password is required'], minlength: [6, 'Password must be at least 6 characters'] }, avatar: { type: String, default: 'https://via.placeholder.com/150x150/007bff/ffffff?text=User' }, role: { type: String, enum: ['user', 'admin'], default: 'user' }, address: { street: String, city: String, state: String, zipCode: String, country: String }, phone: { type: String, match: [/^\+?[\d\s-()]+$/, 'Please enter a valid phone number'] }, wishlist: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Product' }], isActive: { type: Boolean, default: true }, lastLogin: { type: Date, default: Date.now } }, { timestamps: true }); userSchema.pre('save', async function(next) { if (!this.isModified('password')) return next(); this.password = await bcrypt.hash(this.password, 12); next(); }); userSchema.methods.comparePassword = async function(password) { return await bcrypt.compare(password, this.password); }; userSchema.methods.toJSON = function() { const user = this.toObject(); delete user.password; return user; }; module.exports = mongoose.model('User', userSchema);server/models/Product.js
const mongoose = require('mongoose'); const reviewSchema = new mongoose.Schema({ user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, name: { type: String, required: true }, rating: { type: Number, required: true, min: 1, max: 5 }, comment: { type: String, required: true, maxlength: 500 }, helpful: { type: Number, default: 0 } }, { timestamps: true }); const productSchema = new mongoose.Schema({ name: { type: String, required: [true, 'Product name is required'], trim: true, maxlength: [100, 'Product name cannot exceed 100 characters'] }, description: { type: String, required: [true, 'Product description is required'], maxlength: [2000, 'Description cannot exceed 2000 characters'] }, shortDescription: { type: String, maxlength: [200, 'Short description cannot exceed 200 characters'] }, price: { type: Number, required: [true, 'Price is required'], min: [0, 'Price cannot be negative'] }, originalPrice: { type: Number, min: [0, 'Original price cannot be negative'] }, category: { type: String, required: [true, 'Category is required'], enum: ['Electronics', 'Clothing', 'Books', 'Home & Garden', 'Sports', 'Beauty', 'Toys', 'Automotive'] }, subcategory: { type: String, required: true }, brand: { type: String, required: [true, 'Brand is required'] }, model: String, sku: { type: String, unique: true, required: true }, images: [{ url: { type: String, required: true }, alt: String, isPrimary: { type: Boolean, default: false } }], video: { url: String, thumbnail: String }, stock: { type: Number, required: [true, 'Stock quantity is required'], min: [0, 'Stock cannot be negative'], default: 0 }, lowStockThreshold: { type: Number, default: 10 }, rating: { type: Number, default: 0, min: 0, max: 5 }, numReviews: { type: Number, default: 0 }, reviews: [reviewSchema], specifications: [{ name: String, value: String }], features: [String], dimensions: { length: Number, width: Number, height: Number, weight: Number, unit: { type: String, enum: ['cm', 'inch', 'kg', 'lb'], default: 'cm' } }, colors: [{ name: String, hex: String, image: String }], sizes: [{ name: String, stock: Number }], tags: [String], featured: { type: Boolean, default: false }, onSale: { type: Boolean, default: false }, saleEndDate: Date, isActive: { type: Boolean, default: true }, views: { type: Number, default: 0 }, sold: { type: Number, default: 0 }, shippingInfo: { weight: Number, freeShipping: { type: Boolean, default: false }, shippingCost: { type: Number, default: 0 } } }, { timestamps: true }); // Indexes for better performance productSchema.index({ name: 'text', description: 'text' }); productSchema.index({ category: 1, price: 1 }); productSchema.index({ rating: -1 }); productSchema.index({ createdAt: -1 }); productSchema.index({ featured: 1 }); // Calculate average rating productSchema.methods.calculateAverageRating = function() { if (this.reviews.length === 0) { this.rating = 0; this.numReviews = 0; } else { const totalRating = this.reviews.reduce((sum, review) => sum + review.rating, 0); this.rating = Math.round((totalRating / this.reviews.length) * 10) / 10; this.numReviews = this.reviews.length; } }; // Check if product is low in stock productSchema.virtual('isLowStock').get(function() { return this.stock <= this.lowStockThreshold; }); // Calculate discount percentage productSchema.virtual('discountPercentage').get(function() { if (this.originalPrice && this.originalPrice > this.price) { return Math.round(((this.originalPrice - this.price) / this.originalPrice) * 100); } return 0; }); productSchema.set('toJSON', { virtuals: true }); module.exports = mongoose.model('Product', productSchema);server/models/Order.js
const mongoose = require('mongoose'); const orderItemSchema = new mongoose.Schema({ product: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true }, name: { type: String, required: true }, quantity: { type: Number, required: true, min: 1 }, price: { type: Number, required: true }, image: { type: String, required: true }, color: String, size: String }); const orderSchema = new mongoose.Schema({ orderNumber: { type: String, unique: true, required: true }, user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true }, orderItems: [orderItemSchema], shippingAddress: { fullName: { type: String, required: true }, street: { type: String, required: true }, city: { type: String, required: true }, state: { type: String, required: true }, zipCode: { type: String, required: true }, country: { type: String, required: true }, phone: String }, billingAddress: { fullName: String, street: String, city: String, state: String, zipCode: String, country: String }, paymentMethod: { type: String, required: true, enum: ['stripe', 'paypal', 'cash_on_delivery'] }, paymentResult: { id: String, status: String, update_time: String, email_address: String }, itemsPrice: { type: Number, required: true, default: 0.0 }, taxPrice: { type: Number, required: true, default: 0.0 }, shippingPrice: { type: Number, required: true, default: 0.0 }, discountAmount: { type: Number, default: 0.0 }, totalPrice: { type: Number, required: true, default: 0.0 }, isPaid: { type: Boolean, required: true, default: false }, paidAt: Date, isDelivered: { type: Boolean, required: true, default: false }, deliveredAt: Date, status: { type: String, enum: ['pending', 'confirmed', 'processing', 'shipped', 'delivered', 'cancelled', 'refunded'],
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.