Migrating from MongoDB to Geode

// users collection
{
  _id: ObjectId("..."),
  username: "alice",
  email: "[email protected]",
  profile: {
    firstName: "Alice",
    lastName: "Smith",
    avatar: "https://..."
  },
  addresses: [
    {
      type: "home",
      street: "123 Main St",
      city: "New York",
      zip: "10001",
      isDefault: true
    },
    {
      type: "work",
      street: "456 Office Blvd",
      city: "New York",
      zip: "10002"
    }
  ],
  orders: [ObjectId("..."), ObjectId("...")]
}

// products collection
{
  _id: ObjectId("..."),
  name: "Laptop",
  price: 999.99,
  category: {
    name: "Electronics",
    parent: "Technology"
  },
  reviews: [
    {
      userId: ObjectId("..."),
      rating: 5,
      comment: "Great product!",
      date: ISODate("2024-01-15")
    }
  ],
  tags: ["electronics", "computers", "laptops"]
}

// orders collection
{
  _id: ObjectId("..."),
  userId: ObjectId("..."),
  items: [
    {
      productId: ObjectId("..."),
      quantity: 2,
      price: 999.99
    }
  ],
  total: 1999.98,
  status: "shipped",
  createdAt: ISODate("2024-01-20")
}

// User node - flatten profile, keep simple
(:User {
  id: "user_123",
  username: "alice",
  email: "[email protected]",
  firstName: "Alice",
  lastName: "Smith",
  avatar: "https://..."
})

// Address as separate nodes (allows sharing, independent queries)
(:Address {
  id: "addr_1",
  type: "home",
  street: "123 Main St",
  city: "New York",
  zip: "10001"
})

// Relationships
(:User)-[:HAS_ADDRESS {isDefault: true}]->(:Address)

// Product node
(:Product {
  id: "prod_456",
  name: "Laptop",
  price: 999.99,
  tags: ["electronics", "computers", "laptops"]  // Keep as list property
})

// Category as separate node (shared, hierarchical)
(:Category {name: "Electronics"})
(:Category {name: "Technology"})
(:Category {name: "Electronics"})-[:PARENT]->(:Category {name: "Technology"})
(:Product)-[:IN_CATEGORY]->(:Category {name: "Electronics"})

// Review as relationship (captures connection + metadata)
(:User)-[:REVIEWED {rating: 5, comment: "Great product!", date: "2024-01-15"}]->(:Product)

// Order node
(:Order {
  id: "order_789",
  total: 1999.98,
  status: "shipped",
  createdAt: "2024-01-20"
})

// Order relationships
(:User)-[:PLACED]->(:Order)
(:Order)-[:CONTAINS {quantity: 2, price: 999.99}]->(:Product)

{
  username: "alice",
  profile: {
    firstName: "Alice",
    lastName: "Smith",
    bio: "Software developer"
  }
}

CREATE (:User {
  username: "alice",
  firstName: "Alice",
  lastName: "Smith",
  bio: "Software developer"
})

{
  name: "Order #123",
  shippingAddress: {
    street: "123 Main St",
    city: "New York",
    country: "USA"
  }
}

CREATE (addr:Address {
  street: "123 Main St",
  city: "New York",
  country: "USA"
})
CREATE (order:Order {name: "Order #123"})
CREATE (order)-[:SHIPS_TO]->(addr)

{
  productId: ObjectId("..."),
  reviews: [
    {
      userId: ObjectId("..."),
      rating: 5,
      comment: "Excellent!",
      date: ISODate("...")
    }
  ]
}

// Review becomes a relationship with properties
MATCH (user:User {id: $userId})
MATCH (product:Product {id: $productId})
CREATE (user)-[:REVIEWED {
  rating: 5,
  comment: "Excellent!",
  date: timestamp("2024-01-15")
}]->(product)

{
  type: "purchase",
  buyer: ObjectId("..."),
  seller: ObjectId("..."),
  product: ObjectId("..."),
  price: 100,
  date: ISODate("...")
}

// Create a Transaction node
CREATE (tx:Transaction {
  id: "tx_123",
  price: 100,
  date: timestamp("2024-01-15")
})

MATCH (buyer:User {id: $buyerId})
MATCH (seller:User {id: $sellerId})
MATCH (product:Product {id: $productId})
MATCH (tx:Transaction {id: "tx_123"})
CREATE (buyer)-[:INITIATED]->(tx)
CREATE (tx)-[:BENEFITED]->(seller)
CREATE (tx)-[:INVOLVED]->(product)

