Lesson 22-React Project Architecture and Engineering

Project Architecture Design

SPA vs. MPA Architecture Design

SPA Core Architecture:

src/
├── assets/          # Static assets
├── components/      # Common components
├── pages/           # Page components
├── routes/          # Route configurations
├── store/           # State management
├── services/        # API services
├── utils/           # Utility functions
└── App.js           # Root component

MPA Architecture Features:

  1. Multiple independent HTML entry files.
  2. Each page is built and bundled separately.
  3. Suitable for SEO-heavy scenarios.
  4. Isolated state between pages.

SPA Advantages Comparison:

FeatureSPAMPA
User ExperienceSeamless page transitionsPage reloads with white screen
Build ComplexitySingle entry pointMultiple entry configurations
SEO FriendlinessRequires SSR supportNaturally SEO-friendly
Server LoadLower after initial loadFull page requests each time

Modular and Component-Based Design

Modular Design Principles:

  1. Functional Isolation: Each module has distinct responsibilities.
  2. Clear Interfaces: Well-defined module boundaries.
  3. Controlled Dependencies: Avoid circular dependencies.

Component Classification System:

components/
├── common/       # General-purpose components (Button, Input)
├── layout/       # Layout components (Header, Footer)
├── business/     # Business-specific components (ProductCard, OrderList)
└── hooks/        # Custom Hooks (useFetch, useAuth)

Component Design Guidelines:

  1. Single Responsibility: One component, one purpose.
  2. Controlled Preference: Prioritize controlled component patterns.
  3. Props Design:
    • Clearly mark required props.
    • Set sensible default values.
    • Define complex props with TypeScript interfaces.

State Management Architecture

Redux Architecture Design:

store/
├── index.js          # Store configuration
├── features/         # Feature-based organization
│   ├── user/         # User module
│   │   ├── userSlice.js
│   │   └── userAPI.js
│   └── product/      # Product module
└── middleware/       # Custom middleware

MobX Architecture Features:

  1. Reactive Data: Automatically tracks dependencies.
  2. Less Boilerplate: Simpler than Redux.
  3. Object-Oriented: Ideal for domain model design.

State Management Selection Guidelines:

  1. Complex application state: Redux Toolkit.
  2. Simple state sharing: Context + useReducer.
  3. Domain-driven models: MobX.
  4. Server-side state: React Query/SWR.

Routing Architecture Design

Nested Routing Implementation:

<Routes>
  <Route path="/" element={<Layout />}>
    <Route index element={<Home />} />
    <Route path="products" element={<Products />}>
      <Route path=":id" element={<ProductDetail />} />
    </Route>
    <Route path="about" element={<About />} />
  </Route>
</Routes>

Dynamic Routing Configuration:

// Dynamic component import
const ProductPage = React.lazy(() => import('./pages/Product'));

// Permission-based routing
const ProtectedRoute = ({ children }) => {
  const { isAuthenticated } = useAuth();
  return isAuthenticated ? children : <Navigate to="/login" />;
};

<Routes>
  <Route path="/admin" element={<ProtectedRoute />}>
    <Route path="dashboard" element={<AdminDashboard />} />
  </Route>
</Routes>

Project Directory Standards

Recommended Directory Structure:

my-react-app/
├── .github/               # GitHub configurations
│   └── workflows/         # CI/CD workflows
├── public/                # Static assets (not bundled)
├── src/
│   ├── api/               # API request encapsulation
│   ├── assets/            # Images, fonts, etc.
│   ├── components/        # Reusable components
│   ├── config/            # Application configurations
│   ├── hooks/             # Custom Hooks
│   ├── layouts/           # Layout components
│   ├── pages/             # Page components
│   ├── routes/            # Route configurations
│   ├── store/             # State management
│   ├── styles/            # Global styles
│   ├── types/             # TypeScript types
│   ├── utils/             # Utility functions
│   ├── App.tsx            # Root component
│   └── main.tsx           # Entry file
├── .eslintrc.js           # ESLint configuration
├── .prettierrc            # Prettier configuration
├── tsconfig.json          # TypeScript configuration
└── vite.config.ts         # Vite configuration

Naming Convention Recommendations:

  1. Component files: PascalCase (e.g., UserProfile.tsx).
  2. Utility functions: camelCase (e.g., formatDate.ts).
  3. Style files: Match component name (e.g., UserProfile.module.css).
  4. Test files: ComponentName.test.tsx.

Engineering Toolchain

Advanced CRA Configuration

Environment Variables Configuration:

# .env.development
REACT_APP_API_URL=http://localhost:3001

# .env.production
REACT_APP_API_URL=https://api.example.com

Proxy Configuration:

// craco.config.js (using craco to override CRA config)
module.exports = {
  devServer: {
    proxy: {
      '/api': {
        target: 'http://localhost:3001',
        changeOrigin: true,
        pathRewrite: { '^/api': '' }
      }
    }
  }
}

Deep Webpack Configuration

Custom Loader Example:

// webpack.config.js
module.exports = {
  module: {
    rules: [
      {
        test: /\.md$/,
        use: [
          'html-loader',
          {
            loader: path.resolve(__dirname, 'loaders/markdown-loader.js'),
            options: { highlight: true }
          }
        ]
      }
    ]
  }
}

Performance Optimization Strategies:

  1. Code Splitting:
// Dynamic import
const LazyComponent = React.lazy(() => import('./LazyComponent'));

