DataLoader

// Load a document by ID
const user = await this.users.loadById(userId)

// Multiple loadById calls for the same ID will use cached results
const sameUser = await this.users.loadById(userId)

// Load a document by a specific field
const user = await this.users.loadOne({
  key: 'email',  // Field to query by
  value: 'user@example.com',  // Value to match
  match: {isActive: true},  // Optional additional query filter
  sort: {createdAt: -1},  // Optional sorting
  project: {name: 1, email: 1},  // Optional projection
  timeout: 10,  // Optional batch timeout in ms (default: 5)
  debug: false  // Optional debug logging
})

// Load documents by IDs
const users = await this.users.loadMany({
  key: '_id',
  values: [userId1, userId2, userId3]
})

// Load documents by any field
const adminUsers = await this.users.loadMany({
  key: 'role',
  values: ['admin', 'superadmin'],
  match: {isActive: true},
  sort: {lastName: 1}
})

// Load with a single value
const activeUsers = await this.users.loadData({
  key: 'status',
  value: 'active'
})

// Load with multiple values
const users = await this.users.loadData({
  key: 'country',
  values: ['US', 'CA', 'UK'],
  match: {createdAt: {$gt: new Date('2023-01-01')}},
  sort: {createdAt: -1},
  project: {name: 1, email: 1, country: 1},
  timeout: 10,
  debug: true
})

import {Repository} from '@orion-js/services'
import {createCollection, typedId} from '@orion-js/mongodb'
import {schemaWithName, InferSchemaType} from '@orion-js/schema'

const PostSchema = schemaWithName('PostSchema', {
  _id: {type: typedId('post')},
  title: {type: String},
  content: {type: String},
  authorId: {type: String}
})

const UserSchema = schemaWithName('UserSchema', {
  _id: {type: typedId('user')},
  name: {type: String},
  email: {type: String}
})

type PostType = InferSchemaType<typeof PostSchema>
type UserType = InferSchemaType<typeof UserSchema>

@Repository()
class ContentRepository {
  posts = createCollection({
    name: 'posts',
    schema: PostSchema
  })
  
  users = createCollection({
    name: 'users',
    schema: UserSchema
  })
  
  // Without DataLoader (N+1 problem)
  async getPostsWithAuthors(postIds: string[]): Promise<(PostType & {author: UserType})[]> {
    const posts = await this.posts.find({_id: {$in: postIds}}).toArray()
    
    // This causes N separate database queries, one for each post
    for (const post of posts) {
      post.author = await this.users.findOne({_id: post.authorId})
    }
    
    return posts as (PostType & {author: UserType})[]
  }
  
  // With DataLoader (optimized)
  async getPostsWithAuthorsOptimized(postIds: string[]): Promise<(PostType & {author: UserType})[]> {
    const posts = await this.posts.find({_id: {$in: postIds}}).toArray()
    
    // This batches all author lookups into a single query
    const authorIds = posts.map(post => post.authorId)
    const authors = await this.users.loadMany({
      key: '_id',
      values: authorIds
    })
    
    // Map authors to posts
    const authorMap: Record<string, UserType> = {}
    authors.forEach(author => {
      authorMap[author._id] = author
    })
    
    posts.forEach(post => {
      post.author = authorMap[post.authorId]
    })
    
    return posts as (PostType & {author: UserType})[]
  }
}