// MongoDB collections
db.users
db.products
db.orders

// GQL labels
:User
:Product
:Order

// notifications collection
{ type: "email", to: "alice@...", subject: "..." }
{ type: "sms", to: "+1234567890", message: "..." }
{ type: "push", to: "device_token", payload: {...} }

// Option 1: Multiple labels
(:Notification:Email {to: "alice@...", subject: "..."})
(:Notification:SMS {to: "+1234567890", message: "..."})
(:Notification:Push {to: "device_token", payload: {...}})

// Option 2: Single label with type property
(:Notification {type: "email", to: "alice@...", subject: "..."})

// capped collection for logs
{ timestamp: ISODate("..."), level: "ERROR", message: "..." }

// Create nodes with explicit lifecycle management
CREATE (:LogEntry {
  timestamp: timestamp(),
  level: "ERROR",
  message: "..."
})

// Periodic cleanup
MATCH (l:LogEntry)
WHERE l.timestamp < timestamp() - duration('P30D')
DELETE l

// MongoDB
db.users.findOne({ _id: ObjectId("...") })

// GQL
MATCH (u:User {id: "..."})
RETURN u

// MongoDB
db.users.find({
  age: { $gte: 18 },
  active: true
})

// GQL
MATCH (u:User)
WHERE u.age >= 18 AND u.active = true
RETURN u

// MongoDB
db.users.find(
  { active: true },
  { username: 1, email: 1 }
)

// GQL
MATCH (u:User)
WHERE u.active = true
RETURN u.username, u.email

// MongoDB
db.products.find({ tags: "electronics" })

// GQL
MATCH (p:Product)
WHERE "electronics" IN p.tags
RETURN p

// MongoDB
db.users.find({ orders: { $size: 5 } })

// GQL
MATCH (u:User)
WHERE size(u.orders) = 5
RETURN u

// Or with relationships
MATCH (u:User)-[:PLACED]->(o:Order)
WITH u, count(o) AS orderCount
WHERE orderCount = 5
RETURN u

// MongoDB
db.products.find({ tags: { $all: ["electronics", "sale"] } })

// GQL
MATCH (p:Product)
WHERE "electronics" IN p.tags AND "sale" IN p.tags
RETURN p

// MongoDB
db.users.find({ "profile.city": "New York" })

// GQL (if flattened)
MATCH (u:User)
WHERE u.city = "New York"
RETURN u

// GQL (if kept as relationship)
MATCH (u:User)-[:LIVES_IN]->(c:City {name: "New York"})
RETURN u

// MongoDB
db.orders.aggregate([
  { $match: { _id: ObjectId("...") } },
  { $lookup: {
    from: "users",
    localField: "userId",
    foreignField: "_id",
    as: "user"
  }}
])

// GQL - much simpler!
MATCH (u:User)-[:PLACED]->(o:Order {id: "..."})
RETURN o, u

// MongoDB
db.orders.aggregate([
  { $lookup: { from: "users", ... } },
  { $lookup: { from: "products", ... } },
  { $unwind: "$items" },
  { $lookup: { from: "products", localField: "items.productId", ... } }
])

// GQL
MATCH (u:User)-[:PLACED]->(o:Order)-[item:CONTAINS]->(p:Product)
RETURN u, o, item, p

// MongoDB
db.products.find()
  .sort({ price: -1 })
  .skip(10)
  .limit(5)

// GQL
MATCH (p:Product)
RETURN p
ORDER BY p.price DESC
SKIP 10
LIMIT 5

// MongoDB
db.users.updateOne(
  { _id: ObjectId("...") },
  { $set: { email: "[email protected]" } }
)

// GQL
MATCH (u:User {id: "..."})
SET u.email = "[email protected]"

// MongoDB
db.users.updateOne(
  { _id: ObjectId("...") },
  { $set: { email: "[email protected]", active: true } }
)

// GQL
MATCH (u:User {id: "..."})
SET u.email = "[email protected]", u.active = true

// MongoDB
db.products.updateOne(
  { _id: ObjectId("...") },
  { $inc: { views: 1 } }
)

// GQL
MATCH (p:Product {id: "..."})
SET p.views = COALESCE(p.views, 0) + 1

// MongoDB
db.users.updateOne(
  { _id: ObjectId("...") },
  { $push: { tags: "premium" } }
)

