feat: import #831

⚠️ Potential issue

Avoid unnecessary parsing of req.body

Express, when configured with the appropriate middleware, automatically parses JSON request bodies. Directly calling JSON.parse(String(req.body)) may not be necessary and could lead to errors if req.body is already an object.

Modify the code to use the parsed body directly:

-    const request = JSON.parse(String(req.body)) as IImportRequest;
+    const request = req.body as IImportRequest;

Ensure that express.json() middleware is applied to parse JSON request bodies.

📝 Committable suggestion

    const request = req.body as IImportRequest;

_:warning: Potential issue_ **Avoid unnecessary parsing of `req.body`** Express, when configured with the appropriate middleware, automatically parses JSON request bodies. Directly calling `JSON.parse(String(req.body))` may not be necessary and could lead to errors if `req.body` is already an object. Modify the code to use the parsed body directly: ```diff - const request = JSON.parse(String(req.body)) as IImportRequest; + const request = req.body as IImportRequest; ``` Ensure that `express.json()` middleware is applied to parse JSON request bodies.  <details> <summary>📝 Committable suggestion</summary> > ‼️ **IMPORTANT** > Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements. `````suggestion const request = req.body as IImportRequest; ````` </details>

🛠️ Refactor suggestion

Implement error handling during import

Operations like importInventory and inventory.save() can fail. Without error handling, any failures won't be communicated back to the client, and the server might crash due to unhandled exceptions.

Wrap the import operations in a try-catch block and handle errors appropriately:

+    try {
         const inventory = await getInventory(accountId);
         importInventory(inventory, request.inventory);
         await inventory.save();
+    } catch (error) {
+        res.status(500).json({ error: 'Failed to import inventory' });
+        return;
+    }

_:hammer_and_wrench: Refactor suggestion_ **Implement error handling during import** Operations like `importInventory` and `inventory.save()` can fail. Without error handling, any failures won't be communicated back to the client, and the server might crash due to unhandled exceptions. Wrap the import operations in a try-catch block and handle errors appropriately: ```diff + try { const inventory = await getInventory(accountId); importInventory(inventory, request.inventory); await inventory.save(); + } catch (error) { + res.status(500).json({ error: 'Failed to import inventory' }); + return; + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

🛠️ Refactor suggestion

Consider using transactions for atomic operations.

The importInventory function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction.

