Classes vs Functions (TypeScript and Dependency Injection)

classes.ts

class FooManager {
    private readonly barRepo: BarRepository
    private readonly userPreferencesRepo: UserPreferencesRepository
    constructor(barRepo: BarRepository, userPreferencesRepo: UserPreferencesRepository) {
        this.barRepo = barRepo
        this.userPreferencesRepo = userPreferencesRepo
    }

    async findMyFavoriteBar(user: User): Promise<Bar> {
        const bars = await this.barRepo.findAll()
        const { favoriteBar } = await this.userPreferencesRepo.getById(user.id)
        return bars.find(({name}) => name === favoriteBar) || bars[Math.floor(Math.random() * bars.length)]
    }
}

type Bar = {
    name: string
}

interface BarRepository {
    findAll(): Promise<Bar[]>
}

type UserPreferences = {
    favoriteBar: string
}

interface UserPreferencesRepository {
    getById(id: string): Promise<UserPreferences>
}

type User = {
    id: string
}

functions.ts

type Bar = {
    name: string
}

type User = {
    id: string
}

type UserPreferences = {
    favoriteBar: string
}

const findMyFavoriteBar = async (user: User, findAllBars: () => Promise<Bar[]>, getUserPreferences: (user: User) => Promise<UserPreferences>) => {
    const bars = await findAllBars()
    const { favoriteBar } = await getUserPreferences(user)
    return bars.find(({name}) => name === favoriteBar) || bars[Math.floor(Math.random() * bars.length)]
}