// GQL
MATCH (u:User {id: "..."})
SET u.tags = COALESCE(u.tags, []) + ["premium"]

// MongoDB
db.users.deleteOne({ _id: ObjectId("...") })

// GQL
MATCH (u:User {id: "..."})
DELETE u

// MongoDB (references need manual cleanup)
db.users.deleteOne({ _id: ObjectId("...") })
db.orders.deleteMany({ userId: ObjectId("...") })

// GQL - delete node and all relationships
MATCH (u:User {id: "..."})
DETACH DELETE u

// MongoDB
db.orders.aggregate([
  { $group: {
    _id: "$status",
    count: { $sum: 1 }
  }}
])

// GQL
MATCH (o:Order)
RETURN o.status, count(o) AS count

// MongoDB
db.orders.aggregate([
  { $group: {
    _id: "$userId",
    orderCount: { $sum: 1 },
    totalSpent: { $sum: "$total" },
    avgOrder: { $avg: "$total" },
    lastOrder: { $max: "$createdAt" }
  }}
])

// GQL
MATCH (u:User)-[:PLACED]->(o:Order)
RETURN
  u.id,
  count(o) AS orderCount,
  sum(o.total) AS totalSpent,
  avg(o.total) AS avgOrder,
  max(o.createdAt) AS lastOrder

// MongoDB
db.products.aggregate([
  { $unwind: "$tags" },
  { $group: { _id: "$tags", count: { $sum: 1 } } },
  { $sort: { count: -1 } }
])

// GQL
MATCH (p:Product)
UNWIND p.tags AS tag
RETURN tag, count(p) AS count
ORDER BY count DESC

// MongoDB
db.products.aggregate([
  { $facet: {
    byCategory: [
      { $group: { _id: "$category", count: { $sum: 1 } } }
    ],
    byPrice: [
      { $bucket: {
        groupBy: "$price",
        boundaries: [0, 50, 100, 500, 1000],
        default: "Other"
      }}
    ],
    totalCount: [
      { $count: "count" }
    ]
  }}
])

// GQL - run separate queries
// By category
MATCH (p:Product)-[:IN_CATEGORY]->(c:Category)
RETURN c.name, count(p) AS count

// By price range
MATCH (p:Product)
RETURN
  CASE
    WHEN p.price < 50 THEN "0-50"
    WHEN p.price < 100 THEN "50-100"
    WHEN p.price < 500 THEN "100-500"
    WHEN p.price < 1000 THEN "500-1000"
    ELSE "1000+"
  END AS priceRange,
  count(p)

// Total count
MATCH (p:Product)
RETURN count(p)

// MongoDB $graphLookup
db.employees.aggregate([
  { $match: { name: "CEO" } },
  { $graphLookup: {
    from: "employees",
    startWith: "$_id",
    connectFromField: "_id",
    connectToField: "managerId",
    as: "subordinates",
    maxDepth: 5
  }}
])

// GQL - native and efficient!
MATCH (ceo:Employee {name: "CEO"})<-[:REPORTS_TO*1..5]-(subordinate)
RETURN subordinate

// MongoDB text search
db.products.createIndex({ name: "text", description: "text" })
db.products.find({ $text: { $search: "laptop computer" } })

// GQL with fulltext index
CREATE FULLTEXT INDEX product_search ON :Product(name, description)

// Query
MATCH (p:Product)
WHERE p.name CONTAINS 'laptop' OR p.description CONTAINS 'computer'
RETURN p

// Different nodes with same label, different properties
CREATE (:Product {name: "Laptop", price: 999, specs: {ram: "16GB"}})
CREATE (:Product {name: "Book", isbn: "123-456", author: "Jane Doe"})

// Add new properties anytime
MATCH (p:Product {name: "Laptop"})
SET p.weight = 2.5

// Flexible relationship properties
CREATE (a)-[:PURCHASED {date: timestamp(), coupon: "SAVE10"}]->(b)
CREATE (c)-[:PURCHASED {date: timestamp(), giftWrap: true}]->(d)

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      required: ["email", "username"],
      properties: {
        email: { bsonType: "string" },
        age: { bsonType: "int", minimum: 0 }
      }
    }
  }
})

CREATE CONSTRAINT user_email_exists ON :User(email) ASSERT EXISTS
CREATE CONSTRAINT user_email_unique ON :User(email) ASSERT UNIQUE
CREATE CONSTRAINT user_age_range ON :User(age) ASSERT age >= 0