Additionally, the function should validate the client object structure before processing.

 export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => {
+    if (!db || !client) {
+        throw new Error('Invalid arguments: db and client are required');
+    }
+
+    // Validate required client properties
+    const requiredKeys = ['WeaponSkins', 'Upgrades'];
+    for (const key of requiredKeys) {
+        if (client[key] && !Array.isArray(client[key])) {
+            throw new Error(`Invalid ${key} format: expected array`);
+        }
+    }

_:hammer_and_wrench: Refactor suggestion_ **Consider using transactions for atomic operations.** The `importInventory` function performs multiple updates that should be atomic. Consider wrapping the operations in a transaction. Additionally, the function should validate the client object structure before processing. ```diff export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<IInventoryClient>): void => { + if (!db || !client) { + throw new Error('Invalid arguments: db and client are required'); + } + + // Validate required client properties + const requiredKeys = ['WeaponSkins', 'Upgrades']; + for (const key of requiredKeys) { + if (client[key] && !Array.isArray(client[key])) { + throw new Error(`Invalid ${key} format: expected array`); + } + } ``` > Committable suggestion skipped: line range outside the PR's diff.

💡 Codebase verification

Consider using a shared type for the loadout categories

The coupling between ILoadoutDatabase and ILoadOutPresets exists because they share similar property keys but use different value types (ILoadoutConfigDatabase[] vs ILoadoutConfigClient[]). To better maintain this relationship:

Consider extracting the common loadout categories into a shared enum or string union type
Document the intentional differences (e.g., OPERATOR_ADULT vs GEAR)
Add a comment explaining the Database-to-Client relationship

🔗 Analysis chain

Consider documenting the coupling mechanism.

The comment indicates that ILoadoutDatabase should be kept in sync with ILoadOutPresets. Consider documenting how this sync is maintained and whether this coupling could be enforced through types.

Let's check for the usage of these interfaces:

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Find usages of both interfaces to understand the coupling
rg -l "ILoadOutPresets|ILoadoutDatabase" --type ts

Length of output: 269

Script:

#!/bin/bash
# Get the interface definitions and surrounding context
rg "interface (ILoadOutPresets|ILoadoutDatabase)" -A 10 --type ts

Length of output: 1712

_:bulb: Codebase verification_ **Consider using a shared type for the loadout categories** The coupling between `ILoadoutDatabase` and `ILoadOutPresets` exists because they share similar property keys but use different value types (`ILoadoutConfigDatabase[]` vs `ILoadoutConfigClient[]`). To better maintain this relationship: - Consider extracting the common loadout categories into a shared `enum` or string union type - Document the intentional differences (e.g., `OPERATOR_ADULT` vs `GEAR`) - Add a comment explaining the Database-to-Client relationship <details> <summary>🔗 Analysis chain</summary> **Consider documenting the coupling mechanism.** The comment indicates that `ILoadoutDatabase` should be kept in sync with `ILoadOutPresets`. Consider documenting how this sync is maintained and whether this coupling could be enforced through types. Let's check for the usage of these interfaces: </details> <details> <summary>🏁 Scripts executed</summary> The following scripts were executed for the analysis: Script: ```shell #!/bin/bash # Find usages of both interfaces to understand the coupling rg -l "ILoadOutPresets|ILoadoutDatabase" --type ts ``` Length of output: 269 --- Script: ```shell #!/bin/bash # Get the interface definitions and surrounding context rg "interface (ILoadOutPresets|ILoadoutDatabase)" -A 10 --type ts ``` Length of output: 1712 </details>

 @ -1,15 +1,24 @@
 import { importInventory } from "@/src/services/importService";
 import { importInventory, importLoadOutPresets } from "@/src/services/importService";
 import { getInventory } from "@/src/services/inventoryService";
 import { getLoadout } from "@/src/services/loadoutService";
 import { getAccountIdForRequest } from "@/src/services/loginService";
 import { IInventoryClient } from "@/src/types/inventoryTypes/inventoryTypes";
 import { RequestHandler } from "express";
 export const importController: RequestHandler = async (req, res) => {
     const accountId = await getAccountIdForRequest(req);
     const inventory = await getInventory(accountId);
     const request = JSON.parse(String(req.body)) as IImportRequest;
     const inventory = await getInventory(accountId);
     importInventory(inventory, request.inventory);
     await inventory.save();
     if (request.inventory.LoadOutPresets) {
         const loadout = await getLoadout(accountId);
         importLoadOutPresets(loadout, request.inventory.LoadOutPresets);
         await loadout.save();
     }
     res.end();
 };

 @ -9,6 +9,8 @@ import { IMongoDate } from "../types/commonTypes";
 import {
     equipmentKeys,
     IInventoryClient,
     ILoadoutConfigClient,
     ILoadOutPresets,
     ISlots,
     IUpgradeClient,
     IUpgradeDatabase,
 @ -16,6 +18,7 @@ import {
     IWeaponSkinDatabase
 } from "../types/inventoryTypes/inventoryTypes";
 import { TInventoryDatabaseDocument } from "../models/inventoryModels/inventoryModel";
 import { ILoadoutConfigDatabase, ILoadoutDatabase } from "../types/saveLoadoutTypes";
 /* eslint-disable @typescript-eslint/no-unused-vars */
 @ -137,3 +140,25 @@ export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<
         }
     }
 };
 const convertLoadOutConfig = (client: ILoadoutConfigClient): ILoadoutConfigDatabase => {
     const { ItemId, ...rest } = client;
     return {
         ...rest,
         _id: new Types.ObjectId(client.ItemId.$oid)
     };
 };
 export const importLoadOutPresets = (db: ILoadoutDatabase, client: ILoadOutPresets): void => {
     db.NORMAL = client.NORMAL.map(convertLoadOutConfig);
     db.SENTINEL = client.SENTINEL.map(convertLoadOutConfig);
     db.ARCHWING = client.ARCHWING.map(convertLoadOutConfig);
     db.NORMAL_PVP = client.NORMAL_PVP.map(convertLoadOutConfig);
     db.LUNARO = client.LUNARO.map(convertLoadOutConfig);
     db.OPERATOR = client.OPERATOR.map(convertLoadOutConfig);
     db.KDRIVE = client.KDRIVE.map(convertLoadOutConfig);
     db.DATAKNIFE = client.DATAKNIFE.map(convertLoadOutConfig);
     db.MECH = client.MECH.map(convertLoadOutConfig);
     db.OPERATOR_ADULT = client.OPERATOR_ADULT.map(convertLoadOutConfig);
     db.DRIFTER = client.DRIFTER.map(convertLoadOutConfig);
 };

 @ -210,7 +210,7 @@ export interface IInventoryClient extends IDailyAffiliations {
     Scoops: IEquipmentDatabase[];
     TrainingRetriesLeft: number;
     LoadOutPresets: ILoadOutPresets;
     CurrentLoadOutIds: Array<any[] | IOid>;
     CurrentLoadOutIds: IOid[]; // we store it in the database using this representation as well :/
     Missions: IMission[];
     RandomUpgradesIdentified?: number;
     LastRegionPlayed: TSolarMapRegion;
 @ -667,7 +667,7 @@ export interface ILibraryPersonalProgress {
     Completed: boolean;
 }
 //this needs to be checked against ILoadoutDatabase
 // keep in sync with ILoadoutDatabase
 export interface ILoadOutPresets {
     NORMAL: ILoadoutConfigClient[];
     NORMAL_PVP: ILoadoutConfigClient[];
 @ -680,6 +680,7 @@ export interface ILoadOutPresets {
     DATAKNIFE: ILoadoutConfigClient[];
     MECH: ILoadoutConfigClient[];
     OPERATOR_ADULT: ILoadoutConfigClient[];
     DRIFTER: ILoadoutConfigClient[];
 }
 export enum FocusSchool {

 @ -54,18 +54,19 @@ export interface IConfigEntry {
 export interface ILoadoutClient extends Omit<ILoadoutDatabase, "_id" | "loadoutOwnerId"> {}
 // keep in sync with ILoadOutPresets
 export interface ILoadoutDatabase {
     NORMAL: ILoadoutEntry;
     SENTINEL: ILoadoutEntry;
     ARCHWING: ILoadoutEntry;
     NORMAL_PVP: ILoadoutEntry;
     LUNARO: ILoadoutEntry;
     OPERATOR: ILoadoutEntry;
     KDRIVE: ILoadoutEntry;
     DATAKNIFE: ILoadoutEntry;
     MECH: ILoadoutEntry;
     OPERATOR_ADULT: ILoadoutEntry;
     DRIFTER: ILoadoutEntry;
     NORMAL: ILoadoutConfigDatabase[];
     SENTINEL: ILoadoutConfigDatabase[];
     ARCHWING: ILoadoutConfigDatabase[];
     NORMAL_PVP: ILoadoutConfigDatabase[];
     LUNARO: ILoadoutConfigDatabase[];
     OPERATOR: ILoadoutConfigDatabase[];
     KDRIVE: ILoadoutConfigDatabase[];
     DATAKNIFE: ILoadoutConfigDatabase[];
     MECH: ILoadoutConfigDatabase[];
     OPERATOR_ADULT: ILoadoutConfigDatabase[];
     DRIFTER: ILoadoutConfigDatabase[];
     _id: Types.ObjectId;
     loadoutOwnerId: Types.ObjectId;
 }

feat: import #831

13

src/controllers/custom/importController.ts

View File

25

src/services/importService.ts

View File

5

src/types/inventoryTypes/inventoryTypes.ts

View File

23

src/types/saveLoadoutTypes.ts

View File

feat: import #831

13 src/controllers/custom/importController.ts Unescape Escape View File

25 src/services/importService.ts Unescape Escape View File

5 src/types/inventoryTypes/inventoryTypes.ts Unescape Escape View File

23 src/types/saveLoadoutTypes.ts Unescape Escape View File

13

src/controllers/custom/importController.ts

View File

25

src/services/importService.ts

View File

5

src/types/inventoryTypes/inventoryTypes.ts

View File

23

src/types/saveLoadoutTypes.ts

View File