MongoDB: 文档与BSON：MongoDB的数据基石

// ❌ 错误：JSON.stringify 丢失类型
const order = {
  createdAt: new Date(),         // Date 对象
  total: new Number('0.30'),     // Decimal128 应该用更精确类型
  avatar: Buffer.from('...'),    // 二进制头像
  _id: new ObjectId()            // MongoDB 期望的 ObjectId
};

const json = JSON.stringify(order);
// {"createdAt":"2026-07-01T...","total":0.3,"avatar":"...","_id":"..."}
//         ^^^^^^^^^^^^^^^^ 字符串        ^ 浮点数（精度丢失） ^ 字符串（无法还原）

// ✅ 正确：mongoose 直接操作 BSON 类型
const OrderSchema = new mongoose.Schema({
  createdAt: { type: Date, default: Date.now },           // BSON Date
  total: { type: mongoose.Schema.Types.Decimal128 },        // BSON Decimal128（精确）
  avatar: { type: Buffer },                                 // BSON Binary
  _id: { type: mongoose.Schema.Types.ObjectId, auto: true } // BSON ObjectId
});

const order = await Order.create({
  total: mongoose.Types.Decimal128.fromString('0.30'),
  // TODO: 替换为实际头像文件路径
      avatar: fs.readFileSync('avatar.jpg')
});

// 一个 BSON 文档的内部表示（简化）
{
  _id: ObjectId("507f1f77bcf86cd799439011"),    // 12 字节 ObjectId
  name: "Alice",                                // String（UTF-8）
  age: 28,                                      // Int32
  balance: Decimal128("12345.6789"),            // Decimal128（高精度）
  joinedAt: ISODate("2026-07-01T10:00:00Z"),    // Date（64-bit 整数）
  isActive: true,                               // Boolean
  hobbies: ["reading", "coding", "hiking"],     // Array
  address: {                                    // Embedded Document
    city: "Tokyo",
    country: "Japan"
  },
  profile: null,                                // Null
  avatar: BinData(0, "..."),                    // Binary
  // 字段顺序：BSON 保留字段插入顺序（JSON 不保证）
}

// 插入一个文档
db.users.insertOne({
  name: "Alice",
  age: 28,
  joinedAt: new Date(),
  balance: NumberDecimal("12345.6789"),
  address: { city: "Tokyo", country: "Japan" }
});

// 查看 BSON 详细信息（使用 bsonSon 函数）
db.users.findOne({ name: "Alice" });
// {
//   _id: ObjectId('507f1f77bcf86cd799439011'),
//   name: 'Alice',
//   age: 28,
//   joinedAt: ISODate('2026-07-01T10:00:00.000Z'),
//   balance: NumberDecimal('12345.6789'),
//   address: { city: 'Tokyo', country: 'Japan' }
// }

// 查看字段类型
const doc = db.users.findOne({ name: "Alice" });
print(typeof doc.age);             // number
print(doc.joinedAt instanceof Date); // true

// 执行成功

// 在 mongosh 中创建 ObjectId
const id1 = ObjectId();              // 自动生成
const id2 = ObjectId("507f1f77bcf86cd799439011");  // 从字符串生成

// 提取创建时间（关键优势！）
id2.getTimestamp();
// ISODate("2012-10-17T20:46:11.000Z")

// 在 Node.js 中使用 mongoose
const mongoose = require('mongoose');
const id = new mongoose.Types.ObjectId();
console.log(id.getTimestamp());  // 2026-07-01T10:00:00.000Z

// === 在 mongosh 中 ===
const products = db.products.find().toArray();
products.forEach(p => {
  print(`Product ${p._id} created at ${p._id.getTimestamp()}`);
});

// === 按 ObjectId 时间范围查询 ===
const startOfDay = ObjectId.createFromTime(
  Math.floor(new Date('2026-07-01').getTime() / 1000)
);
const endOfDay = ObjectId.createFromTime(
  Math.floor(new Date('2026-07-02').getTime() / 1000)
);

db.products.find({
  _id: { $gte: startOfDay, $lt: endOfDay }
});

// === Node.js / mongoose ===
const Product = mongoose.model('Product', productSchema);
const products = await Product.find({
  _id: {
    $gte: mongoose.Types.ObjectId.createFromTime(
      Math.floor(Date.parse('2026-07-01') / 1000)
    ),
    $lt: mongoose.Types.ObjectId.createFromTime(
      Math.floor(Date.parse('2026-07-02') / 1000)
    )
  }
});

