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.

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

 import { IMongoDate } from "../types/commonTypes";
 import {
     equipmentKeys,
+    ICrewShipClient,
+    ICrewShipDatabase,
+    ICrewShipMembersClient,
+    ICrewShipMembersDatabase,
     IDialogueClient,
     IDialogueDatabase,
     IDialogueHistoryClient,
     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,
     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);
     }

         | "CrewShipWeaponSkins"
         | "OperatorLoadOuts"
         | "AdultOperatorLoadOuts"
+        | "CrewShips"
         | "InfestedFoundry"
         | "DialogueHistory"
         | TEquipmentKey
     CrewShipWeaponSkins: IUpgradeDatabase[];
     OperatorLoadOuts: IOperatorConfigDatabase[];
     AdultOperatorLoadOuts: IOperatorConfigDatabase[];
+    CrewShips: ICrewShipDatabase[];
     InfestedFoundry?: IInfestedFoundryDatabase;
     DialogueHistory?: IDialogueHistoryDatabase;
     LastNemesisAllySpawnTime?: IMongoDate;
     Settings: ISettings;
     PersonalTechProjects: IPersonalTechProject[];
-    CrewShips: ICrewShip[];
+    CrewShips: ICrewShipClient[];
     PlayerSkills: IPlayerSkills;
     CrewShipAmmo: IConsumable[];
     CrewShipSalvagedWeaponSkins: IUpgradeClient[];
     _id: Types.ObjectId;
 }
-export interface ICrewShip {
+export interface ICrewShipClient {
     ItemType: string;
     Configs: IItemConfig[];
     Weapon?: ICrewShipWeapon;
     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