@aneuhold/be-ts-db-lib 3.0.0 → 3.0.2

package/lib/services/MigrationService.ts

@@ -1,9 +1,20 @@
 /* eslint-disable */
 // @ts-nocheck
+import {
+  ApiKey,
+  DashboardTask,
+  DashboardUserConfig,
+  DocumentService,
+  NonogramKatanaItem,
+  NonogramKatanaUpgrade,
+  User
+} from '@aneuhold/core-ts-db-lib';
 import { DR } from '@aneuhold/core-ts-lib';
-import { ObjectId } from 'bson';
 import { v7 as uuidv7 } from 'uuid';
+import ApiKeyRepository from '../repositories/common/ApiKeyRepository.js';
 import UserRepository from '../repositories/common/UserRepository.js';
+import DashboardNonogramKatanaItemRepository from '../repositories/dashboard/DashboardNonogramKatanaItemRepository.js';
+import DashboardNonogramKatanaUpgradeRepository from '../repositories/dashboard/DashboardNonogramKatanaUpgradeRepository.js';
 import DashboardTaskRepository from '../repositories/dashboard/DashboardTaskRepository.js';
 import DashboardUserConfigRepository from '../repositories/dashboard/DashboardUserConfigRepository.js';
 
@@ -25,185 +36,418 @@ export default class MigrationService {
    * @param dryRun Whether or not to actually make the changes or just log them.
    */
   static async migrateDb(dryRun = false): Promise<void> {
-    return;
-    DR.logger.info('Starting migration from ObjectId to UUID v7...');
+    DR.logger.info('Starting migration...');
 
     // 1. Load all documents
     const userRepo = UserRepository.getRepo();
+    const apiKeyRepo = ApiKeyRepository.getRepo();
     const taskRepo = DashboardTaskRepository.getRepo();
     const configRepo = DashboardUserConfigRepository.getRepo();
+    const nonogramItemRepo = DashboardNonogramKatanaItemRepository.getRepo();
+    const nonogramUpgradesRepo = DashboardNonogramKatanaUpgradeRepository.getRepo();
 
     const users = await userRepo.getAll();
+    const apiKeys = await apiKeyRepo.getAll();
     const tasks = await taskRepo.getAll();
     const configs = await configRepo.getAll();
+    const nonogramItems = await nonogramItemRepo.getAll();
+    const nonogramUpgrades = await nonogramUpgradesRepo.getAll();
 
-    DR.logger.info(`Loaded ${users.length} users, ${tasks.length} tasks, ${configs.length} configs.`);
-
-    // 2. Create ID Map (Old ObjectId string -> New UUID)
-    const idMap = new Map<string, string>();
-    let newIdCount = 0;
+    DR.logger.info(
+      `Loaded ${users.length} users, ${apiKeys.length} API keys, ${tasks.length} tasks, ${configs.length} configs, ${nonogramItems.length} nonogram items, and ${nonogramUpgrades.length} nonogram upgrades.`
+    );
 
-    const addToMap = (docs: any[]) => {
+    const countObjectIds = (docs: any[]) => {
       docs.forEach((doc) => {
-        if (doc._id instanceof ObjectId) {
-          idMap.set(doc._id.toHexString(), uuidv7());
-          newIdCount++;
-        } else if (typeof doc._id === 'string' && !idMap.has(doc._id)) {
-           // Already a string? Maybe already migrated or just a string ID.
-           // If it looks like an ObjectId, map it.
-           if (ObjectId.isValid(doc._id) && doc._id.length === 24) {
-             idMap.set(doc._id, uuidv7());
-             newIdCount++;
-           }
-        }
+        // Get the type of the _id field
+        console.log(`Document ID type: ${typeof doc._id}, value: ${doc._id}`);
       });
     };
 
-    addToMap(users);
-    addToMap(tasks);
-    addToMap(configs);
-
-    DR.logger.info(`Generated ${newIdCount} new UUIDs.`);
+    // Create a map of document IDs to new UUIDs
+    const allDocs = [
+      ...users,
+      ...apiKeys,
+      ...tasks,
+      ...configs,
+      ...nonogramItems,
+      ...nonogramUpgrades
+    ];
+    const legacyDocs = allDocs.filter((doc) => typeof doc._id === 'object');
+    const newDocs = allDocs.filter((doc) => typeof doc._id === 'string');
+
+    DR.logger.info(
+      `Found ${legacyDocs.length} documents with legacy ObjectId IDs and ${newDocs.length} documents with string IDs.`
+    );
+
+    // Delete all existing new docs (with string IDs) to ensure fresh creation
+    if (!dryRun && newDocs.length > 0) {
+      DR.logger.info(`Deleting ${newDocs.length} existing migrated documents...`);
+      const newDocIds = newDocs.map((doc) => doc._id);
+      
+      const userIdsToDelete = users.filter((u) => typeof u._id === 'string').map((u) => u._id);
+      const apiKeyIdsToDelete = apiKeys.filter((k) => typeof k._id === 'string').map((k) => k._id);
+      const taskIdsToDelete = tasks.filter((t) => typeof t._id === 'string').map((t) => t._id);
+      const configIdsToDelete = configs.filter((c) => typeof c._id === 'string').map((c) => c._id);
+      const nonogramItemIdsToDelete = nonogramItems.filter((i) => typeof i._id === 'string').map((i) => i._id);
+      const nonogramUpgradeIdsToDelete = nonogramUpgrades.filter((u) => typeof u._id === 'string').map((u) => u._id);
+
+      if (userIdsToDelete.length > 0) {
+        const result = await (await userRepo.getCollection()).deleteMany({ _id: { $in: userIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} users.`);
+      }
+      if (apiKeyIdsToDelete.length > 0) {
+        const result = await (await apiKeyRepo.getCollection()).deleteMany({ _id: { $in: apiKeyIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} API keys.`);
+      }
+      if (taskIdsToDelete.length > 0) {
+        const result = await (await taskRepo.getCollection()).deleteMany({ _id: { $in: taskIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} tasks.`);
+      }
+      if (configIdsToDelete.length > 0) {
+        const result = await (await configRepo.getCollection()).deleteMany({ _id: { $in: configIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} configs.`);
+      }
+      if (nonogramItemIdsToDelete.length > 0) {
+        const result = await (await nonogramItemRepo.getCollection()).deleteMany({ _id: { $in: nonogramItemIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} nonogram items.`);
+      }
+      if (nonogramUpgradeIdsToDelete.length > 0) {
+        const result = await (await nonogramUpgradesRepo.getCollection()).deleteMany({ _id: { $in: nonogramUpgradeIdsToDelete } });
+        DR.logger.info(`Deleted ${result.deletedCount} nonogram upgrades.`);
+      }
+      
+      DR.logger.info('Deletion complete. Starting fresh migration...');
+    } else if (dryRun && newDocs.length > 0) {
+      DR.logger.info(`Dry run: Would delete ${newDocs.length} existing migrated documents.`);
+    }
 
-    // 3. Helper to get new ID
-    const getNewId = (oldId: any): string | undefined => {
-      if (!oldId) return undefined;
+    // Now create the actual map
+    const mapFromObjectIdToUUID = new Map<string, UUID>();
+
+    const newUsersToCreate: User[] = [];
+    const newApiKeysToCreate: ApiKey[] = [];
+    const newTasksToCreate: DashboardTask[] = [];
+    const newConfigsToCreate: DashboardUserConfig[] = [];
+    const newNonogramItemsToCreate: NonogramKatanaItem[] = [];
+    const newNonogramUpgradesToCreate: NonogramKatanaUpgrade[] = [];
+
+    /**
+     * Gets a UUID for a given legacy ObjectId. If one already exists in the map,
+     * it is returned. Otherwise, a new one is generated and added to the map.
+     */
+    const getUUID = (oldId: ObjectId): UUID => {
       const oldIdStr = oldId.toString();
-      return idMap.get(oldIdStr) || (typeof oldId === 'string' ? oldId : undefined);
+      if (mapFromObjectIdToUUID.has(oldIdStr)) {
+        return mapFromObjectIdToUUID.get(oldIdStr);
+      }
+      const newId = uuidv7();
+      mapFromObjectIdToUUID.set(oldIdStr, newId);
+      return newId;
     };
 
-    // 4. Prepare New Documents
-    const newUsers: any[] = [];
-    const oldUserIds: ObjectId[] = [];
-
-    const newTasks: any[] = [];
-    const oldTaskIds: ObjectId[] = [];
-
-    const newConfigs: any[] = [];
-    const oldConfigIds: ObjectId[] = [];
-
-    // --- Process Users ---
-    for (const user of users) {
-      if (user._id instanceof ObjectId) {
-        const newId = getNewId(user._id);
-        if (!newId) continue;
-
-        const newUser = { ...user, _id: newId };
-        // Users don't have many internal refs usually, but check if needed
-        newUsers.push(newUser);
-        oldUserIds.push(user._id);
+    // Create a map of UUID to documents
+    const mapFromUUIDToDocument = new Map<UUID, any>();
+
+    const verifyDoc = (oldDoc: any, newDoc: any) => {
+      const oldJson = JSON.stringify(oldDoc, null, 2);
+      const newJson = JSON.stringify(newDoc, null, 2);
+      const oldLines = oldJson.split('\n').length;
+      const newLines = newJson.split('\n').length;
+      if (newLines !== oldLines + 1) {
+        DR.logger.warn(
+          `Line count mismatch for ${oldDoc.docType || 'doc'} ${oldDoc._id}: Old=${oldLines}, New=${newLines}.`
+        );
+      }
+    };
+    
+    function createNewDoc(oldDoc) {
+      if (mapFromObjectIdToUUID.has(oldDoc._id.toString()) && mapFromUUIDToDocument.has(mapFromObjectIdToUUID.get(oldDoc._id.toString()))) {
+        console.warn(
+          `Skipping document ${oldDoc._id} as it was already migrated.` +
+          ` The created document is ${JSON.stringify(mapFromUUIDToDocument.get(mapFromObjectIdToUUID.get(oldDoc._id.toString())))}`
+        );
+        return;
       }
+      const newDocId = getUUID(oldDoc._id);
+      const newDoc = DocumentService.deepCopy(oldDoc);
+      newDoc._id = newDocId;
+      newDoc.oldOId = oldDoc._id.toString();
+      mapFromUUIDToDocument.set(newDocId, newDoc);
+      return newDoc;
     }
 
-    // --- Process Tasks ---
-    for (const task of tasks) {
-      if (task._id instanceof ObjectId) {
-        const newId = getNewId(task._id);
-        if (!newId) continue;
+    // Filter to only legacy users with the chosen usernames
+    const userNames = ['demoUser1', 'demoUser2', "testUser", "testUser2"];
+    // const userNames = ["testUser"];
+    const legacyUsers = users.filter((u) => userNames.includes(u.userName) && typeof u._id === 'object');
+    DR.logger.info(`Found ${legacyUsers.length} legacy users to migrate.`);
+    
+    // First, create all user documents and generate their UUIDs that way relationships between
+    // users in the collaborators field can be mapped correctly.
+    legacyUsers.forEach((oldUserDoc) => {
+      const newUser = createNewDoc(oldUserDoc);
+      if (!newUser) return;
+      verifyDoc(oldUserDoc, newUser);
+      newUsersToCreate.push(newUser);
+    });
+
+    // Create the function that will flesh out new documents for a given user document
+    function createNewDocsForUser(oldUserDoc: User) {
+      const oldUserIdStr = oldUserDoc._id.toString();
+      const newUserId = getUUID(oldUserDoc._id);
+
+      // 1. Create new API keys
+      const userApiKeys = apiKeys.filter((k) => k.userId.toString() === oldUserIdStr);
+      userApiKeys.forEach((oldKey) => {
+        const newKey = createNewDoc(oldKey);
+        if (!newKey) return;
+        newKey.userId = newUserId;
+        verifyDoc(oldKey, newKey);
+        newApiKeysToCreate.push(newKey);
+      });
 
-        const newTask = { ...task, _id: newId };
+      // 2. Create new Tasks
+      const userTasks = tasks.filter(
+        (t) => t.userId.toString() === oldUserIdStr
+      );
 
-        // Fix userId
-        if (newTask.userId) newTask.userId = getNewId(newTask.userId) || newTask.userId;
+      const taskChildrenMap = new Map<string, DashboardTask[]>();
+      const rootTasks: DashboardTask[] = [];
+      const userTaskIds = new Set(userTasks.map((t) => t._id.toString()));
 
-        // Fix assignedTo
-        if (newTask.assignedTo) newTask.assignedTo = getNewId(newTask.assignedTo) || newTask.assignedTo;
+      userTasks.forEach((task) => {
+        const pId = task.parentTaskId?.toString();
+        if (pId && userTaskIds.has(pId)) {
+          if (!taskChildrenMap.has(pId)) {
+            taskChildrenMap.set(pId, []);
+          }
+          taskChildrenMap.get(pId).push(task);
+        } else {
+          rootTasks.push(task);
+        }
+      });
 
-        // Fix parentTaskId
-        if (newTask.parentTaskId) newTask.parentTaskId = getNewId(newTask.parentTaskId) || newTask.parentTaskId;
+      const queue = [...rootTasks];
+      while (queue.length > 0) {
+        const oldTask = queue.shift()!;
+        const newTask = createNewDoc(oldTask);
 
-        // Fix sharedWith array
-        if (Array.isArray(newTask.sharedWith)) {
-          newTask.sharedWith = newTask.sharedWith.map((id: any) => getNewId(id) || id);
-        }
+        if (newTask) {
+          newTask.userId = newUserId;
 
-        // Fix tags keys (userIds are keys)
-        if (newTask.tags) {
+          // Map user IDs in tags keys
           const newTags: any = {};
-          for (const [key, val] of Object.entries(newTask.tags)) {
-            const newKey = getNewId(key) || key;
-            newTags[newKey] = val;
-          }
+          Object.keys(oldTask.tags).forEach((tagUserId) => {
+            const newTagUserId = getUUID(tagUserId);
+            newTags[newTagUserId] = oldTask.tags[tagUserId];
+          });
           newTask.tags = newTags;
-        }
-        
-        // Fix filterSettings keys (userIds are keys)
-        if (newTask.filterSettings) {
-          const newSettings: any = {};
-          for (const [key, val] of Object.entries(newTask.filterSettings)) {
-            const newKey = getNewId(key) || key;
-            newSettings[newKey] = val;
-          }
-          newTask.filterSettings = newSettings;
-        }
 
-        // Fix sortSettings keys (userIds are keys)
-        if (newTask.sortSettings) {
-          const newSettings: any = {};
-          for (const [key, val] of Object.entries(newTask.sortSettings)) {
-            const newKey = getNewId(key) || key;
-            newSettings[newKey] = val;
+          // Map user IDs in filterSettings keys
+          const newFilterSettings: any = {};
+          Object.keys(oldTask.filterSettings).forEach((fsUserId) => {
+            const newFsUserId = getUUID(fsUserId);
+            newFilterSettings[newFsUserId] = {
+              ...oldTask.filterSettings[fsUserId],
+              userId: newFsUserId
+            };
+          });
+          newTask.filterSettings = newFilterSettings;
+
+          // Map user IDs in sortSettings keys
+          const newSortSettings: any = {};
+          Object.keys(oldTask.sortSettings).forEach((ssUserId) => {
+            const newSsUserId = getUUID(ssUserId);
+            newSortSettings[newSsUserId] = {
+              ...oldTask.sortSettings[ssUserId],
+              userId: newSsUserId
+            };
+          });
+          newTask.sortSettings = newSortSettings;
+
+          newTask.sharedWith = oldTask.sharedWith.map((id: any) => getUUID(id));
+          if (oldTask.assignedTo) {
+            newTask.assignedTo = getUUID(oldTask.assignedTo);
+          }
+          if (oldTask.parentTaskId) {
+            newTask.parentTaskId = getUUID(oldTask.parentTaskId);
           }
-          newTask.sortSettings = newSettings;
+          if (oldTask.parentRecurringTaskInfo) {
+            newTask.parentRecurringTaskInfo = {
+              ...oldTask.parentRecurringTaskInfo,
+              taskId: getUUID(oldTask.parentRecurringTaskInfo.taskId)
+            };
+          }
+
+          verifyDoc(oldTask, newTask);
+          newTasksToCreate.push(newTask);
         }
 
-        newTasks.push(newTask);
-        oldTaskIds.push(task._id);
+        const children = taskChildrenMap.get(oldTask._id.toString());
+        if (children) {
+          queue.push(...children);
+        }
       }
-    }
-
-    // --- Process UserConfigs ---
-    for (const config of configs) {
-      if (config._id instanceof ObjectId) {
-        const newId = getNewId(config._id);
-        if (!newId) continue;
-
-        const newConfig = { ...config, _id: newId };
-
-        // Fix userId
-        if (newConfig.userId) newConfig.userId = getNewId(newConfig.userId) || newConfig.userId;
 
-        // Fix collaborators
-        if (Array.isArray(newConfig.collaborators)) {
-          newConfig.collaborators = newConfig.collaborators.map((id: any) => getNewId(id) || id);
+      // 3. Create new Configs
+      const userConfigs = configs.filter((c) => c.userId.toString() === oldUserIdStr);
+      userConfigs.forEach((oldConfig) => {
+        const newConfig = createNewDoc(oldConfig);
+        if (!newConfig) return;
+        newConfig.userId = newUserId;
+        newConfig.collaborators = (oldConfig.collaborators || []).map((id) =>
+          getUUID(id)
+        );
+        if (newConfig.taskListSortSettings) {
+          Object.entries(newConfig.taskListSortSettings).forEach(
+            ([category, settings]: [string, any]) => {
+              const newSettings = {
+                userId: getUUID(settings.userId),
+                sortList: settings.sortList
+              };
+              newConfig.taskListSortSettings[category] = newSettings;
+            }
+          );
         }
+        if (newConfig.taskListFilterSettings) {
+          Object.entries(newConfig.taskListFilterSettings).forEach(
+            ([category, settings]: [string, any]) => {
+              const newSettings = {
+                ...settings,
+                userId: getUUID(settings.userId)
+              };
+              newConfig.taskListFilterSettings[category] = newSettings;
+            }
+          );
+        }
+        verifyDoc(oldConfig, newConfig);
+        newConfigsToCreate.push(newConfig);
+      });
 
-        newConfigs.push(newConfig);
-        oldConfigIds.push(config._id);
-      }
-    }
+      // 4. Nonogram Items
+      const userNonogramItems = nonogramItems.filter((i) => i.userId.toString() === oldUserIdStr);
+      userNonogramItems.forEach((oldItem) => {
+        const newItem = createNewDoc(oldItem);
+        if (!newItem) return;
+        newItem.userId = newUserId;
+        verifyDoc(oldItem, newItem);
+        newNonogramItemsToCreate.push(newItem);
+      });
 
-    // 5. Execute
-    if (dryRun) {
-      DR.logger.info(`[DRY RUN] Would insert ${newUsers.length} users and delete ${oldUserIds.length} old ones.`);
-      DR.logger.info(`[DRY RUN] Would insert ${newTasks.length} tasks and delete ${oldTaskIds.length} old ones.`);
-      DR.logger.info(`[DRY RUN] Would insert ${newConfigs.length} configs and delete ${oldConfigIds.length} old ones.`);
-      return;
+      // 5. Nonogram Upgrades
+      const userNonogramUpgrades = nonogramUpgrades.filter((u) => u.userId.toString() === oldUserIdStr);
+      userNonogramUpgrades.forEach((oldUpgrade) => {
+        const newUpgrade = createNewDoc(oldUpgrade);
+        if (!newUpgrade) return;
+        newUpgrade.userId = newUserId;
+        verifyDoc(oldUpgrade, newUpgrade);
+        newNonogramUpgradesToCreate.push(newUpgrade);
+      });
     }
 
-    DR.logger.info('Executing migration...');
-
-    // Users
-    if (newUsers.length > 0) {
-      await userRepo.insertMany(newUsers);
-      await userRepo.deleteList(oldUserIds);
-      DR.logger.success(`Migrated ${newUsers.length} users.`);
+    // Now create related documents for each user
+    legacyUsers.forEach((u) => createNewDocsForUser(u));
+
+    const legacyUserIds = new Set(legacyUsers.map((u) => u._id.toString()));
+    const expectedUsers = legacyUsers.length;
+    const expectedApiKeys = apiKeys.filter((k) =>
+      legacyUserIds.has(k.userId.toString())
+    ).length;
+    const expectedTasks = tasks.filter((t) =>
+      legacyUserIds.has(t.userId.toString())
+    ).length;
+    const expectedConfigs = configs.filter((c) =>
+      legacyUserIds.has(c.userId.toString())
+    ).length;
+    const expectedNonogramItems = nonogramItems.filter((i) =>
+      legacyUserIds.has(i.userId.toString())
+    ).length;
+    const expectedNonogramUpgrades = nonogramUpgrades.filter((u) =>
+      legacyUserIds.has(u.userId.toString())
+    ).length;
+
+    if (newUsersToCreate.length !== expectedUsers) {
+      DR.logger.error(
+        `Expected ${expectedUsers} users, but prepped ${newUsersToCreate.length}.`
+      );
     }
-
-    // Tasks
-    if (newTasks.length > 0) {
-      await taskRepo.insertMany(newTasks);
-      await taskRepo.deleteList(oldTaskIds);
-      DR.logger.success(`Migrated ${newTasks.length} tasks.`);
+    if (newApiKeysToCreate.length !== expectedApiKeys) {
+      DR.logger.error(
+        `Expected ${expectedApiKeys} API keys, but prepped ${newApiKeysToCreate.length}.`
+      );
+    }
+    if (newTasksToCreate.length !== expectedTasks) {
+      DR.logger.error(
+        `Expected ${expectedTasks} tasks, but prepped ${newTasksToCreate.length}.`
+      );
+    }
+    if (newConfigsToCreate.length !== expectedConfigs) {
+      DR.logger.error(
+        `Expected ${expectedConfigs} configs, but prepped ${newConfigsToCreate.length}.`
+      );
+    }
+    if (newNonogramItemsToCreate.length !== expectedNonogramItems) {
+      DR.logger.error(
+        `Expected ${expectedNonogramItems} nonogram items, but prepped ${newNonogramItemsToCreate.length}.`
+      );
+    }
+    if (newNonogramUpgradesToCreate.length !== expectedNonogramUpgrades) {
+      DR.logger.error(
+        `Expected ${expectedNonogramUpgrades} nonogram upgrades, but prepped ${newNonogramUpgradesToCreate.length}.`
+      );
     }
 
-    // Configs
-    if (newConfigs.length > 0) {
-      await configRepo.insertMany(newConfigs);
-      await configRepo.deleteList(oldConfigIds);
-      DR.logger.success(`Migrated ${newConfigs.length} configs.`);
+    DR.logger.info(`Prepped ${newUsersToCreate.length} new users.`);
+    DR.logger.info(`Prepped ${newApiKeysToCreate.length} new API keys.`);
+    DR.logger.info(`Prepped ${newTasksToCreate.length} new tasks.`);
+    DR.logger.info(`Prepped ${newConfigsToCreate.length} new configs.`);
+    DR.logger.info(
+      `Prepped ${newNonogramItemsToCreate.length} new nonogram items.`
+    );
+    DR.logger.info(
+      `Prepped ${newNonogramUpgradesToCreate.length} new nonogram upgrades.`
+    );
+    DR.logger.info(`In total, prepped ${
+      newUsersToCreate.length +
+      newApiKeysToCreate.length +
+      newTasksToCreate.length +
+      newConfigsToCreate.length +
+      newNonogramItemsToCreate.length +
+      newNonogramUpgradesToCreate.length
+    } documents for insertion.`);
+
+    if (!dryRun) {
+      DR.logger.info('Dry run is false. Inserting documents into DB...');
+      if (newUsersToCreate.length > 0) {
+        await (await userRepo.getCollection()).insertMany(newUsersToCreate);
+      }
+      if (newApiKeysToCreate.length > 0) {
+        await (await apiKeyRepo.getCollection()).insertMany(newApiKeysToCreate);
+      }
+      if (newTasksToCreate.length > 0) {
+        await (await taskRepo.getCollection()).insertMany(newTasksToCreate);
+      }
+      if (newConfigsToCreate.length > 0) {
+        await (await configRepo.getCollection()).insertMany(newConfigsToCreate);
+      }
+      if (newNonogramItemsToCreate.length > 0) {
+        await (
+          await nonogramItemRepo.getCollection()
+        ).insertMany(newNonogramItemsToCreate);
+      }
+      if (newNonogramUpgradesToCreate.length > 0) {
+        await (
+          await nonogramUpgradesRepo.getCollection()
+        ).insertMany(newNonogramUpgradesToCreate);
+      }
+      DR.logger.info('Insertion complete.');
+    } else {
+      DR.logger.info('Dry run is true. Skipping DB insertion.');
     }
 
-    DR.logger.success('Migration complete!');
+    return;
   }
+
+  // We started with 1204 docs
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@aneuhold/be-ts-db-lib",
   "author": "Anton G. Neuhold Jr.",
   "license": "MIT",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "A backend database library meant to actually interact with various databases in personal projects",
   "packageManager": "pnpm@10.12.1",
   "type": "module",
@@ -57,14 +57,15 @@
     "MongoDB"
   ],
   "dependencies": {
-    "@aneuhold/be-ts-lib": "^3.0.0",
-    "@aneuhold/core-ts-db-lib": "^3.0.0",
+    "@aneuhold/be-ts-lib": "^3.0.1",
+    "@aneuhold/core-ts-db-lib": "^3.0.1",
     "@aneuhold/core-ts-lib": "^2.3.11",
     "bson": "^7.0.0",
-    "mongodb": "^7.0.0"
+    "mongodb": "^7.0.0",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@aneuhold/local-npm-registry": "^0.2.17",
+    "@aneuhold/local-npm-registry": "^0.2.18",
     "@aneuhold/main-scripts": "^2.7.2",
     "@types/node": "^24.10.0",
     "@types/node-fetch": "^2.6.13",