AI Added Caching to Your Code — And Quietly Polluted Your Business Logic

class UserRepository {
  constructor(
    private db: Database,
    private cache: Cache  // new dependency
  ) {}

  async findById(id: string): Promise<User> {
    const key = `user:${id}`
    const cached = await this.cache.get(key)
    if (cached) return JSON.parse(cached)

    const user = await this.db.query('SELECT * FROM users WHERE id = ?', [id])
    await this.cache.set(key, JSON.stringify(user), 3600)
    return user
  }
}

class UserRepository {
  constructor(private db: Database) {}

  async findById(id: string): Promise<User> {
    return this.db.query('SELECT * FROM users WHERE id = ?', [id])
  }
}

class CachedUserRepository {
  constructor(
    private repo: UserRepository,  // depends on the concrete class, not an interface
    private cache: Cache
  ) {}

  async findById(id: string): Promise<User> {
    const key = `user:${id}`
    const cached = await this.cache.get(key)
    if (cached) return JSON.parse(cached)

    const user = await this.repo.findById(id)
    await this.cache.set(key, JSON.stringify(user), 3600)
    return user
  }
}

// 1. Define the interface — the only contract
interface IUserRepository {
  findById(id: string): Promise<User>
  findAll(): Promise<User[]>
}

// 2. Core implementation only handles data access — no cache knowledge
class UserRepository implements IUserRepository {
  constructor(private db: Database) {}

  async findById(id: string): Promise<User> {
    return this.db.query('SELECT * FROM users WHERE id = ?', [id])
  }

  async findAll(): Promise<User[]> {
    return this.db.query('SELECT * FROM users')
  }
}

// 3. Decorator implements the same interface, wraps any IUserRepository
class CachedUserRepository implements IUserRepository {
  constructor(
    private inner: IUserRepository,  // depends on the interface, not the concrete class
    private cache: Cache
  ) {}

  async findById(id: string): Promise<User> {
    const key = `user:${id}`
    const cached = await this.cache.get(key)
    if (cached) return JSON.parse(cached)

    const user = await this.inner.findById(id)
    await this.cache.set(key, JSON.stringify(user), 3600)
    return user
  }

  async findAll(): Promise<User[]> {
    const key = 'users:all'
    const cached = await this.cache.get(key)
    if (cached) return JSON.parse(cached)

    const users = await this.inner.findAll()
    await this.cache.set(key, JSON.stringify(users), 300)
    return users
  }
}

const userRepository: IUserRepository = new CachedUserRepository(
  new UserRepository(db),
  cache
)

class UserService {
  constructor(private users: IUserRepository) {}  // only knows the interface

  async getUser(id: string): Promise<User> {
    return this.users.findById(id)
  }
}

describe('UserRepository', () => {
  it('should query user by id', async () => {
    const db = createMockDb({ id: '1', name: 'Alice' })
    const repo = new UserRepository(db)
    const user = await repo.findById('1')
    expect(user.name).toBe('Alice')
  })
})

describe('CachedUserRepository', () => {
  it('should return cached result without hitting inner repo', async () => {
    const inner = { findById: vi.fn(), findAll: vi.fn() }
    const cache = createMockCache({ 'user:1': JSON.stringify({ id: '1', name: 'Alice' }) })
    const repo = new CachedUserRepository(inner, cache)

    const user = await repo.findById('1')
    expect(inner.findById).not.toHaveBeenCalled()  // cache hit, inner not called
    expect(user.name).toBe('Alice')
  })

  it('should call inner and populate cache on miss', async () => {
    const inner = { findById: vi.fn().mockResolvedValue({ id: '2', name: 'Bob' }), findAll: vi.fn() }
    const cache = createMockCache({})
    const repo = new CachedUserRepository(inner, cache)

    await repo.findById('2')
    expect(inner.findById).toHaveBeenCalledWith('2')
    expect(await cache.get('user:2')).not.toBeNull()
  })
})

// Logging decorator
class LoggingUserRepository implements IUserRepository {
  constructor(
    private inner: IUserRepository,
    private logger: Logger
  ) {}

  async findById(id: string): Promise<User> {
    this.logger.info(`findById: ${id}`)
    const start = performance.now()
    const user = await this.inner.findById(id)
    this.logger.info(`findById: ${id} took ${performance.now() - start}ms`)
    return user
  }
  // ...
}

// Stack multiple decorators
const repo: IUserRepository = new LoggingUserRepository(
  new CachedUserRepository(
    new UserRepository(db),
    cache
  ),
  logger
)