coding-style

Coding Style Guidelines

Core Principles

1. Immutability

NEVER mutate, ALWAYS create new:

// Arrays
const added = [...items, newItem]
const removed = items.filter(i => i.id !== id)
const updated = items.map(i => i.id === id ? { ...i, ...changes } : i)

// Objects
const updated = { ...user, name: newName }
const nested = { ...obj, nested: { ...obj.nested, value: newValue } }

2. Small Functions

Keep functions under 50 lines:

// BAD: Large function doing multiple things
function processOrder(order) {
  // 100+ lines of code...
}

// GOOD: Split into focused functions
function validateOrder(order: Order): ValidationResult { }
function calculateTotal(items: Item[]): number { }
function applyDiscounts(total: number, discounts: Discount[]): number { }
function createInvoice(order: Order, total: number): Invoice { }

3. Small Files

Keep files under 800 lines:

src/
├── features/
│   └── checkout/
│       ├── components/
│       │   ├── CartItem.tsx       # ~100 lines
│       │   ├── CartSummary.tsx    # ~80 lines
│       │   └── CheckoutForm.tsx   # ~150 lines
│       ├── hooks/
│       │   └── useCheckout.ts     # ~50 lines
│       └── services/
│           └── checkout.ts        # ~100 lines

4. Explicit Types

No implicit any:

// BAD
function process(data) {
  return data.map(item => item.value)
}

// GOOD
function process(data: DataItem[]): string[] {
  return data.map(item => item.value)
}

5. Error Handling

Always handle errors:

async function fetchUser(id: string): Promise<Result<User>> {
  try {
    const user = await db.users.findUnique({ where: { id } })
    if (!user) {
      return { success: false, error: 'User not found' }
    }
    return { success: true, data: user }
  } catch (error) {
    console.error('Failed to fetch user:', error)
    return { success: false, error: 'Failed to fetch user' }
  }
}

Code Review Checklist

Structure

• Functions < 50 lines
• Files < 800 lines
• No deep nesting (> 4 levels)
• Single responsibility