// mongoose 操作成功执行
// 数据库查询/更新结果

// === Double（默认）===
db.products.insertOne({
  sku: "PHONE-001",
  price: 599.99  // 存储为 Double
});

// === Decimal128（金融推荐）===
db.accounts.insertOne({
  balance: NumberDecimal("1234567890.12345678901234567890")
  // 精确存储，无精度丢失
});

// === Int32（计数）===
db.products.insertOne({
  sku: "BOOK-001",
  stock: NumberInt(150)
});

// === Long（大整数 ID）===
db.orders.insertOne({
  _id: NumberLong("1700000000000")  // 时间戳作为 ID
});

// === JavaScript 中处理 Decimal128 ===
const account = await Account.findOne({});
console.log(account.balance.toString());  // "1234567890.12345678901234567890"

// === Number 精度陷阱 ===
0.1 + 0.2;                          // 0.30000000000000004 ❌
NumberDecimal("0.1") + NumberDecimal("0.2"); // NumberDecimal("0.3") ✅

// 执行成功

// ✅ 合法的字段名
db.users.insertOne({
  firstName: "Alice",          // 驼峰式
  first_name: "Alice",         // 蛇形式
  "first-name": "Alice",       // kebab-case（需引号）
  "user 1": "Alice",           // 含空格（需引号）
  age28: 28                     // 数字结尾
});

// ❌ 非法的字段名
db.users.insertOne({
  $name: "Alice",              // 以 $ 开头 ❌
  "user.name": "Alice",        // 含 . ❌
  "": "Alice"                  // 空字符串 ❌
});

// ✅ 推荐风格：camelCase
db.users.insertOne({
  firstName: "Alice",
  lastName: "Smith",
  emailAddress: "alice@example.com",
  dateOfBirth: new Date("1998-01-01"),
  isActive: true,
  totalSpent: NumberDecimal("1234.56")
});

// mongoose 自动将驼峰转为数据库字段
const UserSchema = new mongoose.Schema({
  firstName: { type: String, required: true },       // 数据库字段：firstName
  emailAddress: { type: String, required: true },   // 数据库字段：emailAddress
  createdAt: { type: Date, default: Date.now },     // 数据库字段：createdAt
  isActive: { type: Boolean, default: true }        // 数据库字段：isActive
});

// 通过 toJSON 转换下划线命名（API 返回时）
UserSchema.set('toJSON', {
  virtuals: true,
  versionKey: false,
  transform: (doc, ret) => {
    ret.first_name = ret.firstName;
    delete ret.firstName;
    return ret;
  }
});

// mongoose 操作成功执行
// 数据库查询/更新结果

// === 存储大文件（>16MB）===
const mongoose = require('mongoose');
const Grid = require('gridfs-stream');
const fs = require('fs');

const conn = mongoose.connection;
let gfs;
conn.once('open', () => {
  gfs = Grid(conn.db, mongoose.mongo);
  gfs.collection('uploads');
});

// 上传文件
const writestream = gfs.createWriteStream({
  filename: 'large-video.mp4',
  content_type: 'video/mp4'
});

fs.createReadStream('./local-video.mp4').pipe(writestream);

writestream.on('close', (file) => {
  console.log(`File stored: ${file._id}`);
});

// 下载文件
const readstream = gfs.createReadStream({
  _id: ObjectId('507f1f77bcf86cd799439011')
});

readstream.pipe(fs.createWriteStream('./downloaded-video.mp4'));

// mongoose 操作成功执行
// 数据库查询/更新结果

// === 嵌入式：用户 + 多地址 ===
db.users.insertOne({
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Alice",
  email: "alice@example.com",
  addresses: [                          // 嵌入数组
    {
      type: "home",
      street: "123 Main St",
      city: "Tokyo",
      country: "Japan",
      zip: "100-0001"
    },
    {
      type: "work",
      street: "456 Office Rd",
      city: "Tokyo",
      country: "Japan",
      zip: "100-0002"
    }
  ]
});

// === 查询：住在 Tokyo 的用户 ===
db.users.find({ "addresses.city": "Tokyo" });

// === 引用式：用户 + 订单（多对一） ===
// users 集合
db.users.insertOne({
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Alice",
  email: "alice@example.com"
});

