Mongodb Best Practices

For common Gallery 1882 query patterns, consider these compound indexes:

// In collection config, use the `indexes` property or create via MongoDB directly

// Posts: commonly queried by status + date for listing pages
// db.posts.createIndex({ _status: 1, publishedAt: -1 })

// Happenings: queried by type + date range
// db.happenings.createIndex({ _status: 1, startDate: 1, endDate: 1 })

// Artists: queried by status for directory pages
// db.artists.createIndex({ _status: 1, lastName: 1 })

Index Rules

1. Compound indexes -- Put equality filters first, range filters last, sort fields in between
2. Cover your queries -- If a query only needs fields in the index, MongoDB can serve it entirely from the index (covered query)
3. Limit index count -- Each index adds write overhead. Target 3-5 indexes per collection max
4. Use explain() to verify index usage:

   db.posts.find({ _status: "published" }).sort({ publishedAt: -1 }).explain("executionStats")
   

5. Avoid indexing low-cardinality fields alone (e.g., boolean featured) -- combine with other fields in a compound index

Query Patterns

Efficient Payload Queries

// Use `where` with indexed fields for server-side queries
const posts = await payload.find({
  collection: 'posts',
  where: {
    _status: { equals: 'published' },
  },
  sort: '-publishedAt',
  limit: 10,
  depth: 1, // Control relationship depth to reduce joins
})

Depth Control

• depth: 0 -- Returns IDs only for relationships (fastest)
• depth: 1 -- Populates one level of relationships (default)
• depth: 2+ -- Nested population; avoid in list queries, use for detail pages

// List page: shallow depth
const listings = await payload.find({ collection: 'happenings', depth: 0 })

// Detail page: deeper population
const detail = await payload.findByID({ collection: 'happenings', id, depth: 2 })

Pagination

Always paginate large collections:

const result = await payload.find({
  collection: 'posts',
  page: 1,
  limit: 12,
  where: { _status: { equals: 'published' } },
})
// result.totalDocs, result.totalPages, result.hasNextPage

Projection (Select)

Limit returned fields to reduce data transfer:

const slugsOnly = await payload.find({
  collection: 'posts',
  select: {
    slug: true,
    title: true,
    publishedAt: true,
  },
})

Data Modeling

Embedded vs Referenced

Relationship Patterns

// One-to-many: Use relationship field
{
  name: 'artists',
  type: 'relationship',
  relationTo: 'artists',
  hasMany: true,
}

// Bidirectional: Add relationship on both sides or use hooks to populate
// Avoid circular depth issues by controlling depth parameter

Avoid These Anti-Patterns

Monitoring

Key Metrics to Watch

• Slow query log: Enable profiling for queries >100ms

  db.setProfilingLevel(1, { slowms: 100 })
  db.system.profile.find().sort({ ts: -1 }).limit(5)
  

• Index usage: Check which indexes are actually used

  db.posts.aggregate([{ $indexStats: {} }])
  

• Collection stats: Monitor document count and storage size

  db.posts.stats()
  

MongoDB Atlas (Production)

When using MongoDB Atlas (common with Payload Cloud / Vercel):

• Use M10+ tier for production (M0/M2/M5 have limited indexes and no profiling)
• Enable Atlas Search for full-text search instead of regex queries
• Set up alerts for slow queries and high connections
• Use connection pooling -- Payload handles this via the MongoDB driver, but verify DATABASE_URI includes appropriate options