import asyncio
from motor.motor_asyncio import AsyncIOMotorClient
from geode_client import Client
from bson import ObjectId

class MongoToGeodeETL:
    def __init__(self, mongo_uri, geode_host, geode_port):
        self.mongo = AsyncIOMotorClient(mongo_uri)
        self.geode = Client(host=geode_host, port=geode_port, skip_verify=True)
        self.id_mapping = {}  # ObjectId -> Geode ID

    def convert_id(self, oid):
        """Convert MongoDB ObjectId to string ID."""
        if isinstance(oid, ObjectId):
            return str(oid)
        return oid

    def transform_document(self, doc, flatten_fields=None):
        """Transform MongoDB document to Geode node properties."""
        result = {}
        flatten_fields = flatten_fields or []

        for key, value in doc.items():
            if key == '_id':
                result['id'] = self.convert_id(value)
            elif isinstance(value, ObjectId):
                # Skip ObjectId references - handle as relationships
                continue
            elif isinstance(value, dict):
                if key in flatten_fields:
                    # Flatten embedded document
                    for subkey, subvalue in value.items():
                        result[f"{key}_{subkey}"] = subvalue
                else:
                    # Keep as map property
                    result[key] = value
            elif isinstance(value, list):
                if value and isinstance(value[0], dict):
                    # Skip embedded documents - handle separately
                    continue
                else:
                    # Keep simple arrays as list properties
                    result[key] = value
            else:
                result[key] = value

        return result

    async def migrate_collection(self, db_name, collection_name, label,
                                  flatten_fields=None, batch_size=1000):
        """Migrate a MongoDB collection to Geode nodes."""
        collection = self.mongo[db_name][collection_name]
        total = await collection.count_documents({})
        print(f"Migrating {total} documents from {collection_name} to {label}")

        async with self.geode.connection() as conn:
            await conn.begin()
            count = 0

            async for doc in collection.find():
                props = self.transform_document(doc, flatten_fields)
                self.id_mapping[doc['_id']] = props['id']

                await conn.execute(
                    f"CREATE (n:{label} $props)",
                    {"props": props}
                )
                count += 1

                if count % batch_size == 0:
                    await conn.commit()
                    await conn.begin()
                    print(f"  Migrated {count}/{total} documents...")

            await conn.commit()
            print(f"  Completed: {count} {label} nodes created")

    async def migrate_references(self, db_name, collection_name,
                                  from_label, to_label, ref_field,
                                  rel_type, rel_props=None):
        """Migrate ObjectId references to relationships."""
        collection = self.mongo[db_name][collection_name]
        rel_props = rel_props or []

        async with self.geode.connection() as conn:
            await conn.begin()
            count = 0

            async for doc in collection.find({ref_field: {"$exists": True}}):
                ref_value = doc.get(ref_field)
                if not ref_value:
                    continue

                # Handle single reference
                refs = ref_value if isinstance(ref_value, list) else [ref_value]

                for ref in refs:
                    if isinstance(ref, ObjectId):
                        from_id = self.convert_id(doc['_id'])
                        to_id = self.convert_id(ref)

                        await conn.execute(f"""
                            MATCH (a:{from_label} {{id: $from_id}})
                            MATCH (b:{to_label} {{id: $to_id}})
                            CREATE (a)-[:{rel_type}]->(b)
                        """, {"from_id": from_id, "to_id": to_id})
                        count += 1

                if count % 1000 == 0:
                    await conn.commit()
                    await conn.begin()

            await conn.commit()
            print(f"Created {count} {rel_type} relationships")

    async def migrate_embedded_as_relationships(self, db_name, collection_name,
                                                  from_label, embedded_field,
                                                  to_label, rel_type,
                                                  id_field='id'):
        """Migrate embedded documents to nodes and relationships."""
        collection = self.mongo[db_name][collection_name]

        async with self.geode.connection() as conn:
            await conn.begin()
            node_count = 0
            rel_count = 0

            async for doc in collection.find():
                embedded_docs = doc.get(embedded_field, [])
                if not isinstance(embedded_docs, list):
                    embedded_docs = [embedded_docs]

                from_id = self.convert_id(doc['_id'])

                for i, embedded in enumerate(embedded_docs):
                    if not isinstance(embedded, dict):
                        continue

                    # Generate ID for embedded doc
                    embedded_id = f"{from_id}_{embedded_field}_{i}"
                    props = self.transform_document(embedded)
                    props['id'] = embedded_id

                    # Create node
                    await conn.execute(
                        f"CREATE (n:{to_label} $props)",
                        {"props": props}
                    )
                    node_count += 1

                    # Create relationship
                    await conn.execute(f"""
                        MATCH (a:{from_label} {{id: $from_id}})
                        MATCH (b:{to_label} {{id: $to_id}})
                        CREATE (a)-[:{rel_type}]->(b)
                    """, {"from_id": from_id, "to_id": embedded_id})
                    rel_count += 1

                if node_count % 1000 == 0:
                    await conn.commit()
                    await conn.begin()

            await conn.commit()
            print(f"Created {node_count} {to_label} nodes and {rel_count} relationships")

    async def migrate_embedded_as_relationship_props(self, db_name, collection_name,
                                                       parent_label, embedded_field,
                                                       ref_field, target_label,
                                                       rel_type):
        """Migrate embedded docs with references to relationships with properties."""
        collection = self.mongo[db_name][collection_name]

        async with self.geode.connection() as conn:
            await conn.begin()
            count = 0

            async for doc in collection.find():
                embedded_docs = doc.get(embedded_field, [])
                from_id = self.convert_id(doc['_id'])

                for embedded in embedded_docs:
                    if not isinstance(embedded, dict):
                        continue

                    ref_value = embedded.get(ref_field)
                    if not ref_value:
                        continue

                    to_id = self.convert_id(ref_value)

                    # Extract relationship properties
                    rel_props = {k: v for k, v in embedded.items()
                                if k != ref_field and not isinstance(v, (dict, list, ObjectId))}

                    await conn.execute(f"""
                        MATCH (a:{parent_label} {{id: $from_id}})
                        MATCH (b:{target_label} {{id: $to_id}})
                        CREATE (a)-[:{rel_type} $props]->(b)
                    """, {"from_id": from_id, "to_id": to_id, "props": rel_props})
                    count += 1

                if count % 1000 == 0:
                    await conn.commit()
                    await conn.begin()

            await conn.commit()
            print(f"Created {count} {rel_type} relationships with properties")

    async def run_migration(self, db_name):
        """Run complete migration."""
        print("=" * 60)
        print("MONGODB TO GEODE MIGRATION")
        print("=" * 60)

        # Step 1: Create indexes
        print("\n1. Creating indexes...")
        async with self.geode.connection() as conn:
            await conn.execute("CREATE INDEX user_id ON :User(id)")
            await conn.execute("CREATE INDEX product_id ON :Product(id)")
            await conn.execute("CREATE INDEX order_id ON :Order(id)")
            await conn.execute("CREATE INDEX category_id ON :Category(id)")

        # Step 2: Migrate collections to nodes
        print("\n2. Migrating collections to nodes...")

        await self.migrate_collection(
            db_name, 'users', 'User',
            flatten_fields=['profile']
        )

        await self.migrate_collection(
            db_name, 'products', 'Product'
        )

        await self.migrate_collection(
            db_name, 'orders', 'Order'
        )

        await self.migrate_collection(
            db_name, 'categories', 'Category'
        )

        # Step 3: Migrate references to relationships
        print("\n3. Migrating references to relationships...")

        await self.migrate_references(
            db_name, 'orders',
            'Order', 'User', 'userId',
            'PLACED_BY'
        )

        await self.migrate_references(
            db_name, 'products',
            'Product', 'Category', 'categoryId',
            'IN_CATEGORY'
        )

        await self.migrate_references(
            db_name, 'categories',
            'Category', 'Category', 'parentId',
            'PARENT'
        )

        # Step 4: Migrate embedded documents
        print("\n4. Migrating embedded documents...")

        await self.migrate_embedded_as_relationships(
            db_name, 'users',
            'User', 'addresses',
            'Address', 'HAS_ADDRESS'
        )

        await self.migrate_embedded_as_relationship_props(
            db_name, 'orders',
            'Order', 'items', 'productId',
            'Product', 'CONTAINS'
        )

        await self.migrate_embedded_as_relationship_props(
            db_name, 'products',
            'Product', 'reviews', 'userId',
            'User', 'REVIEWED'
        )

        print("\n" + "=" * 60)
        print("MIGRATION COMPLETE")
        print("=" * 60)