// orders 集合
db.orders.insertMany([
  {
    _id: ObjectId("507f1f77bcf86cd799439012"),
    user_id: ObjectId("507f1f77bcf86cd799439011"),  // 引用
    items: ["PHONE-001", "CASE-002"],
    total: NumberDecimal("649.98"),
    createdAt: new Date()
  },
  {
    _id: ObjectId("507f1f77bcf86cd799439013"),
    user_id: ObjectId("507f1f77bcf86cd799439011"),  // 引用
    items: ["LAPTOP-001"],
    total: NumberDecimal("1299.99"),
    createdAt: new Date()
  }
]);

// === 使用 $lookup 关联查询（类似 SQL JOIN） ===
db.users.aggregate([
  { $match: { name: "Alice" } },
  { $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "user_id",
      as: "orders"
  }}
]);

// 执行成功

// === 综合用户文档 ===
db.users.insertOne({
  _id: ObjectId("507f1f77bcf86cd799439011"),

  // === 基本信息 ===
  email: "alice@example.com",
  username: "alice_chen",
  displayName: "Alice Chen",
  phone: "+81-90-1234-5678",

  // === 认证 ===
  passwordHash: "$2b$10$...",      // bcrypt 哈希（不入明文）
  emailVerified: true,
  twoFactorEnabled: false,

  // === 偏好（嵌套文档）===
  preferences: {
    language: "ja",
    currency: "JPY",
    timezone: "Asia/Tokyo",
    notifications: {
      email: true,
      sms: false,
      push: true,
      marketing: false
    }
  },

  // === 收货地址（嵌入式数组）===
  addresses: [
    {
      addressId: ObjectId("..."),
      type: "home",
      isDefault: true,
      street: "1-2-3 Shibuya",
      city: "Tokyo",
      prefecture: "Tokyo",
      zip: "150-0002",
      country: "Japan",
      phone: "+81-90-1234-5678"
    }
  ],

  // === 统计（高频更新字段建议拆分）===
  stats: {
    totalOrders: 25,
    totalSpent: NumberDecimal("125430.50"),
    averageRating: 4.7,
    lastOrderAt: ISODate("2026-06-15T10:30:00Z")
  },

  // === 关注列表（引用式）===
  followingIds: [
    ObjectId("507f1f77bcf86cd799439012"),
    ObjectId("507f1f77bcf86cd799439013")
  ],

  // === 头像引用（GridFS）===
  avatarFileId: ObjectId("507f1f77bcf86cd799439099"),

  // === 元数据 ===
  createdAt: ISODate("2025-03-01T10:00:00Z"),
  updatedAt: ISODate("2026-07-01T15:23:00Z"),
  lastLoginAt: ISODate("2026-07-01T10:00:00Z"),
  isActive: true,
  role: "customer"  // customer | admin | moderator
});

const UserSchema = new mongoose.Schema({
  email: { type: String, required: true, unique: true, lowercase: true },
  username: { type: String, required: true, unique: true, index: true },
  displayName: { type: String, required: true },
  phone: { type: String },

  passwordHash: { type: String, required: true, select: false },
  emailVerified: { type: Boolean, default: false },
  twoFactorEnabled: { type: Boolean, default: false },

  preferences: {
    language: { type: String, default: 'en' },
    currency: { type: String, default: 'USD' },
    timezone: { type: String, default: 'UTC' },
    notifications: {
      email: { type: Boolean, default: true },
      sms: { type: Boolean, default: false },
      push: { type: Boolean, default: true },
      marketing: { type: Boolean, default: false }
    }
  },

  addresses: [{
    addressId: { type: mongoose.Schema.Types.ObjectId, default: () => new mongoose.Types.ObjectId() },
    type: { type: String, enum: ['home', 'work', 'other'], default: 'home' },
    isDefault: { type: Boolean, default: false },
    street: { type: String, required: true },
    city: { type: String, required: true },
    prefecture: String,
    zip: { type: String, required: true },
    country: { type: String, required: true },
    phone: String
  }],

  stats: {
    totalOrders: { type: Number, default: 0 },
    totalSpent: { type: mongoose.Schema.Types.Decimal128, default: 0 },
    averageRating: { type: Number, default: 0 },
    lastOrderAt: Date
  },

  followingIds: [{ type: mongoose.Schema.Types.ObjectId, ref: 'User' }],
  avatarFileId: { type: mongoose.Schema.Types.ObjectId },

  role: { type: String, enum: ['customer', 'admin', 'moderator'], default: 'customer', index: true },
  isActive: { type: Boolean, default: true, index: true }
}, { timestamps: true });