MongoDB
Cheatsheet

{
  _id: ObjectId('66f1a2b3c4d5e6f708190011'),   // 12 bytes; the first 4 are a timestamp
  customerId: ObjectId('66f1a2b3c4d5e6f708190001'),  // a reference to customers._id
  status: 'paid',
  items: [                                       // an embedded array of sub documents
    { sku: 'SKU-1', qty: 1, price: 1999 },
    { sku: 'SKU-2', qty: 1, price: 1299 }
  ],
  total: 3298,                                   // store money as integer paise or Decimal128
  shipping: { city: 'Delhi', pincode: '110001' },// embedded: read with the order, always
  createdAt: ISODate('2026-07-03T10:30:00.000Z') // a real Date, so ranges and $dateToString work
}

db.createCollection('orders', {
  validator: {
    $jsonSchema: {
      bsonType: 'object',
      required: ['customerId', 'status', 'items', 'total', 'createdAt'],
      properties: {
        customerId: { bsonType: 'objectId' },
        status: { enum: ['pending', 'paid', 'shipped', 'cancelled'] },
        items: {
          bsonType: 'array',
          minItems: 1,
          items: {
            bsonType: 'object',
            required: ['sku', 'qty', 'price'],
            properties: { qty: { bsonType: 'int', minimum: 1 }, price: { bsonType: ['int', 'long', 'decimal'] } }
          }
        },
        total: { bsonType: ['int', 'long', 'decimal'], minimum: 0 },
        createdAt: { bsonType: 'date' }
      }
    }
  },
  validationLevel: 'strict',     // or 'moderate': skip documents that were already invalid
  validationAction: 'error'      // or 'warn': log instead of rejecting
});

// Change the rules on an existing collection
db.runCommand({ collMod: 'orders', validator: { /* ... */ }, validationLevel: 'moderate' });

import { MongoClient, ObjectId, type Collection } from 'mongodb';

interface LineItem { sku: string; qty: number; price: number }
interface Order {
  _id: ObjectId;
  customerId: ObjectId;
  status: 'pending' | 'paid' | 'shipped' | 'cancelled';
  items: LineItem[];
  total: number;
  createdAt: Date;
}

// One client per process; it manages its own connection pool
const client = new MongoClient(process.env.MONGO_URL ?? 'mongodb://localhost:27017/?replicaSet=rs0', {
  maxPoolSize: 20,
  retryWrites: true,
});
await client.connect();
const db = client.db('shop');
const orders: Collection<Order> = db.collection<Order>('orders');

// Indexes are idempotent: run them at startup or in a migration
await orders.createIndex({ customerId: 1, createdAt: -1 });
await orders.createIndex({ status: 1, createdAt: 1 }, { partialFilterExpression: { status: 'pending' } });

// Typed queries: filters, projections and results all checked against Order
const recent = await orders
  .find({ customerId: new ObjectId('66f1a2b3c4d5e6f708190001'), status: { $ne: 'cancelled' } })
  .project<Pick<Order, 'total' | 'createdAt'>>({ _id: 0, total: 1, createdAt: 1 })
  .sort({ createdAt: -1 })
  .limit(5)
  .toArray();

// Cursors stream large results instead of loading them all
for await (const order of orders.find({ status: 'paid' }).batchSize(500)) {
  void order.total;
}

// bulkWrite: many different writes, one round trip
await orders.bulkWrite([
  { updateOne: { filter: { status: 'paid', createdAt: { $lt: new Date('2026-07-15') } }, update: { $set: { status: 'shipped' } } } },
  { deleteMany: { filter: { status: 'cancelled', createdAt: { $lt: new Date('2025-01-01') } } } },
], { ordered: false });

// Typed aggregation output
const revenue = await orders.aggregate<{ _id: string; revenue: number }>([
  { $match: { status: { $in: ['paid', 'shipped'] } } },
  { $group: { _id: '$status', revenue: { $sum: '$total' } } },
]).toArray();

