generate_map

Run the generate_map prompt

Use the generate_map prompt to document this codebase

Run generate_map for repo="frontend"

# Architecture Overview

## Codebase Statistics

- **Files**: 342
- **Symbols**: 1,248 (functions, classes, methods)
- **Processes**: 87 execution flows
- **Indexed**: 2024-01-15

## Functional Areas

The codebase is organized into 47 functional areas detected through community analysis:

### Core Modules

#### Authentication (23 symbols, 78% cohesion)
Handles user authentication, session management, and token generation.

Key symbols:
- `login`, `logout`, `validateToken`, `refreshToken`
- `AuthProvider`, `AuthMiddleware`
- `hashPassword`, `comparePasswords`

#### Database (45 symbols, 82% cohesion)
Database access layer with query builders and ORM utilities.

Key symbols:
- `findUserByEmail`, `createUser`, `updateUser`
- `executeQuery`, `transaction`
- `ConnectionPool`, `QueryBuilder`

#### API Routes (67 symbols, 71% cohesion)
HTTP request handlers and routing logic.

Key symbols:
- `loginHandler`, `registerHandler`, `profileHandler`
- `orderHandler`, `checkoutHandler`
- `apiRouter`, `middleware`

### Supporting Modules

#### Payment Processing (28 symbols, 80% cohesion)
Payment gateway integration and transaction handling.

#### User Management (34 symbols, 75% cohesion)
User profile management, permissions, and preferences.

## Key Execution Flows

### User Login Flow (API, 12 steps)

Complete authentication flow from request to response:

1. `loginHandler` (src/routes/auth.ts) — Entry point
2. `validateCredentials` (src/auth/validate.ts) — Input validation
3. `hashPassword` (src/auth/utils.ts) — Password hashing
4. `findUserByEmail` (src/db/users.ts) — Database lookup
5. `comparePasswords` (src/auth/utils.ts) — Password verification
6. `generateToken` (src/auth/tokens.ts) — JWT generation
7. `signJWT` (src/auth/jwt.ts) — Token signing
8. `createSession` (src/db/sessions.ts) — Session creation
9. `insertSession` (src/db/queries.ts) — Database insert
10. `auditLog` (src/logging/audit.ts) — Audit logging
11. `sendWelcomeEmail` (src/email/templates.ts) — Email notification
12. `returnResponse` (src/routes/auth.ts) — HTTP response

### Order Checkout (API, 23 steps)

E-commerce checkout and payment processing flow:

1. `checkoutHandler` (src/routes/orders.ts) — Entry point
2. `validateCart` (src/cart/validate.ts) — Cart validation
3. `calculateTotal` (src/cart/totals.ts) — Price calculation
4. `createOrder` (src/orders/create.ts) — Order creation
5. `processPayment` (src/payments/process.ts) — Payment gateway call
...
23. `sendConfirmationEmail` (src/email/templates.ts) — Order confirmation

### Payment Processing (Event, 15 steps)

Asynchronous payment webhook handler:

1. `webhookHandler` (src/webhooks/payment.ts) — Entry point
2. `verifySignature` (src/webhooks/verify.ts) — Webhook authentication
3. `parsePayload` (src/webhooks/parse.ts) — JSON parsing
...

## Architecture Diagram

```mermaid
graph TB
    Client[Client Request]
    
    subgraph API Layer
        Router[API Routes]
        Auth[Authentication]
        Handlers[Request Handlers]
    end
    
    subgraph Business Logic
        Orders[Order Management]
        Cart[Cart Service]
        Payments[Payment Processing]
        Users[User Management]
    end
    
    subgraph Data Layer
        DB[(Database)]
        Cache[(Cache)]
    end
    
    subgraph External
        PaymentGW[Payment Gateway]
        Email[Email Service]
    end
    
    Client --> Router
    Router --> Auth
    Auth --> Handlers
    
    Handlers --> Orders
    Handlers --> Users
    Orders --> Cart
    Orders --> Payments
    
    Orders --> DB
    Users --> DB
    Cart --> Cache
    
    Payments --> PaymentGW
    Orders --> Email
    Auth --> Email
    
    PaymentGW -.Webhook.-> Payments
```

## Module Dependencies

### High Cohesion Modules (>80%)
These modules are well-isolated with clear boundaries:
- Database (82%)
- Payment Processing (80%)

### Core Integration Points
- **Authentication** — Used by all API routes
- **Database** — Central data access layer
- **Payment Processing** — Integrated with Orders and Webhooks

## Entry Points

Main application entry points:

1. **API Server** — HTTP request handling (87 processes)
2. **CLI Commands** — Admin tools and scripts (12 processes)
3. **Event Handlers** — Webhooks and async jobs (8 processes)

## Recommendations

1. **High Cohesion**: Database and Payment modules are well-structured
2. **Consider Splitting**: API Routes module (71% cohesion) could be split by domain
3. **Shared Dependencies**: Authentication is heavily used — ensure backward compatibility

Generate architecture map focusing on the authentication system

Create architecture docs with sequence diagrams instead of component diagrams

Generate minimal architecture overview (no process traces)