// ❌ Broken pattern: always embedding — leads to unbounded document growth
// A blog post that embeds all comments directly
{
  "_id": "post_abc",
  "title": "Understanding MVCC",
  "comments": [          // unbounded array — grows without limit
    { "author": "alice", "text": "Great post!" },
    { "author": "bob", "text": "Very helpful!" },
    // ... 50,000 comments later — document hits 16MB limit and all writes fail
  ]
}

// ✅ Correct: reference for high-cardinality, frequently-updated child entities
// Post document — stays small, never bloats
{ "_id": "post_abc", "title": "Understanding MVCC", "commentCount": 50000 }

// Comment document — separate collection, independently queryable
{ "_id": "comment_xyz", "postId": "post_abc", "author": "alice", "text": "Great post!" }

// ❌ Broken: no schema version — reading old documents requires defensive checks in every query
const user = await db.users.findOne({ _id: userId })
// Is user.address a string? An object? An array? It changed 3 times over 2 years.
const city = user.address?.city ?? user.city ?? user.location?.city ?? 'Unknown'

// ✅ Correct: explicit _schemaVersion field — readers branch on version, migrations are explicit
// v1 document (2024)
{ "_id": "user_1", "_schemaVersion": 1, "address": "123 Main St, NYC" }

// v2 document (2025 — structured address)
{ "_id": "user_2", "_schemaVersion": 2, "address": { "street": "123 Main St", "city": "NYC" } }

// v3 document (2026 — multi-address support)
{ "_id": "user_3", "_schemaVersion": 3, "addresses": [{ "type": "home", "city": "NYC" }] }

// Migration script: run as background job, not a blocking migration
await db.users.updateMany(
  { _schemaVersion: { $lt: 3 } },
  [{ $set: { /* transform to v3 shape */ } }]
)

// Table: AppTable
// Access patterns to support:
//   1. Get user by ID
//   2. Get all orders for a user
//   3. Get order by order ID
//   4. Get all order items for an order

// Item shapes in a single table:
type UserItem = {
  PK: `USER#${string}`      // PK: USER#userId
  SK: `USER#${string}`      // SK: USER#userId (same — point lookup)
  entityType: 'USER'
  email: string
  name: string
}

type OrderItem = {
  PK: `USER#${string}`      // PK: USER#userId — enables "get all orders for user"
  SK: `ORDER#${string}`     // SK: ORDER#orderId — enables "get order by ID"
  entityType: 'ORDER'
  total: number
  status: 'pending' | 'shipped' | 'delivered'
}

type OrderLineItem = {
  PK: `ORDER#${string}`     // PK: ORDER#orderId — enables "get all items for order"
  SK: `ITEM#${string}`      // SK: ITEM#productId
  entityType: 'ORDER_ITEM'
  quantity: number
  unitPrice: number
}

// ❌ Anti-pattern: audit log embedded in a document — hits 16MB silently in production
{
  "_id": "user_42",
  "name": "Alice",
  "auditLog": [    // grows indefinitely — each login, each update appends here
    { "action": "login", "timestamp": "2026-01-01T00:00:00Z" },
    { "action": "update_email", "timestamp": "2026-01-02T00:00:00Z" },
    // ... 8,000 events later — write fails with BSONObjectTooLarge
  ]
}

// ✅ Correct: separate audit_events collection — unbounded data never embedded
db.audit_events.insertOne({
  userId: "user_42",
  action: "login",
  timestamp: new Date(),
  metadata: { ip: "1.2.3.4", userAgent: "..." }
})

// Find top 5 product categories by total revenue in the last 30 days
db.orders.aggregate([
  // Stage 1: filter to recent orders
  { $match: {
    status: 'delivered',
    createdAt: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) }
  }},

  // Stage 2: unwind the items array into individual documents
  { $unwind: '$items' },

  // Stage 3: join to products collection to get the category
  { $lookup: {
    from: 'products',
    localField: 'items.productId',
    foreignField: '_id',
    as: 'product'
  }},
  { $unwind: '$product' },

  // Stage 4: group by category, sum revenue
  { $group: {
    _id: '$product.category',
    totalRevenue: { $sum: { $multiply: ['$items.quantity', '$items.unitPrice'] } },
    orderCount: { $sum: 1 }
  }},

  // Stage 5: sort and limit
  { $sort: { totalRevenue: -1 } },
  { $limit: 5 }
])

// DynamoDB Stream record — triggered on every INSERT, MODIFY, or REMOVE
type DynamoDBStreamRecord = {
  eventName: 'INSERT' | 'MODIFY' | 'REMOVE'
  dynamodb: {
    Keys: { PK: { S: string }; SK: { S: string } }
    NewImage?: Record<string, AttributeValue>
    OldImage?: Record<string, AttributeValue>
  }
}

// Lambda function that processes order status changes
export const handler = async (event: DynamoDBStreamEvent) => {
  for (const record of event.Records) {
    if (record.eventName !== 'MODIFY') continue

    const newStatus = record.dynamodb.NewImage?.status?.S
    const oldStatus = record.dynamodb.OldImage?.status?.S

    if (oldStatus !== 'pending' || newStatus !== 'shipped') continue

    // Trigger fulfillment notification without a separate event bus
    await ses.sendEmail({ /* ... */ })
    await sqs.sendMessage({ /* ... fulfillment queue */ })
  }
}

// Create a vector search index via Atlas Search UI or API
{
  "name": "article_embeddings_index",
  "type": "vectorSearch",
  "definition": {
    "fields": [{ "type": "vector", "path": "embedding", "numDimensions": 1536, "similarity": "cosine" }]
  }
}

// Query: semantic similarity search combined with a metadata filter
db.articles.aggregate([
  { $vectorSearch: {
    index: "article_embeddings_index",
    path: "embedding",
    queryVector: [/* 1536-dimension query vector */],
    numCandidates: 150,
    limit: 5,
    filter: { category: "backend", publishedAt: { $gte: new Date("2025-01-01") } }
  }},
  { $project: { title: 1, summary: 1, score: { $meta: "vectorSearchScore" } }}
])

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:UpdateItem"],
    "Resource": "arn:aws:dynamodb:us-east-1:123456789:table/AppTable",
    "Condition": {
      "ForAllValues:StringEquals": {
        "dynamodb:LeadingKeys": ["${cognito-identity.amazonaws.com:sub}"]
      }
    }
  }]
}

// Client-side field-level encryption — PII never reaches MongoDB in plaintext
const encryptedClient = new MongoClient(uri, {
  autoEncryption: {
    keyVaultNamespace: 'encryption.__keyVault',
    kmsProviders: { aws: { accessKeyId: '...', secretAccessKey: '...' } },
    schemaMap: {
      'mydb.users': {
        properties: {
          ssn: { encrypt: { bsonType: 'string', algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512_Deterministic' }},
          creditCard: { encrypt: { bsonType: 'string', algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512_Random' }}
        }
      }
    }
  }
})