feat: import #831

🛠️ 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.

⚠️ Potential issue

Validate ItemId.$oid and CrewMembers in convertCrewShip

In the convertCrewShip function, add validation for ItemId.$oid and ensure that CrewMembers are properly converted if present.

Apply this diff to add validation:

 const convertCrewShip = (client: ICrewShipClient): ICrewShipDatabase => {
     const { ItemId, ...rest } = client;
+    if (!ItemId || !ItemId.$oid || !Types.ObjectId.isValid(ItemId.$oid)) {
+        throw new Error('Invalid ItemId');
+    }
     return {
         ...rest,
         _id: new Types.ObjectId(ItemId.$oid),
         CrewMembers: client.CrewMembers ? convertCrewShipMembers(client.CrewMembers) : undefined
     };
 };

_:warning: Potential issue_ **Validate `ItemId.$oid` and `CrewMembers` in `convertCrewShip`** In the `convertCrewShip` function, add validation for `ItemId.$oid` and ensure that `CrewMembers` are properly converted if present. Apply this diff to add validation: ```diff const convertCrewShip = (client: ICrewShipClient): ICrewShipDatabase => { const { ItemId, ...rest } = client; + if (!ItemId || !ItemId.$oid || !Types.ObjectId.isValid(ItemId.$oid)) { + throw new Error('Invalid ItemId'); + } return { ...rest, _id: new Types.ObjectId(ItemId.$oid), CrewMembers: client.CrewMembers ? convertCrewShipMembers(client.CrewMembers) : undefined }; }; ``` > 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.

 @ -42,7 +42,6 @@ import {
     ICrewShipCustomization,
     ICrewShipWeapon,
     ICrewShipMembersClient,
     ICrewShip,
     ICrewShipPilotWeapon,
     IShipExterior,
     IHelminthFoodRecord,
 @ -52,7 +51,8 @@ import {
     IDialogueGift,
     ICompletedDialogue,
     IDialogueClient,
     IUpgradeDatabase
     IUpgradeDatabase,
     ICrewShipDatabase
 } from "../../types/inventoryTypes/inventoryTypes";
 import { IOid } from "../../types/commonTypes";
 import {
 @ -694,7 +694,7 @@ crewShipMembersSchema.set("toJSON", {
     }
 });
 const crewShipSchema = new Schema<ICrewShip>({
 const crewShipSchema = new Schema<ICrewShipDatabase>({
     ItemType: { type: String, required: true },
     Configs: { type: [ItemConfigSchema], default: [] },
     Weapon: { type: crewShipWeaponSchema, default: undefined },
 @ -1184,7 +1184,7 @@ type InventoryDocumentProps = {
     Hoverboards: Types.DocumentArray<IEquipmentDatabase>;
     MoaPets: Types.DocumentArray<IEquipmentDatabase>;
     WeaponSkins: Types.DocumentArray<IWeaponSkinDatabase>;
     CrewShips: Types.DocumentArray<ICrewShip>;
     CrewShips: Types.DocumentArray<ICrewShipDatabase>;
     CrewShipHarnesses: Types.DocumentArray<IEquipmentDatabase>;
 };

 @ -8,6 +8,10 @@ import {
 import { IMongoDate } from "../types/commonTypes";
 import {
     equipmentKeys,
     ICrewShipClient,
     ICrewShipDatabase,
     ICrewShipMembersClient,
     ICrewShipMembersDatabase,
     IDialogueClient,
     IDialogueDatabase,
     IDialogueHistoryClient,
 @ -81,6 +85,23 @@ const replaceSlots = (db: ISlots, client: ISlots): void => {
     db.Slots = client.Slots;
 };
 const convertCrewShipMembers = (client: ICrewShipMembersClient): ICrewShipMembersDatabase => {
     return {
         SLOT_A: client.SLOT_A ? new Types.ObjectId(client.SLOT_A.ItemId.$oid) : undefined,
         SLOT_B: client.SLOT_B ? new Types.ObjectId(client.SLOT_B.ItemId.$oid) : undefined,
         SLOT_C: client.SLOT_C ? new Types.ObjectId(client.SLOT_C.ItemId.$oid) : undefined
     };
 };
 const convertCrewShip = (client: ICrewShipClient): ICrewShipDatabase => {
     const { ItemId, ...rest } = client;
     return {
         ...rest,
         _id: new Types.ObjectId(ItemId.$oid),
         CrewMembers: client.CrewMembers ? convertCrewShipMembers(client.CrewMembers) : undefined
     };
 };
 const convertInfestedFoundry = (client: IInfestedFoundryClient): IInfestedFoundryDatabase => {
     return {
         ...client,
 @ -192,6 +213,9 @@ export const importInventory = (db: TInventoryDatabaseDocument, client: Partial<
     if (client.FocusUpgrades) {
         db.FocusUpgrades = client.FocusUpgrades;
     }
     if (client.CrewShips) {
         replaceArray<ICrewShipDatabase>(db.CrewShips, client.CrewShips.map(convertCrewShip));
     }
     if (client.InfestedFoundry) {
         db.InfestedFoundry = convertInfestedFoundry(client.InfestedFoundry);
     }

 @ -30,6 +30,7 @@ export interface IInventoryDatabase
         | "CrewShipWeaponSkins"
         | "OperatorLoadOuts"
         | "AdultOperatorLoadOuts"
         | "CrewShips"
         | "InfestedFoundry"
         | "DialogueHistory"
         | TEquipmentKey
 @ -50,6 +51,7 @@ export interface IInventoryDatabase
     CrewShipWeaponSkins: IUpgradeDatabase[];
     OperatorLoadOuts: IOperatorConfigDatabase[];
     AdultOperatorLoadOuts: IOperatorConfigDatabase[];
     CrewShips: ICrewShipDatabase[];
     InfestedFoundry?: IInfestedFoundryDatabase;
     DialogueHistory?: IDialogueHistoryDatabase;
 @ -292,7 +294,7 @@ export interface IInventoryClient extends IDailyAffiliations {
     LastNemesisAllySpawnTime?: IMongoDate;
     Settings: ISettings;
     PersonalTechProjects: IPersonalTechProject[];
     CrewShips: ICrewShip[];
     CrewShips: ICrewShipClient[];
     PlayerSkills: IPlayerSkills;
     CrewShipAmmo: IConsumable[];
     CrewShipSalvagedWeaponSkins: IUpgradeClient[];
 @ -452,7 +454,7 @@ export interface IUpgradeDatabase extends Omit<IUpgradeClient, "ItemId"> {
     _id: Types.ObjectId;
 }
 export interface ICrewShip {
 export interface ICrewShipClient {
     ItemType: string;
     Configs: IItemConfig[];
     Weapon?: ICrewShipWeapon;
 @ -461,6 +463,10 @@ export interface ICrewShip {
     RailjackImage?: IFlavourItem;
     CrewMembers?: ICrewShipMembersClient;
     ItemId: IOid;
 }
 export interface ICrewShipDatabase extends Omit<ICrewShipClient, "CrewMembers" | "ItemId"> {
     CrewMembers?: ICrewShipMembersDatabase;
     _id: Types.ObjectId;
 }

feat: import #831

8

src/models/inventoryModels/inventoryModel.ts

View File

24

src/services/importService.ts

View File

10

src/types/inventoryTypes/inventoryTypes.ts

View File

feat: import #831

8 src/models/inventoryModels/inventoryModel.ts Unescape Escape View File

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

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

8

src/models/inventoryModels/inventoryModel.ts

View File

24

src/services/importService.ts

View File

10

src/types/inventoryTypes/inventoryTypes.ts

View File