OOP Specialist

Apply these principles when designing, writing, or reviewing object-oriented code.

Core Constraints (Heuristics)

• •Keep methods small and intention-revealing (extract aggressively)
• •Keep classes/modules focused (one reason to change)
• •Prefer parameter objects over long parameter lists

SOLID Principles

GRASP Principles

• •Information Expert: Assign responsibility to class with the data
• •Creator: Create objects where they're contained/aggregated/used
• •Low Coupling: Minimize dependencies between classes
• •High Cohesion: Keep class responsibilities focused
• •Controller: Delegate UI events to controller, not domain objects
• •Polymorphism: Replace conditionals on type with polymorphic methods
• •Pure Fabrication: Create utility classes when no domain class fits
• •Protected Variations: Hide change-prone areas behind interfaces

Key Heuristics

Tell, Don't Ask

// Bad: pull data out, decide elsewhere
if (order.status === "pending" && order.totalCents > 10_000) {
  order.applyDiscountPercent(10);
}

// Good: tell the object what to do
order.applyDiscountIfEligible();

Composition Over Inheritance

Use inheritance only when child "is-a" parent. Prefer composition for "has-a" or "uses-a" relationships.

type Item = { id: string; priceCents: number };
type PricingStrategy = { priceTotalCents: (items: Item[]) => number };

class Order {
  constructor(private readonly pricingStrategy: PricingStrategy) {}

  totalCents(items: Item[]) {
    return this.pricingStrategy.priceTotalCents(items);
  }
}

DRY (Don't Repeat Yourself)

Extract duplicated logic. Three occurrences = extract immediately.

Design Patterns Quick Reference

Functional Patterns

Prefer map, filter/select, reduce over manual iteration:

// Bad
const results: string[] = [];
for (const item of items) {
  if (item.active) results.push(item.name);
}

// Good
const results = items.filter((i) => i.active).map((i) => i.name);

Clean Architecture Layers

┌─────────────────────────────────────┐
│  Frameworks & Drivers (outer)       │  ← Next.js, React, Prisma/Postgres
├─────────────────────────────────────┤
│  Interface Adapters                 │  ← Controllers, Serializers
├─────────────────────────────────────┤
│  Use Cases                          │  ← Service Objects
├─────────────────────────────────────┤
│  Entities (inner)                   │  ← Domain Models
└─────────────────────────────────────┘

Dependencies point INWARD only.

In this repo, a practical mapping is:

• •Frameworks & drivers: Next.js App Router, NextAuth, Prisma, Postgres
• •Interface adapters: src/app/* pages, route handlers, server actions
• •Use cases: src/services/* (business rules)
• •Entities: Prisma models + domain types

References

For detailed patterns and examples:

• •SOLID examples: See references/solid.md
• •Design patterns: See references/design-patterns.md
• •GRASP detailed: See references/grasp.md