// A multi document transaction (needs a replica set or a sharded cluster)
const session = client.startSession();
try {
  await session.withTransaction(async () => {
    const stock = db.collection<{ _id: string; stock: number }>('products');
    const res = await stock.updateOne({ _id: 'SKU-1', stock: { $gte: 1 } }, { $inc: { stock: -1 } }, { session });
    if (res.modifiedCount === 0) throw new Error('Out of stock');   // aborts the transaction
    await orders.insertOne({
      _id: new ObjectId(), customerId: new ObjectId(), status: 'pending',
      items: [{ sku: 'SKU-1', qty: 1, price: 1999 }], total: 1999, createdAt: new Date(),
    }, { session });
  }, { readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' } });
} finally {
  await session.endSession();
}

// Change streams: react to writes as they happen, and resume after a restart
const stream = orders.watch([{ $match: { operationType: 'insert', 'fullDocument.total': { $gte: 5000 } } }]);
stream.on('change', (event) => {
  if (event.operationType === 'insert') console.log('big order', event.fullDocument._id, event._id);
});

console.log(recent, revenue);
await stream.close();
await client.close();

const stream = orders.watch(
  [{ $match: { operationType: { $in: ['insert', 'update'] }, 'fullDocument.status': 'paid' } }],
  { fullDocument: 'updateLookup', resumeAfter: await loadLastToken() },
);

for await (const event of stream) {
  if (event.operationType === 'insert' || event.operationType === 'update') {
    await sendReceipt(event.fullDocument!);
  }
  await saveLastToken(event._id);     // the resume token
}

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument, Types } from 'mongoose';

@Schema({ _id: false })
export class LineItem {
  @Prop({ required: true }) sku!: string;
  @Prop({ required: true, min: 1 }) qty!: number;
  @Prop({ required: true, min: 0 }) price!: number;
}

@Schema({ collection: 'orders', timestamps: true })   // adds createdAt and updatedAt
export class Order {
  @Prop({ type: Types.ObjectId, ref: 'Customer', required: true, index: true })
  customerId!: Types.ObjectId;

  @Prop({ enum: ['pending', 'paid', 'shipped', 'cancelled'], default: 'pending' })
  status!: string;

  @Prop({ type: [SchemaFactory.createForClass(LineItem)], default: [] })
  items!: LineItem[];

  @Prop({ required: true, min: 0 })
  total!: number;
}

export type OrderDocument = HydratedDocument<Order>;
export const OrderSchema = SchemaFactory.createForClass(Order);
OrderSchema.index({ customerId: 1, createdAt: -1 });

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { ConfigService } from '@nestjs/config';
import { Order, OrderSchema } from './order.schema.js';
import { OrdersService } from './orders.service.js';

@Module({
  imports: [
    MongooseModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (config: ConfigService) => ({ uri: config.getOrThrow<string>('MONGO_URL') }),
    }),
    MongooseModule.forFeature([{ name: Order.name, schema: OrderSchema }]),
  ],
  providers: [OrdersService],
  exports: [OrdersService],
})
export class OrdersModule {}

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, Types } from 'mongoose';
import { Order } from './order.schema.js';

@Injectable()
export class OrdersService {
  constructor(@InjectModel(Order.name) private readonly orders: Model<Order>) {}

  // lean() returns plain objects: faster, no document methods
  recentFor(customerId: string) {
    return this.orders
      .find({ customerId: new Types.ObjectId(customerId) })
      .sort({ createdAt: -1 })
      .limit(5)
      .select({ total: 1, status: 1, createdAt: 1 })
      .lean();
  }

  async markPaid(id: string) {
    const order = await this.orders.findByIdAndUpdate(id, { $set: { status: 'paid' } }, { new: true, runValidators: true });
    if (!order) throw new NotFoundException(`Order ${id} not found`);
    return order;
  }

  revenueByStatus() {
    return this.orders.aggregate<{ _id: string; revenue: number }>([
      { $group: { _id: '$status', revenue: { $sum: '$total' } } },
      { $sort: { revenue: -1 } },
    ]);
  }
}

# Back up one database to a compressed archive, then restore it elsewhere
mongodump --uri="mongodb://localhost:27017/shop" --gzip --archive=shop.archive.gz
mongorestore --uri="mongodb://localhost:27017" --gzip --archive=shop.archive.gz --nsFrom='shop.*' --nsTo='shop_copy.*'

# Export one collection as JSON lines, import it back
mongoexport --uri="mongodb://localhost:27017/shop" --collection=orders --out=orders.jsonl
mongoimport --uri="mongodb://localhost:27017/shop" --collection=orders --file=orders.jsonl

// Log operations slower than 100 ms into system.profile
db.setProfilingLevel(1, { slowms: 100 })
db.system.profile.find().sort({ ts: -1 }).limit(5)

// Operations running longer than 5 seconds, then stop one
db.currentOp({ active: true, secs_running: { $gt: 5 } })
db.killOp(12345)

// Sizes, in MB
db.stats(1024 * 1024)
db.orders.totalIndexSize() / 1024 / 1024

// Replica set health and replication lag
rs.status().members.map(m => ({ name: m.name, state: m.stateStr, lagSecs: m.optimeDate }))
rs.printSecondaryReplicationInfo()