# Run migration
async def main():
    etl = MongoToGeodeETL(
        mongo_uri="mongodb://localhost:27017",
        geode_host="localhost",
        geode_port=3141
    )
    await etl.run_migration("ecommerce")

asyncio.run(main())

const { MongoClient, ObjectId } = require('mongodb');
const { createClient } = require('@geodedb/client');

class MongoToGeodeMigration {
  constructor(mongoUri, geodeUri) {
    this.mongoUri = mongoUri;
    this.geodeUri = geodeUri;
  }

  async connect() {
    this.mongo = new MongoClient(this.mongoUri);
    await this.mongo.connect();

    this.geode = await createClient(this.geodeUri);
  }

  async close() {
    await this.mongo.close();
    await this.geode.close();
  }

  convertId(oid) {
    return oid instanceof ObjectId ? oid.toString() : oid;
  }

  transformDocument(doc, flattenFields = []) {
    const result = {};

    for (const [key, value] of Object.entries(doc)) {
      if (key === '_id') {
        result.id = this.convertId(value);
      } else if (value instanceof ObjectId) {
        // Skip - handle as relationships
        continue;
      } else if (Array.isArray(value)) {
        if (value.length > 0 && typeof value[0] === 'object') {
          // Skip embedded docs - handle separately
          continue;
        }
        result[key] = value;
      } else if (typeof value === 'object' && value !== null) {
        if (flattenFields.includes(key)) {
          for (const [subkey, subvalue] of Object.entries(value)) {
            result[`${key}_${subkey}`] = subvalue;
          }
        } else {
          result[key] = value;
        }
      } else {
        result[key] = value;
      }
    }

    return result;
  }

