458 lines
13 KiB
Markdown
458 lines
13 KiB
Markdown
# 🏗️ Production-Ready Architecture Implementation
|
|
|
|
## ✅ What We've Created
|
|
|
|
Your SkyArtShop project now has a modern, production-ready structure matching industry best practices.
|
|
|
|
---
|
|
|
|
## 📂 Complete Structure
|
|
|
|
```
|
|
SkyArtShop/
|
|
├── frontend/ # React + TypeScript Frontend
|
|
│ ├── src/
|
|
│ │ ├── @types/ # TypeScript type definitions
|
|
│ │ │ └── index.ts # Shared types (User, Product, ApiResponse, etc.)
|
|
│ │ │
|
|
│ │ ├── api/ # Backend communication layer
|
|
│ │ │ ├── client.ts # Axios instance with auth interceptors
|
|
│ │ │ ├── products.ts # Product API calls
|
|
│ │ │ └── auth.ts # Authentication API calls
|
|
│ │ │
|
|
│ │ ├── assets/ # Static files (images, fonts, icons)
|
|
│ │ │ └── .gitkeep
|
|
│ │ │
|
|
│ │ ├── components/ # Reusable UI components
|
|
│ │ │ └── .gitkeep # Button, Card, Modal, etc.
|
|
│ │ │
|
|
│ │ ├── hooks/ # Custom React hooks
|
|
│ │ │ ├── useAuth.ts # Authentication state management
|
|
│ │ │ └── useFetch.ts # Generic data fetching
|
|
│ │ │
|
|
│ │ ├── pages/ # Route-level page components
|
|
│ │ │ └── .gitkeep # HomePage, ProductDetail, AdminDashboard, etc.
|
|
│ │ │
|
|
│ │ ├── routes/ # Router configuration
|
|
│ │ │ └── index.tsx # All route definitions + protected routes
|
|
│ │ │
|
|
│ │ ├── templates/ # Page layouts (Header, Sidebar, Footer)
|
|
│ │ │ └── .gitkeep
|
|
│ │ │
|
|
│ │ ├── themes/ # Design system (colors, fonts, spacing)
|
|
│ │ │ └── default.ts # Theme configuration
|
|
│ │ │
|
|
│ │ ├── utils/ # Pure utility functions
|
|
│ │ │ ├── format.ts # Currency, date formatters
|
|
│ │ │ └── debounce.ts # Debounce utility
|
|
│ │ │
|
|
│ │ ├── validators/ # Client-side validation
|
|
│ │ │ └── index.ts # Form validation rules
|
|
│ │ │
|
|
│ │ ├── app.tsx # Root component (providers, router)
|
|
│ │ ├── main.tsx # Entry point (ReactDOM.render)
|
|
│ │ ├── index.css # Global styles + Tailwind
|
|
│ │ └── vite-env.d.ts # Vite environment types
|
|
│ │
|
|
│ ├── index.html # HTML shell
|
|
│ ├── vite.config.ts # Vite configuration
|
|
│ ├── tailwind.config.ts # Tailwind CSS config
|
|
│ ├── tsconfig.json # TypeScript config
|
|
│ ├── package.json # Dependencies + scripts
|
|
│ ├── .env # Environment variables
|
|
│ ├── .gitignore # Git ignore rules
|
|
│ └── readme.md # Frontend documentation
|
|
│
|
|
├── backend/ # Node.js + Express + TypeScript Backend
|
|
│ ├── prisma/
|
|
│ │ └── schema.prisma # Database schema (Prisma ORM)
|
|
│ │
|
|
│ ├── src/
|
|
│ │ ├── @types/ # TypeScript type definitions
|
|
│ │ │ └── index.ts # Shared backend types
|
|
│ │ │
|
|
│ │ ├── config/ # Configuration files
|
|
│ │ │ ├── app.ts # App settings (port, JWT, CORS)
|
|
│ │ │ └── database.ts # Database connection config
|
|
│ │ │
|
|
│ │ ├── controllers/ # Request handlers
|
|
│ │ │ └── .gitkeep # productController, authController, etc.
|
|
│ │ │
|
|
│ │ ├── services/ # Business logic layer
|
|
│ │ │ └── .gitkeep # productService, authService, etc.
|
|
│ │ │
|
|
│ │ ├── models/ # Data access layer (Prisma models)
|
|
│ │ │ └── .gitkeep # Product, User, Order, etc.
|
|
│ │ │
|
|
│ │ ├── routes/ # API endpoint definitions
|
|
│ │ │ └── .gitkeep # products.ts, auth.ts, users.ts, etc.
|
|
│ │ │
|
|
│ │ ├── middlewares/ # Express middleware
|
|
│ │ │ ├── authenticate.ts # JWT authentication
|
|
│ │ │ ├── errorHandler.ts # Global error handling
|
|
│ │ │ └── requestLogger.ts# Request logging
|
|
│ │ │
|
|
│ │ ├── validators/ # Request validation
|
|
│ │ │ └── productValidator.ts # Zod schemas
|
|
│ │ │
|
|
│ │ ├── helpers/ # Pure utility functions
|
|
│ │ │ ├── response.ts # Consistent API responses
|
|
│ │ │ └── jwt.ts # Token generation/verification
|
|
│ │ │
|
|
│ │ └── server.ts # Entry point (Express setup)
|
|
│ │
|
|
│ ├── tsconfig.json # TypeScript config
|
|
│ ├── package.json # Dependencies + scripts
|
|
│ ├── .env # Environment variables
|
|
│ ├── .env.example # Example env file
|
|
│ ├── .gitignore # Git ignore rules
|
|
│ ├── biome.json # Linter/formatter config
|
|
│ └── readme.md # Backend documentation
|
|
│
|
|
└── docs/
|
|
└── ARCHITECTURE.md # This file
|
|
```
|
|
|
|
---
|
|
|
|
## 🎯 Key Features Implemented
|
|
|
|
### Frontend Features
|
|
|
|
✅ **Type-safe API client** with automatic token injection
|
|
✅ **Custom hooks** for authentication and data fetching
|
|
✅ **Protected routes** with automatic redirect
|
|
✅ **Centralized theming** for consistent design
|
|
✅ **Utility functions** for formatting and validation
|
|
✅ **Vite + React Router + Tailwind** ready to go
|
|
|
|
### Backend Features
|
|
|
|
✅ **Layered architecture** (Controllers → Services → Models)
|
|
✅ **JWT authentication** with middleware
|
|
✅ **Global error handling** with consistent responses
|
|
✅ **Request validation** with Zod schemas
|
|
✅ **Prisma ORM** with PostgreSQL schema
|
|
✅ **Security middleware** (Helmet, CORS, Compression)
|
|
✅ **Request logging** for debugging
|
|
|
|
---
|
|
|
|
## 🚀 Getting Started
|
|
|
|
### 1. Install Frontend Dependencies
|
|
|
|
```bash
|
|
cd frontend
|
|
npm install
|
|
```
|
|
|
|
### 2. Install Backend Dependencies
|
|
|
|
```bash
|
|
cd backend
|
|
npm install
|
|
```
|
|
|
|
### 3. Set Up Database
|
|
|
|
```bash
|
|
cd backend
|
|
npx prisma generate
|
|
npx prisma migrate dev
|
|
```
|
|
|
|
### 4. Start Development Servers
|
|
|
|
**Terminal 1 - Backend:**
|
|
|
|
```bash
|
|
cd backend
|
|
npm run dev
|
|
# Runs on http://localhost:3000
|
|
```
|
|
|
|
**Terminal 2 - Frontend:**
|
|
|
|
```bash
|
|
cd frontend
|
|
npm run dev
|
|
# Runs on http://localhost:5173
|
|
```
|
|
|
|
---
|
|
|
|
## 📝 How to Add a New Feature
|
|
|
|
### Example: Add "Wishlist" Feature
|
|
|
|
#### Backend Steps
|
|
|
|
1. **Update Database Schema** (`backend/prisma/schema.prisma`):
|
|
|
|
```prisma
|
|
model Wishlist {
|
|
id Int @id @default(autoincrement())
|
|
userId Int
|
|
productId Int
|
|
createdAt DateTime @default(now())
|
|
|
|
user User @relation(fields: [userId], references: [id])
|
|
product Product @relation(fields: [productId], references: [id])
|
|
}
|
|
```
|
|
|
|
1. **Run Migration**:
|
|
|
|
```bash
|
|
npx prisma migrate dev --name add_wishlist
|
|
```
|
|
|
|
1. **Create Service** (`backend/src/services/wishlistService.ts`):
|
|
|
|
```typescript
|
|
import { prisma } from '../config/database';
|
|
|
|
export async function addToWishlist(userId: number, productId: number) {
|
|
return await prisma.wishlist.create({
|
|
data: { userId, productId }
|
|
});
|
|
}
|
|
|
|
export async function getUserWishlist(userId: number) {
|
|
return await prisma.wishlist.findMany({
|
|
where: { userId },
|
|
include: { product: true }
|
|
});
|
|
}
|
|
```
|
|
|
|
1. **Create Controller** (`backend/src/controllers/wishlistController.ts`):
|
|
|
|
```typescript
|
|
import { Request, Response } from 'express';
|
|
import * as wishlistService from '../services/wishlistService';
|
|
import { sendSuccess } from '../helpers/response';
|
|
|
|
export async function addItem(req: AuthRequest, res: Response) {
|
|
const { productId } = req.body;
|
|
const userId = req.user!.userId;
|
|
|
|
const item = await wishlistService.addToWishlist(userId, productId);
|
|
sendSuccess(res, item, 'Added to wishlist', 201);
|
|
}
|
|
```
|
|
|
|
1. **Create Routes** (`backend/src/routes/wishlist.ts`):
|
|
|
|
```typescript
|
|
import { Router } from 'express';
|
|
import { authenticate } from '../middlewares/authenticate';
|
|
import * as wishlistController from '../controllers/wishlistController';
|
|
|
|
const router = Router();
|
|
|
|
router.post('/', authenticate, wishlistController.addItem);
|
|
router.get('/', authenticate, wishlistController.getItems);
|
|
|
|
export default router;
|
|
```
|
|
|
|
1. **Mount Routes** (`backend/src/server.ts`):
|
|
|
|
```typescript
|
|
import wishlistRoutes from './routes/wishlist';
|
|
app.use('/api/wishlist', wishlistRoutes);
|
|
```
|
|
|
|
#### Frontend Steps
|
|
|
|
1. **Add Types** (`frontend/src/@types/index.ts`):
|
|
|
|
```typescript
|
|
export interface WishlistItem {
|
|
id: number;
|
|
productId: number;
|
|
product: Product;
|
|
createdAt: string;
|
|
}
|
|
```
|
|
|
|
1. **Create API Client** (`frontend/src/api/wishlist.ts`):
|
|
|
|
```typescript
|
|
import apiClient from './client';
|
|
|
|
export const wishlistApi = {
|
|
async getAll() {
|
|
const response = await apiClient.get('/wishlist');
|
|
return response.data.data;
|
|
},
|
|
|
|
async add(productId: number) {
|
|
const response = await apiClient.post('/wishlist', { productId });
|
|
return response.data.data;
|
|
},
|
|
};
|
|
```
|
|
|
|
1. **Create Hook** (`frontend/src/hooks/useWishlist.ts`):
|
|
|
|
```typescript
|
|
import { useState } from 'react';
|
|
import { wishlistApi } from '../api/wishlist';
|
|
|
|
export function useWishlist() {
|
|
const [items, setItems] = useState([]);
|
|
|
|
const addToWishlist = async (productId: number) => {
|
|
await wishlistApi.add(productId);
|
|
// Refetch items...
|
|
};
|
|
|
|
return { items, addToWishlist };
|
|
}
|
|
```
|
|
|
|
1. **Use in Component** (`frontend/src/components/WishlistButton.tsx`):
|
|
|
|
```typescript
|
|
import { useWishlist } from '../hooks/useWishlist';
|
|
|
|
export function WishlistButton({ productId }) {
|
|
const { addToWishlist } = useWishlist();
|
|
|
|
return (
|
|
<button onClick={() => addToWishlist(productId)}>
|
|
Add to Wishlist
|
|
</button>
|
|
);
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 🔄 Data Flow Example
|
|
|
|
```
|
|
User clicks "Add to Cart" button
|
|
↓
|
|
Component calls `productApi.addToCart(id)`
|
|
↓
|
|
API client sends POST /api/cart with JWT token
|
|
↓
|
|
Backend: authenticate middleware verifies token
|
|
↓
|
|
Backend: validateCart middleware validates request
|
|
↓
|
|
Backend: cartController.addItem() receives request
|
|
↓
|
|
Backend: cartService.addItem() handles business logic
|
|
↓
|
|
Backend: cartModel (Prisma) saves to database
|
|
↓
|
|
Backend: returns { success: true, data: cart }
|
|
↓
|
|
Frontend: receives response, updates UI
|
|
↓
|
|
User sees success message
|
|
```
|
|
|
|
---
|
|
|
|
## 🔐 Security Features
|
|
|
|
### Frontend
|
|
|
|
- JWT tokens stored in localStorage
|
|
- Automatic token injection via axios interceptors
|
|
- Protected routes redirect unauthenticated users
|
|
- Client-side validation before API calls
|
|
|
|
### Backend
|
|
|
|
- JWT authentication on protected endpoints
|
|
- Request validation with Zod schemas
|
|
- Helmet for security headers
|
|
- CORS configured for specific origins
|
|
- Password hashing with bcrypt
|
|
- SQL injection prevention via Prisma
|
|
|
|
---
|
|
|
|
## 📊 Testing Strategy
|
|
|
|
### Frontend Testing
|
|
|
|
```bash
|
|
# Unit tests for components
|
|
npm run test:unit
|
|
|
|
# Integration tests for hooks
|
|
npm run test:integration
|
|
|
|
# E2E tests
|
|
npm run test:e2e
|
|
```
|
|
|
|
### Backend Testing
|
|
|
|
```bash
|
|
# Unit tests for services
|
|
npm run test:unit
|
|
|
|
# Integration tests for routes
|
|
npm run test:integration
|
|
|
|
# API tests
|
|
npm run test:api
|
|
```
|
|
|
|
---
|
|
|
|
## 🚢 Deployment
|
|
|
|
### Frontend (Vercel/Netlify)
|
|
|
|
```bash
|
|
cd frontend
|
|
npm run build
|
|
# Deploy dist/ folder
|
|
```
|
|
|
|
### Backend (Railway/Heroku/AWS)
|
|
|
|
```bash
|
|
cd backend
|
|
npm run build
|
|
npm start
|
|
```
|
|
|
|
---
|
|
|
|
## 📚 Next Steps
|
|
|
|
1. **Add Sample Components**: Create Button, Card, Navbar in `frontend/src/components/`
|
|
2. **Add Sample Pages**: Create HomePage, ProductPage in `frontend/src/pages/`
|
|
3. **Implement Auth**: Complete login/register in backend
|
|
4. **Add Products CRUD**: Implement full product management
|
|
5. **Add Tests**: Write unit and integration tests
|
|
6. **Set Up CI/CD**: GitHub Actions for automated deployment
|
|
|
|
---
|
|
|
|
## 💡 Why This Structure Works
|
|
|
|
✅ **Scalable**: Each part has a clear responsibility
|
|
✅ **Maintainable**: Easy to find and update code
|
|
✅ **Testable**: Layers can be tested independently
|
|
✅ **Team-Friendly**: Multiple developers can work without conflicts
|
|
✅ **Production-Ready**: Security, error handling, logging built-in
|
|
✅ **Type-Safe**: TypeScript catches bugs before runtime
|
|
|
|
---
|
|
|
|
**You now have a professional, production-ready architecture!** 🎉
|
|
|
|
Start by implementing your first feature following the guide above.
|