78:T443,// ❌ WRONG: Interface exposes database concepts interface BadUserDAO { // Clients shouldn't know about SQL ResultSets executeQuery(sql: string): ResultSet; // Clients shouldn't manage database connections getConnection(): Connection; // Exposes database-specific concepts (OFFSET/LIMIT) findUsers(offset: number, limit: number): ResultSet; } // ✅ CORRECT: Interface speaks business language interface UserDAO { // Domain-focused methods with domain-typed returns findById(userId: string): Promise; // Business concepts (active users), not database concepts findActiveUsersByRegion(region: Region): Promise; // Pagination using domain abstractions findAll(page: PageRequest): Promise>; // CRUD operations returning domain entities save(user: User): Promise; delete(userId: string): Promise; // Business-meaningful queries findByEmailDomain(domain: string): Promise; countBySubscriptionTier(tier: SubscriptionTier): Promise; }79:T52b,/** * UserDAO Interface * * Defines the contract for user data access operations. * All implementations must fulfill this contract. */ export interface UserDAO { /** * Retrieves a user by their unique identifier. * @param id - The user's unique identifier * @returns The user if found, null otherwise */ findById(id: string): Promise; /** * Retrieves all users matching the given criteria. * @param criteria - Search criteria (supports partial matching) * @returns Array of matching users, empty if none found */ findByCriteria(criteria: UserSearchCriteria): Promise; /** * Persists a user (creates if new, updates if existing). * @param user - The user to persist * @returns The persisted user with generated fields populated */ save(user: User): Promise; /** * Removes a user from the system. * @param id - The user's unique identifier * @returns True if user was deleted, false if not found */ delete(id: string): Promise; /** * Checks if a user with the given email already exists. * @param email - The email to check * @returns True if email is already registered */ existsByEmail(email: string): Promise; }7a:T106d,import { Pool, QueryResult } from 'pg'; import { UserDAO } from './user-dao.interface'; import { User, UserSearchCriteria } from '../domain/user'; /** * PostgreSQL implementation of UserDAO. * * This implementation encapsulates all PostgreSQL-specific concerns: * - SQL query construction * - Connection pool management * - Result set mapping to domain objects * - Transaction handling */ export class PostgresUserDAO implements UserDAO { private readonly pool: Pool; constructor(pool: Pool) { this.pool = pool; } async findById(id: string): Promise { const query = ` SELECT id, email, name, status, tier, created_at, updated_at FROM users WHERE id = $1 `; const result = await this.pool.query(query, [id]); if (result.rows.length === 0) { return null; } return this.mapRowToUser(result.rows[0]); } async findByCriteria(criteria: UserSearchCriteria): Promise { const { conditions, values } = this.buildWhereClause(criteria); const query = ` SELECT id, email, name, status, tier, created_at, updated_at FROM users ${conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : ''} ORDER BY created_at DESC LIMIT ${criteria.limit || 100} OFFSET ${criteria.offset || 0} `; const result = await this.pool.query(query, values); return result.rows.map(row => this.mapRowToUser(row)); } async save(user: User): Promise { const query = ` INSERT INTO users (id, email, name, status, tier, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (id) DO UPDATE SET email = EXCLUDED.email, name = EXCLUDED.name, status = EXCLUDED.status, tier = EXCLUDED.tier, updated_at = NOW() RETURNING * `; const values = [ user.id, user.email, user.name, user.status, user.tier, user.createdAt, new Date() ]; const result = await this.pool.query(query, values); return this.mapRowToUser(result.rows[0]); } async delete(id: string): Promise { const query = 'DELETE FROM users WHERE id = $1'; const result = await this.pool.query(query, [id]); return result.rowCount > 0; } async existsByEmail(email: string): Promise { const query = 'SELECT 1 FROM users WHERE email = $1 LIMIT 1'; const result = await this.pool.query(query, [email]); return result.rows.length > 0; } /** * Maps a database row to a User domain object. * This method isolates the mapping logic for maintainability. */ private mapRowToUser(row: any): User { return new User({ id: row.id, email: row.email, name: row.name, status: row.status, tier: row.tier, createdAt: row.created_at, updatedAt: row.updated_at }); } /** * Builds dynamic WHERE clause from search criteria. * Prevents SQL injection through parameterized queries. */ private buildWhereClause(criteria: UserSearchCriteria): { conditions: string[]; values: any[]; } { const conditions: string[] = []; const values: any[] = []; let paramIndex = 1; if (criteria.email) { conditions.push(`email ILIKE $${paramIndex++}`); values.push(`%${criteria.email}%`); } if (criteria.status) { conditions.push(`status = $${paramIndex++}`); values.push(criteria.status); } if (criteria.tier) { conditions.push(`tier = $${paramIndex++}`); values.push(criteria.tier); } return { conditions, values }; } }7b:T8af,import { UserService } from './user-service'; import { UserDAO } from './user-dao.interface'; import { User } from '../domain/user'; describe('UserService', () => { let mockUserDAO: jest.Mocked; let userService: UserService; beforeEach(() => { // Create a mock implementation of the DAO interface mockUserDAO = { findById: jest.fn(), findByCriteria: jest.fn(), save: jest.fn(), delete: jest.fn(), existsByEmail: jest.fn(), }; // Inject the mock into the service userService = new UserService(mockUserDAO); }); describe('registerUser', () => { it('should reject duplicate emails', async () => { // Arrange: Mock DAO to indicate email exists mockUserDAO.existsByEmail.mockResolvedValue(true); // Act & Assert await expect( userService.registerUser({ email: 'existing@example.com', name: 'Test User' }) ).rejects.toThrow('Email already registered'); // Verify DAO was called correctly expect(mockUserDAO.existsByEmail).toHaveBeenCalledWith( 'existing@example.com' ); expect(mockUserDAO.save).not.toHaveBeenCalled(); }); it('should create user when email is unique', async () => { // Arrange mockUserDAO.existsByEmail.mockResolvedValue(false); mockUserDAO.save.mockImplementation(async (user) => ({ ...user, id: 'generated-id' })); // Act const result = await userService.registerUser({ email: 'new@example.com', name: 'New User' }); // Assert expect(result.id).toBe('generated-id'); expect(mockUserDAO.save).toHaveBeenCalledWith( expect.objectContaining({ email: 'new@example.com', name: 'New User' }) ); }); }); });7c:Te36,// ───────────────────────────────────────────────────────── // CLEAN ARCHITECTURE EXAMPLE // ───────────────────────────────────────────────────────── // Inner Layer: Domain // (No dependencies on outer layers) export class User { constructor( public readonly id: string, public readonly email: string, public readonly name: string ) {} } // ───────────────────────────────────────────────────────── // Use Cases Layer: Defines what capabilities the app needs // ───────────────────────────────────────────────────────── // The interface is defined here - part of the use case contract export interface UserRepository { // or UserDAO - name varies by convention findById(id: string): Promise; save(user: User): Promise; } export class RegisterUserUseCase { constructor(private readonly userRepository: UserRepository) {} async execute(command: RegisterUserCommand): Promise { const existing = await this.userRepository.findById(command.userId); if (existing) throw new Error('User already exists'); const user = new User(command.userId, command.email, command.name); return this.userRepository.save(user); } } // ───────────────────────────────────────────────────────── // Infrastructure Layer: Concrete implementations // ───────────────────────────────────────────────────────── // Implementation lives in outer infrastructure ring export class PostgresUserRepository implements UserRepository { constructor(private readonly pool: Pool) {} async findById(id: string): Promise { // PostgreSQL-specific implementation const result = await this.pool.query( 'SELECT * FROM users WHERE id = $1', [id] ); return result.rows[0] ? this.mapToUser(result.rows[0]) : null; } async save(user: User): Promise { // PostgreSQL-specific implementation await this.pool.query( 'INSERT INTO users (id, email, name) VALUES ($1, $2, $3) ON CONFLICT (id) DO UPDATE SET email = $2, name = $3', [user.id, user.email, user.name] ); return user; } private mapToUser(row: any): User { return new User(row.id, row.email, row.name); } } // ───────────────────────────────────────────────────────── // Composition Root: Wiring dependencies together // ───────────────────────────────────────────────────────── export function configureApplication(pool: Pool) { const userRepository = new PostgresUserRepository(pool); const registerUserUseCase = new RegisterUserUseCase(userRepository); return { registerUserUseCase }; }7d:Tb83,// ───────────────────────────────────────────────────────── // PRINCIPLE VIOLATIONS (WHAT NOT TO DO) // ───────────────────────────────────────────────────────── // ❌ Violates Single Entity Focus - handles unrelated entities interface BadDAO { getUser(id: string): Promise; getProduct(id: string): Promise; // Wrong: different aggregate getOrder(id: string): Promise; // Wrong: different aggregate } // ❌ Violates Domain Language - uses technical database terms interface TechnicalDAO { executeSelectQuery(sql: string): Promise; // Wrong: exposes SQL getResultSetById(id: string): Promise; // Wrong: exposes cursors } // ❌ Violates Domain Objects In/Out - returns database types interface LeakyDAO { findUser(id: string): Promise; // Wrong: database type saveUser(data: Record): void; // Wrong: generic map } // ───────────────────────────────────────────────────────── // PRINCIPLE ADHERENCE (CORRECT APPROACH) // ───────────────────────────────────────────────────────── // ✅ Single Entity Focus - handles one aggregate interface UserDAO { findById(id: string): Promise; findByEmail(email: string): Promise; findActiveUsers(): Promise; save(user: User): Promise; delete(id: string): Promise; } // ✅ Domain Language - business-meaningful operations interface OrderDAO { findById(id: OrderId): Promise; findPendingOrdersForCustomer(customerId: CustomerId): Promise; findOrdersRequiringFulfillment(): Promise; save(order: Order): Promise; markAsShipped(orderId: OrderId, trackingNumber: string): Promise; } // ✅ Consistent Error Translation class PostgresOrderDAO implements OrderDAO { async findById(id: OrderId): Promise { try { const result = await this.pool.query( 'SELECT * FROM orders WHERE id = $1', [id.value] ); return result.rows[0] ? this.mapToOrder(result.rows[0]) : null; } catch (error) { if (error instanceof DatabaseConnectionError) { throw new PersistenceUnavailableException( 'Database temporarily unavailable', error ); } throw new DataAccessException('Failed to retrieve order', error); } } }70:{"json":{"id":"seed_be377fd83fe99b94b8c63bad73360aae","slug":"dao-pattern","category":"System Design (LLD)","topic":"Data Access Object (DAO) Pattern","title":"Data Access Object (DAO) Pattern","description":"Master the Data Access Object pattern for decoupling persistence logic from business logic. Learn when and how to implement DAOs, understand their distinction from repositories, and apply them effectively in enterprise applications.","difficulty":"INTERMEDIATE","estimatedMinutes":60,"pages":[{"id":"seed_ce58046c327b88f325400e770563c6df","title":"DAO Definition and Purpose","order":0,"content":[{"id":"opening-hook","title":"The Persistence Dilemma","content":[{"data":{"content":"Every non-trivial software application must persist data. Whether it's user profiles, financial transactions, product catalogs, or sensor readings—data must survive beyond the lifetime of a single request or process. This fundamental requirement creates one of software engineering's most consequential architectural decisions: **how should application code interact with data storage?**\n\nThe naive approach—embedding database queries directly into business logic—is seductive in its simplicity. A quick SQL query here, a direct file write there. For small applications, it works. But as systems grow, this approach becomes an architectural liability that compounds in severity with every new feature."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"This page establishes the foundational understanding of the Data Access Object (DAO) pattern. You will learn its precise definition, historical origins, structural anatomy, and the critical problems it solves. By the end, you'll understand why DAO has remained a cornerstone of enterprise architecture for over two decades.","variant":"info"},"type":"callout"}]},{"id":"historical-context","title":"The Historical Context","content":[{"data":{"content":"To truly understand the DAO pattern, we must appreciate the problem landscape that gave birth to it. The pattern emerged in the late 1990s during the explosion of enterprise Java development, codified in Sun Microsystems' **Core J2EE Patterns** catalog.\n\n**The Pre-DAO World:**\n\nIn early enterprise applications, data access code was typically scattered throughout the application. Business logic classes contained JDBC code, SQL strings were hardcoded into methods, and connection management was duplicated across dozens of classes. This created several cascading problems:"},"type":"text"},{"data":{"items":["**Tight Coupling** — Business logic was inseparable from database specifics. Changing the database vendor meant rewriting half the application.","**Code Duplication** — The same boilerplate for opening connections, handling exceptions, and releasing resources was copied everywhere.","**Testing Impossibility** — Unit testing business logic required a live database, making tests slow, flaky, and often skipped entirely.","**Maintenance Nightmare** — Schema changes rippled through the entire codebase, turning simple column renames into multi-day projects.","**Security Vulnerabilities** — SQL injection risks multiplied as query construction logic spread across inexperienced hands."],"title":{"icon":"AlertTriangle","text":"Pre-DAO Architectural Problems","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"content":"**The Pattern's Birth:**\n\nThe DAO pattern emerged as a structured response to these challenges. Its core insight was deceptively simple: **isolate all data access logic behind a well-defined interface**. This single architectural decision addressed each of the problems above, transforming chaotic codebases into maintainable systems.\n\nThe pattern's formal documentation in the J2EE Patterns catalog (circa 2001-2003) established it as a canonical solution, and its principles have transcended Java to become a cross-platform best practice."},"type":"text"},{"data":{"icon":"Info","title":"Pattern vs. Implementation","content":"The DAO pattern describes an architectural concept, not a specific implementation. You can implement DAO using raw JDBC, JPA, Hibernate, MyBatis, or any other persistence technology. The pattern's value lies in its structural discipline, not any particular toolkit.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":1},{"id":"formal-definition","title":"The Formal Definition","content":[{"data":{"content":"Let us establish a precise, rigorous definition of the Data Access Object pattern:\n\n> **Data Access Object (DAO)** is a structural pattern that provides an abstract interface to some type of database or other persistence mechanism. By mapping application calls to the persistence layer, the DAO provides specific data operations without exposing details of the database.\n\nThis definition contains several crucial elements that warrant detailed examination:"},"type":"text"},{"data":{"items":["**\\\"Abstract interface\\\"** — The DAO presents a clean contract (typically a Java interface, TypeScript interface, or abstract class) that hides implementation complexity. Clients program against this abstraction, not concrete database calls.","**\\\"Some type of database or other persistence mechanism\\\"** — DAO is not limited to relational databases. It applies equally to document stores, file systems, object databases, cloud storage APIs, or even in-memory caches used as persistence layers.","**\\\"Mapping application calls to the persistence layer\\\"** — The DAO translates domain-level operations (like `findActiveUsersByRegion`) into storage-specific operations (like SQL queries, MongoDB aggregations, or S3 list operations).","**\\\"Specific data operations\\\"** — Each DAO typically focuses on a single entity type or a closely related cluster of entities. A `UserDAO` handles users; an `OrderDAO` handles orders.","**\\\"Without exposing details of the database\\\"** — This is the pattern's core value proposition. The business layer receives domain objects, not ResultSets, Cursors, or raw JSON documents."],"title":{"icon":"BookOpen","text":"Definition Decomposition","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**The Abstract Interface Principle:**\n\nThe most critical aspect of DAO is that the interface must be defined in terms the business layer understands. Consider the difference:"},"type":"text"},{"data":{"code":"$78","fileName":"dao-interface-design.ts","language":"typescript"},"type":"code"},{"data":{"icon":"Lightbulb","title":"The Litmus Test","content":"Apply this test to your DAO interfaces: Could someone understand the interface without knowing whether you're using PostgreSQL, MongoDB, or file storage? If yes, your abstraction is clean. If the interface betrays storage specifics, it's a leaky abstraction.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"structural-anatomy","title":"The Structural Anatomy","content":[{"data":{"content":"A complete DAO implementation involves several interconnected components. Understanding each component's role is essential for correct implementation."},"type":"text"},{"data":{"rows":[["DAO Interface","Defines the contract for data operations","Interface or abstract class (e.g., `UserDAO`)"],["Concrete DAO","Implements the interface for specific storage","Class (e.g., `PostgresUserDAO`, `MongoUserDAO`)"],["Data Transfer Object (DTO)","Carries data between layers (optional)","Simple class with fields and accessors"],["Domain Entity","Business objects returned by DAO","Rich domain model classes (e.g., `User`)"],["DAO Factory","Creates appropriate DAO implementations","Factory class or IoC/DI container"],["Data Source","Manages database connections","Connection pool or ORM session factory"]],"caption":"DAO Pattern Components","headers":["Component","Responsibility","Typical Form"]},"type":"table"},{"data":{"content":"**Detailed Component Analysis:**\n\n**1. DAO Interface**\n\nThe interface is the pattern's contract layer. It defines what operations are available without specifying how they're implemented. This enables polymorphism—different implementations can be swapped transparently."},"type":"text"},{"data":{"code":"$79","fileName":"user-dao.interface.ts","language":"typescript"},"type":"code"},{"data":{"content":"**2. Concrete DAO Implementation**\n\nThe concrete class implements the interface using a specific persistence technology. All storage-specific code—SQL queries, connection handling, result mapping—lives here."},"type":"text"},{"data":{"code":"$7a","fileName":"postgres-user-dao.ts","language":"typescript"},"type":"code"},{"data":{"icon":"AlertCircle","title":"Mapping Responsibility","content":"The DAO is responsible for mapping between database representations and domain objects. This mapping code should be co-located with the DAO implementation, not scattered across the business layer. The `mapRowToUser` method above demonstrates this principle.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"core-problems-solved","title":"The Core Problems DAO Solves","content":[{"data":{"content":"The DAO pattern addresses several fundamental architectural challenges. Understanding these motivates proper implementation."},"type":"text"},{"data":{"left":[{"data":{"items":["Business logic polluted with SQL queries","Database change = application rewrite","Testing requires live database","Duplicated connection handling","SQL injection vulnerabilities spread","Schema evolution is traumatic"],"title":{"icon":"XCircle","text":"Without DAO","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["Business logic speaks domain language","Database change = swap DAO implementation","Unit testing with mock DAOs","Centralized connection management","Security practices in one place","Schema changes localized to DAO layer"],"title":{"icon":"CheckCircle","text":"With DAO","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"content":"**Problem 1: Separation of Concerns**\n\nBusiness logic should focus on business rules, not database mechanics. The UserService shouldn't know (or care) whether users are stored in PostgreSQL, MongoDB, or a distributed key-value store.\n\n**Problem 2: Database Independence**\n\nOrganizations change databases more often than you might expect. Cloud migrations, scaling requirements, cost optimization—all might necessitate switching from MySQL to PostgreSQL, or from PostgreSQL to DynamoDB. Without DAO, this is a ground-up rewrite. With DAO, it's implementing a new class.\n\n**Problem 3: Testability**\n\nUnit tests must be fast, reliable, and isolated. Testing business logic that directly calls the database is none of these. DAO interfaces enable mock implementations that return predictable results, enabling true unit testing:\n"},"type":"text"},{"data":{"code":"$7b","fileName":"user-service.test.ts","language":"typescript"},"type":"code"},{"data":{"content":"**Problem 4: Centralized Data Access Logic**\n\nConnection pooling, retry logic, query logging, performance monitoring—these cross-cutting concerns should exist in one place, not be duplicated across every component that needs data. DAO provides that single location.\n\n**Problem 5: Consistent Error Handling**\n\nDatabase operations fail in predictable ways: connection timeouts, constraint violations, deadlocks. DAO implementations can translate these database-specific exceptions into domain-appropriate errors, giving the business layer coherent error semantics."},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Real Metric","content":"Measure your DAO's effectiveness by this: How many files would change if you switched databases? With proper DAO implementation, the answer should be: only the DAO implementation classes. Business logic, services, and controllers should remain completely unchanged.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":4},{"id":"dao-modern-architecture","title":"DAO in Modern Architecture","content":[{"data":{"content":"While DAO emerged from J2EE, its principles remain vital in modern architectures. Let's examine how DAO fits into contemporary patterns:"},"type":"text"},{"data":{"content":"**In Layered Architecture:**\n\nDAO traditionally resides in the data access layer, mediating between the business logic layer above and the database below. Business services depend on DAO interfaces (dependency injection), while DAO implementations depend on database drivers or ORMs.\n\n**In Clean Architecture:**\n\nDAO implementations are part of the outer 'Infrastructure' ring. DAO interfaces are defined in the inner 'Use Cases' or 'Interface Adapters' ring. This arrangement respects the Dependency Rule—dependencies point inward.\n\n**In Hexagonal Architecture:**\n\nDAO interfaces serve as 'ports' (secondary/driven ports for persistence). Concrete DAO implementations are 'adapters' that connect the domain to specific storage technologies.\n\n**In Microservices:**\n\nEach microservice has its own DAO layer, often supporting a polyglot persistence strategy where different services use different databases—all abstracted behind DAO interfaces."},"type":"text"},{"data":{"code":"$7c","fileName":"architecture-placement.ts","language":"typescript"},"type":"code"},{"data":{"icon":"Info","title":"DAO vs Repository Naming","content":"You'll notice both 'DAO' and 'Repository' used in modern codebases. While they have subtle conceptual differences (covered in detail in the next page), in practice many teams use them interchangeably. The core abstraction principle—hiding storage details behind domain-oriented interfaces—is identical.","variant":"note"},"type":"callout"}],"titleType":"number","titleNumber":5},{"id":"design-principles","title":"Design Principles for Effective DAOs","content":[{"data":{"content":"Creating truly effective DAOs requires adhering to several architectural principles that go beyond basic implementation:"},"type":"text"},{"data":{"type":"ordered","items":["**Single Entity Focus** — Each DAO should handle one aggregate or closely related entity cluster. A UserDAO handles users; it shouldn't also handle products. This maintains high cohesion.","**Domain Language in Interfaces** — Method names should reflect business operations (`findActiveSubscribers`, `countPendingOrders`), not database operations (`executeQuery`, `runSQL`).","**Domain Objects In and Out** — Accept domain entities as parameters and return domain entities as results. Never expose database types (ResultSet, Cursor, DataFrame) in the interface.","**Hide Query Complexity** — Complex joins, subqueries, and aggregations should be invisible to callers. The method `getOrderSummaryByCustomer(customerId)` might execute five joins, but the caller doesn't know or care.","**Consistent Error Translation** — Convert database-specific exceptions (SQLException, MongoError) into domain-meaningful exceptions (EntityNotFoundException, DuplicateKeyException).","**Immutable Return Values** — Where possible, return immutable domain objects. This prevents accidental state corruption and clarifies that changes require explicit save operations.","**Explicit Transaction Boundaries** — DAOs typically don't manage transactions themselves. Transaction boundaries are controlled by the service layer, which may coordinate multiple DAO calls."],"title":{"icon":"Shield","text":"DAO Design Principles","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"code":"$7d","fileName":"principle-violations-examples.ts","language":"typescript"},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"summary","title":"Summary: DAO Definition and Purpose","content":[{"data":{"content":"We have established the foundational understanding of the Data Access Object pattern. Let's consolidate the essential concepts:"},"type":"text"},{"data":{"type":"ordered","items":["**DAO is an abstraction pattern** — It separates data access logic from business logic through well-defined interfaces.","**Historical necessity** — The pattern emerged to solve real problems: coupling, duplication, untestability, and maintenance nightmares in enterprise applications.","**Interface-first design** — The DAO interface speaks the domain language; implementations encapsulate storage specifics.","**Structural components** — A complete DAO involves interfaces, concrete implementations, domain entities, and often factories for instantiation.","**Core problems solved** — Separation of concerns, database independence, testability, centralized data access logic, and consistent error handling.","**Modern relevance** — DAO principles apply in layered, clean, hexagonal, and microservice architectures alike.","**Design discipline** — Effective DAOs follow principles: single entity focus, domain language, domain objects in/out, hidden complexity, and explicit transaction awareness."],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's Next:**\n\nWith a solid understanding of what DAO is and why it exists, we're ready to address a common source of confusion: **how does DAO differ from the Repository pattern?** The next page provides a detailed comparison, clarifying when each pattern is appropriate and how they can complement each other in sophisticated architectures."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now have a comprehensive understanding of the Data Access Object pattern's definition, structure, and purpose. This foundational knowledge prepares you for the nuanced comparison with the Repository pattern in the following page.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":7}],"isLocked":false},{"id":"seed_c41e929257e984ac7e17cd8cda0bf363","title":"DAO vs Repository","order":1,"content":null,"isLocked":true},{"id":"seed_c5b85d3a23470292e0bcc3f0d9c49b46","title":"DAO Implementation","order":2,"content":null,"isLocked":true},{"id":"seed_53ec85b3018273b0551aa3274f884aea","title":"When to Use DAO","order":3,"content":null,"isLocked":true}]}}