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')
});

// 1つのBSONドキュメントの内部表現（簡略化）
{
  _id: ObjectId("507f1f77bcf86cd799439011"),    // 12バイトObjectId
  name: "Alice",                                // 文字列（UTF-8）
  age: 28,                                      // Int32
  balance: Decimal128("12345.6789"),            // Decimal128（高精度）
  joinedAt: ISODate("2026-07-01T10:00:00Z"),    // 日付（64ビット整数）
  isActive: true,                               // ブール
  hobbies: ["reading", "coding", "hiking"],     // 配列
  address: {                                    // 埋め込みドキュメント
    city: "Tokyo",
    country: "Japan"
  },
  profile: null,                                // Null
  avatar: BinData(0, "..."),                    // バイナリ
  // フィールド順序：BSONはフィールドの挿入順序を保持（JSONは保証しない）
}

// ドキュメントを挿入
db.users.insertOne({
  name: "Alice",
  age: 28,
  joinedAt: new Date(),
  balance: NumberDecimal("12345.6789"),
  address: { city: "Tokyo", country: "Japan" }
});

// BSON詳細を確認（bsonSize関数を使用）
db.users.findOne({ name: "Alice" });

// フィールド型を確認
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();

// 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)
    )
  }
});

// === 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"

// === 数値の精度の罠 ===
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",       // ケバブケース（引用符が必要）
  "user 1": "Alice",           // スペースを含む（引用符が必要）
  age28: 28                     // 数字で終わる
});

// ❌ 無効なフィールド名
db.users.insertOne({
  $name: "Alice",              // $で始まる ❌
  "user.name": "Alice",        // .を含む ❌
  "": "Alice"                  // 空文字列 ❌
});

// ✅ 推奨スタイル：キャメルケース
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;
  }
});

// === 大きなファイルの保存（>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'));

// === 埋め込み：ユーザー + 複数の住所 ===
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"
    }
  ]
});

// === 検索：東京に住むユーザー ===
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 });