// Webpack magic comment
const HeavyComponent = React.lazy(() => import(
  /* webpackChunkName: "heavy-component" */ 
  './HeavyComponent'
));
  1. Caching Strategy:
output: {
  filename: '[name].[contenthash].js',
  chunkFilename: '[name].[contenthash].chunk.js'
}

Vite Application Practices

Vite Configuration Example:

// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  server: {
    port: 3000,
    proxy: {
      '/api': {
        target: 'http://localhost:3001',
        changeOrigin: true
      }
    }
  },
  build: {
    rollupOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom']
        }
      }
    }
  }
})

Vite Advantages:

  1. Lightning-Fast Cold Start: ESM-based instant compilation.
  2. On-Demand Compilation: Compiles only the code needed for the current page.
  3. Native ESM: Development server without bundling.

Code Linting Tools

ESLint Configuration:

// .eslintrc.js
module.exports = {
  extends: [
    'eslint:recommended',
    'plugin:react/recommended',
    'plugin:@typescript-eslint/recommended'
  ],
  rules: {
    'react-hooks/rules-of-hooks': 'error',
    'react-hooks/exhaustive-deps': 'warn'
  },
  settings: {
    react: {
      version: 'detect'
    }
  }
}

Prettier Integration:

// .prettierrc
{
  "semi": true,
  "singleQuote": true,
  "tabWidth": 2,
  "trailingComma": "es5"
}

Husky + lint-staged:

// package.json
{
  "husky": {
    "hooks": {
      "pre-commit": "lint-staged"
    }
  },
  "lint-staged": {
    "*.{js,jsx,ts,tsx}": ["eslint --fix", "prettier --write"],
    "*.{css,scss}": ["prettier --write"]
  }
}

Testing Framework Configuration

Jest Configuration:

// jest.config.js
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'jsdom',
  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts'],
  moduleNameMapper: {
    '\\.(css|less|scss|sass)$': 'identity-obj-proxy'
  }
}

React Testing Library Example:

// Button.test.tsx
import { render, screen, fireEvent } from '@testing-library/react'
import Button from './Button'

test('renders button with text', () => {
  render(<Button>Click me</Button>)
  const buttonElement = screen.getByText(/click me/i)
  expect(buttonElement).toBeInTheDocument()
})

test('calls onClick when clicked', () => {
  const handleClick = jest.fn()
  render(<Button onClick={handleClick}>Click me</Button>)
  fireEvent.click(screen.getByText(/click me/i))
  expect(handleClick).toHaveBeenCalledTimes(1)
})

Performance Optimization and Deployment

Code Splitting Strategies

Route-Level Splitting:

const Home = React.lazy(() => import('./pages/Home'))
const About = React.lazy(() => import('./pages/About'))

<Suspense fallback={<Spinner />}>
  <Routes>
    <Route path="/" element={<Home />} />
    <Route path="/about" element={<About />} />
  </Routes>
</Suspense>

Component-Level Splitting:

const HeavyChart = React.lazy(() => import('./HeavyChart'))

function Dashboard() {
  return (
    <div>
      <h1>Dashboard</h1>
      <Suspense fallback={<ChartPlaceholder />}>
        <HeavyChart />
      </Suspense>
    </div>
  )
}

Resource Optimization Strategies

Gzip Compression Configuration:

# Nginx configuration example
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
gzip_comp_level 6;
gzip_min_length 1024;

CDN Configuration Best Practices:

  1. Static asset versioning: main.[contenthash].js.
  2. Cache strategies:
    • HTML: no-cache.
    • JS/CSS: max-age=31536000.
    • Images: max-age=604800.

SSR and SSG Solutions

Next.js SSR Configuration:

// pages/_app.tsx
import type { AppProps } from 'next/app'
import { Provider } from 'react-redux'
import store from '../store'

function MyApp({ Component, pageProps }: AppProps) {
  return (
    <Provider store={store}>
      <Component {...pageProps} />
    </Provider>
  )
}

export default MyApp

Static Generation Optimization:

// pages/products/[id].tsx
export async function getStaticProps({ params }) {
  const product = await fetchProduct(params.id)
  return {
    props: { product },
    revalidate: 60 // ISR: Revalidate every 60 seconds
  }
}

export async function getStaticPaths() {
  const products = await fetchAllProducts()
  return {
    paths: products.map(p => ({ params: { id: p.id } })),
    fallback: 'blocking'
  }
}

Performance Monitoring Solutions

Web Vitals Monitoring:

// Using web-vitals library
import { getCLS, getFID, getLCP } from 'web-vitals'

function sendToAnalytics(metric) {
  console.log(metric)
  // Send to monitoring system
}

getCLS(sendToAnalytics)
getFID(sendToAnalytics)
getLCP(sendToAnalytics)

Lighthouse Optimization Recommendations:

  1. Priority Metrics:
    • First Contentful Paint (FCP).
    • Largest Contentful Paint (LCP).
    • Cumulative Layout Shift (CLS).
  2. Optimization Directions:
    • Inline critical CSS.
    • Lazy-load images.
    • Preconnect critical third-party resources.

CI/CD Practices

GitHub Actions Example:

# .github/workflows/deploy.yml
name: Deploy to Production

on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: '16'
      - run: npm ci
      - run: npm run build
      - uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./dist

Dockerization Configuration:

# Dockerfile
FROM node:16-alpine as builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

By implementing the above architecture design and engineering practices, you can build high-performance, maintainable, and scalable React applications. The key is to select appropriate technical solutions based on project scale and team characteristics, while continuously monitoring performance metrics and user experience during development.

Share your love