Analyse des exigences et conception du schéma

The Capstone: Designing a Real Application

Step 1: Gather Functional Requirements

// Requirement analysis output (pseudocode spec)
const requirements = {
  reads: [
    'Get product by slug (very high frequency)',
    'List products by category + sort/filter (high frequency)',
    'Search products by keyword (high frequency)',
    'Get order history for a user (medium frequency)',
    'Get order detail (medium frequency)'
  ],
  writes: [
    'Create order (medium frequency)',
    'Update order status (medium frequency)',
    'Add product review (low frequency)',
    'Update product inventory (high frequency)'
  ]
}

Step 2: Identify Access Patterns

// Access pattern register
const accessPatterns = [
  {
    name: 'Product page',
    filter: { slug: 1 },
    projection: 'all except internal fields',
    frequency: 'very high',
    decision: 'index on slug; embed top 5 reviews'
  },
  {
    name: 'Category listing',
    filter: { categoryId: 1, price: 1 },
    sort: { price: 1, createdAt: -1 },
    frequency: 'high',
    decision: 'compound index { categoryId, price, createdAt }'
  }
]

Designing the Products Collection

// Product document schema (simplified)
{
  _id: ObjectId(),
  slug: 'wireless-headphones-pro',
  name: 'Wireless Headphones Pro',
  categoryId: ObjectId(),
  vendor: {
    _id: ObjectId(),         // reference for updates
    name: 'AudioTech Ltd',   // Extended Reference
    logoUrl: '...'           // Extended Reference
  },
  price: 149.99,
  stock: 234,
  avgRating: 4.3,           // Computed Pattern
  reviewCount: 892,          // Computed Pattern
  topReviews: [ /* 5 most recent */ ],  // Subset Pattern
  tags: ['audio', 'wireless', 'headphones'],
  schema_version: 1
}

Designing the Orders Collection

// Order document schema
{
  _id: ObjectId(),
  userId: ObjectId(),
  status: 'processing',  // 'pending', 'processing', 'shipped', 'delivered', 'refunded'
  createdAt: new Date(),
  shippingAddress: {
    name: 'Alice Smith',
    street: '42 Elm St',
    city: 'Istanbul',
    country: 'TR'
  },
  items: [
    {
      productId: ObjectId(),     // reference for linking
      slug: 'wireless-...',
      name: 'Wireless Headphones Pro',  // snapshot
      price: 149.99,             // price at purchase time
      quantity: 1,
      imageUrl: '...'
    }
  ],
  subtotal: 149.99,
  tax: 27.00,
  total: 176.99
}

Applying the Schema Design Decision Framework

// Decision table for our e-commerce schema
const decisions = [
  { entity: 'Order items',       decision: 'embed',     reason: 'always fetched with order; price snapshot required' },
  { entity: 'Shipping address',  decision: 'embed',     reason: 'snapshot at purchase time; changes do not affect order' },
  { entity: 'Product reviews',   decision: 'separate + subset', reason: 'grows unbounded; top-5 subset in product doc' },
  { entity: 'Vendor details',    decision: 'extended ref', reason: 'name/logo read on every product page; changes rarely' },
  { entity: 'Category tree',     decision: 'separate',  reason: 'queried independently; used for breadcrumbs' }
]

Schema Validation for Critical Collections

db.runCommand({
  collMod: 'orders',
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['userId', 'status', 'items', 'total', 'createdAt'],
      properties: {
        status: {
          bsonType: 'string',
          enum: ['pending', 'processing', 'shipped', 'delivered', 'refunded']
        },
        total: { bsonType: 'double', minimum: 0 },
        items: { bsonType: 'array', minItems: 1 }
      }
    }
  },
  validationAction: 'error'
})

Planning the Index Set

// Products collection indexes
db.products.createIndex({ slug: 1 }, { unique: true })  // product page lookup
db.products.createIndex({ categoryId: 1, price: 1, _id: 1 })  // category listing + keyset pagination
db.products.createIndex({ tags: 1 })  // tag filter
db.products.createIndex({ 'vendor._id': 1 })  // vendor store page

// Orders collection indexes
db.orders.createIndex({ userId: 1, createdAt: -1 })  // user order history
db.orders.createIndex({ status: 1, createdAt: 1 })   // fulfillment queue

Handling Concurrent Inventory Updates

// Atomically reserve stock — returns null if out of stock
const product = await db.collection('products').findOneAndUpdate(
  { _id: productId, stock: { $gte: quantity } },  // guard: enough stock
  { $inc: { stock: -quantity } },
  { returnDocument: 'after', projection: { stock: 1, name: 1, price: 1 } }
)

if (!product) {
  throw new Error('Insufficient stock')
}
// Proceed to create order with product snapshot

Aggregation Pipeline for Reporting

// Revenue by vendor, last 30 days
const since = new Date(Date.now() - 30 * 86400000)

db.orders.aggregate([
  { $match: { status: 'delivered', createdAt: { $gte: since } } },
  { $unwind: '$items' },
  {
    $group: {
      _id: '$items.vendorId',
      totalRevenue: { $sum: { $multiply: ['$items.price', '$items.quantity'] } },
      orderCount: { $addToSet: '$_id' }
    }
  },
  { $addFields: { orderCount: { $size: '$orderCount' } } },
  { $sort: { totalRevenue: -1 } },
  { $limit: 20 }
])

Testing the Schema With explain()

// Validate the category listing query
const stats = db.products.find(
  { categoryId: ObjectId('...'), price: { $lte: 200 } }
).sort({ price: 1 }).explain('executionStats')

const plan = stats.executionStats
console.log('Stage:', plan.executionStages.inputStage.stage)  // should be IXSCAN
console.log('Keys examined:', plan.totalKeysExamined)          // should be small
console.log('Docs examined:', plan.totalDocsExamined)          // should equal nReturned
console.log('Docs returned:', plan.nReturned)

Quick Check

Lesson Recap