  async migrateCollection(dbName, collectionName, label, options = {}) {
    const collection = this.mongo.db(dbName).collection(collectionName);
    const cursor = collection.find();
    const total = await collection.countDocuments();

    console.log(`Migrating ${total} documents from ${collectionName} to ${label}`);

    let count = 0;
    const batchSize = options.batchSize || 1000;

    for await (const doc of cursor) {
      const props = this.transformDocument(doc, options.flattenFields || []);

      await this.geode.exec(
        `CREATE (n:${label} $props)`,
        { params: { props } }
      );

      count++;
      if (count % batchSize === 0) {
        console.log(`  Migrated ${count}/${total} documents...`);
      }
    }

    console.log(`  Completed: ${count} ${label} nodes created`);
  }

  async migrateReferences(dbName, collectionName, fromLabel, toLabel, refField, relType) {
    const collection = this.mongo.db(dbName).collection(collectionName);
    const cursor = collection.find({ [refField]: { $exists: true } });

    let count = 0;

    for await (const doc of cursor) {
      const refValue = doc[refField];
      if (!refValue) continue;

      const refs = Array.isArray(refValue) ? refValue : [refValue];

      for (const ref of refs) {
        if (ref instanceof ObjectId) {
          await this.geode.exec(`
            MATCH (a:${fromLabel} {id: $fromId})
            MATCH (b:${toLabel} {id: $toId})
            CREATE (a)-[:${relType}]->(b)
          `, {
            params: {
              fromId: this.convertId(doc._id),
              toId: this.convertId(ref)
            }
          });
          count++;
        }
      }
    }

    console.log(`Created ${count} ${relType} relationships`);
  }

  async run(dbName) {
    await this.connect();

    try {
      console.log('Creating indexes...');
      await this.geode.exec('CREATE INDEX user_id ON :User(id)');
      await this.geode.exec('CREATE INDEX product_id ON :Product(id)');

      console.log('\nMigrating collections...');
      await this.migrateCollection(dbName, 'users', 'User', {
        flattenFields: ['profile']
      });
      await this.migrateCollection(dbName, 'products', 'Product');
      await this.migrateCollection(dbName, 'orders', 'Order');

      console.log('\nMigrating references...');
      await this.migrateReferences(dbName, 'orders', 'Order', 'User', 'userId', 'PLACED_BY');
      await this.migrateReferences(dbName, 'products', 'Product', 'Category', 'categoryId', 'IN_CATEGORY');

      console.log('\nMigration complete!');
    } finally {
      await this.close();
    }
  }
}

// Run
const migration = new MongoToGeodeMigration(
  'mongodb://localhost:27017',
  'quic://localhost:3141'
);
migration.run('ecommerce').catch(console.error);