MongoDB Transactions and ACID Compliance in Distributed Systems: Multi-Document Consistency Patterns with SQL-Familiar Transaction Management

// Traditional approach without transactions - complex error-prone coordination
async function transferFundsBetweenAccountsWithoutTransactions(fromAccountId, toAccountId, amount) {
  try {
    // Step 1: Check sufficient balance
    const fromAccount = await db.accounts.findOne({ _id: fromAccountId });
    if (!fromAccount || fromAccount.balance < amount) {
      throw new Error('Insufficient funds');
    }

    // Step 2: Deduct from source account
    const debitResult = await db.accounts.updateOne(
      { _id: fromAccountId, balance: { $gte: amount } },
      { $inc: { balance: -amount } }
    );

    if (debitResult.matchedCount === 0) {
      throw new Error('Concurrent modification - insufficient funds');
    }

    // Step 3: Add to destination account
    const creditResult = await db.accounts.updateOne(
      { _id: toAccountId },
      { $inc: { balance: amount } }
    );

    if (creditResult.matchedCount === 0) {
      // Rollback: Add money back to source account
      await db.accounts.updateOne(
        { _id: fromAccountId },
        { $inc: { balance: amount } }
      );
      throw new Error('Failed to credit destination account');
    }

    // Step 4: Record transaction history
    const historyResult = await db.transactionHistory.insertOne({
      fromAccount: fromAccountId,
      toAccount: toAccountId,
      amount: amount,
      type: 'transfer',
      timestamp: new Date(),
      status: 'completed'
    });

    if (!historyResult.insertedId) {
      // Complex rollback required
      await db.accounts.updateOne({ _id: fromAccountId }, { $inc: { balance: amount } });
      await db.accounts.updateOne({ _id: toAccountId }, { $inc: { balance: -amount } });
      throw new Error('Failed to record transaction history');
    }

    // Step 5: Update account statistics
    await db.accountStats.updateOne(
      { accountId: fromAccountId },
      { 
        $inc: { totalDebits: amount, transactionCount: 1 },
        $set: { lastActivity: new Date() }
      },
      { upsert: true }
    );

    await db.accountStats.updateOne(
      { accountId: toAccountId },
      { 
        $inc: { totalCredits: amount, transactionCount: 1 },
        $set: { lastActivity: new Date() }
      },
      { upsert: true }
    );

    return {
      success: true,
      transactionId: historyResult.insertedId,
      fromAccountBalance: fromAccount.balance - amount,
      timestamp: new Date()
    };

  } catch (error) {
    // Complex error recovery and partial rollback logic required
    console.error('Transfer failed:', error.message);

    // Attempt to verify and correct any partial updates
    try {
      // Check for orphaned updates and compensate
      await validateAndCompensatePartialTransfer(fromAccountId, toAccountId, amount);
    } catch (compensationError) {
      console.error('Compensation failed:', compensationError.message);
      // Manual intervention may be required
    }

    throw error;
  }
}

// Problems with non-transactional approaches:
// 1. Complex rollback logic for partial failures
// 2. Race conditions between concurrent operations
// 3. Potential data inconsistency during failure scenarios
// 4. Manual compensation logic for error recovery
// 5. Difficult to guarantee atomic multi-document operations
// 6. Complex error handling and state management
// 7. Risk of phantom reads and dirty reads
// 8. No isolation guarantees for concurrent access
// 9. Difficult to implement complex business rules atomically
// 10. Manual coordination across multiple collections and operations

async function validateAndCompensatePartialTransfer(fromAccountId, toAccountId, amount) {
  // Complex validation and compensation logic
  const fromAccount = await db.accounts.findOne({ _id: fromAccountId });
  const toAccount = await db.accounts.findOne({ _id: toAccountId });

  // Check for partial transfer state
  const recentHistory = await db.transactionHistory.findOne({
    fromAccount: fromAccountId,
    toAccount: toAccountId,
    amount: amount,
    timestamp: { $gte: new Date(Date.now() - 60000) } // Last minute
  });

  if (!recentHistory) {
    // No history recorded - check if money was debited but not credited
    const expectedFromBalance = fromAccount.originalBalance - amount; // This is problematic - we don't know original balance

    // Complex logic to determine correct state and compensate
    if (fromAccount.balance < expectedFromBalance) {
      // Money was debited but not credited - complete the transfer
      await db.accounts.updateOne(
        { _id: toAccountId },
        { $inc: { balance: amount } }
      );

      await db.transactionHistory.insertOne({
        fromAccount: fromAccountId,
        toAccount: toAccountId,
        amount: amount,
        type: 'transfer_compensation',
        timestamp: new Date(),
        status: 'compensated'
      });
    }
  }

  // Additional complex state validation and recovery logic...
}

// Traditional batch processing with manual consistency management
async function processOrderBatchWithoutTransactions(orders) {
  const processedOrders = [];
  const failedOrders = [];

  for (const order of orders) {
    try {
      // Step 1: Validate inventory
      const inventoryCheck = await db.inventory.findOne({ 
        productId: order.productId,
        quantity: { $gte: order.quantity }
      });

      if (!inventoryCheck) {
        failedOrders.push({ order, reason: 'insufficient_inventory' });
        continue;
      }

      // Step 2: Reserve inventory
      const inventoryUpdate = await db.inventory.updateOne(
        { 
          productId: order.productId, 
          quantity: { $gte: order.quantity }
        },
        { $inc: { quantity: -order.quantity, reserved: order.quantity } }
      );

      if (inventoryUpdate.matchedCount === 0) {
        failedOrders.push({ order, reason: 'inventory_update_failed' });
        continue;
      }

      // Step 3: Create order record
      const orderResult = await db.orders.insertOne({
        ...order,
        status: 'confirmed',
        createdAt: new Date(),
        inventoryReserved: true
      });

      if (!orderResult.insertedId) {
        // Rollback inventory reservation
        await db.inventory.updateOne(
          { productId: order.productId },
          { $inc: { quantity: order.quantity, reserved: -order.quantity } }
        );
        failedOrders.push({ order, reason: 'order_creation_failed' });
        continue;
      }

      // Step 4: Update customer statistics
      await db.customerStats.updateOne(
        { customerId: order.customerId },
        { 
          $inc: { 
            totalOrders: 1, 
            totalSpent: order.total 
          },
          $set: { lastOrderDate: new Date() }
        },
        { upsert: true }
      );

      processedOrders.push({
        orderId: orderResult.insertedId,
        customerId: order.customerId,
        productId: order.productId,
        status: 'completed'
      });

    } catch (error) {
      console.error('Order processing failed:', error);

      // Attempt partial cleanup - complex and error-prone
      try {
        await cleanupPartialOrder(order);
      } catch (cleanupError) {
        console.error('Cleanup failed for order:', order.orderId, cleanupError);
      }

      failedOrders.push({ 
        order, 
        reason: 'processing_error', 
        error: error.message 
      });
    }
  }

  return {
    processed: processedOrders,
    failed: failedOrders,
    summary: {
      total: orders.length,
      successful: processedOrders.length,
      failed: failedOrders.length
    }
  };
}

// MongoDB transactions - simple, reliable, ACID-compliant operations
const { MongoClient } = require('mongodb');

class DistributedTransactionManager {
  constructor(mongoClient) {
    this.client = mongoClient;
    this.db = mongoClient.db('financial_platform');

    // Collections for transactional operations
    this.collections = {
      accounts: this.db.collection('accounts'),
      transactions: this.db.collection('transactions'),
      accountStats: this.db.collection('account_statistics'),
      auditLog: this.db.collection('audit_log'),
      orders: this.db.collection('orders'),
      inventory: this.db.collection('inventory'),
      customers: this.db.collection('customers'),
      notifications: this.db.collection('notifications')
    };

    // Transaction configuration for different operation types
    this.transactionConfig = {
      // Financial operations require strict consistency
      financial: {
        readConcern: { level: 'snapshot' },
        writeConcern: { w: 'majority', j: true, wtimeout: 5000 },
        readPreference: 'primary',
        maxCommitTimeMS: 10000
      },

      // Business operations with balanced performance/consistency
      business: {
        readConcern: { level: 'majority' },
        writeConcern: { w: 'majority', j: true, wtimeout: 3000 },
        readPreference: 'primaryPreferred',
        maxCommitTimeMS: 8000
      },

      // Analytics operations allowing eventual consistency
      analytics: {
        readConcern: { level: 'available' },
        writeConcern: { w: 1, wtimeout: 2000 },
        readPreference: 'secondaryPreferred',
        maxCommitTimeMS: 5000
      }
    };
  }

  async transferFunds(fromAccountId, toAccountId, amount, metadata = {}) {
    const session = this.client.startSession();

    try {
      const result = await session.withTransaction(async () => {
        // All operations within this function are executed atomically

        // Step 1: Validate and lock source account with optimistic concurrency
        const fromAccount = await this.collections.accounts.findOneAndUpdate(
          { 
            _id: fromAccountId,
            balance: { $gte: amount },
            status: 'active',
            locked: { $ne: true }
          },
          { 
            $inc: { balance: -amount },
            $set: { 
              lastModified: new Date(),
              version: { $inc: 1 }
            }
          },
          { 
            session,
            returnDocument: 'before' // Get account state before modification
          }
        );

        if (!fromAccount.value) {
          throw new Error('Insufficient funds or account locked');
        }

        // Step 2: Credit destination account
        const toAccount = await this.collections.accounts.findOneAndUpdate(
          { 
            _id: toAccountId,
            status: 'active'
          },
          { 
            $inc: { balance: amount },
            $set: { 
              lastModified: new Date(),
              version: { $inc: 1 }
            }
          },
          { 
            session,
            returnDocument: 'after' // Get account state after modification
          }
        );

        if (!toAccount.value) {
          throw new Error('Invalid destination account');
        }

        // Step 3: Create transaction record with detailed information
        const transactionRecord = {
          type: 'transfer',
          fromAccount: {
            id: fromAccountId,
            balanceBefore: fromAccount.value.balance,
            balanceAfter: fromAccount.value.balance - amount
          },
          toAccount: {
            id: toAccountId,
            balanceBefore: toAccount.value.balance - amount,
            balanceAfter: toAccount.value.balance
          },
          amount: amount,
          currency: fromAccount.value.currency || 'USD',
          timestamp: new Date(),
          status: 'completed',
          metadata: {
            ...metadata,
            ipAddress: metadata.clientIp,
            userAgent: metadata.userAgent,
            requestId: metadata.requestId
          },
          fees: {
            transferFee: 0, // Could be calculated based on business rules
            exchangeFee: 0
          },
          compliance: {
            amlChecked: true,
            fraudScore: metadata.fraudScore || 0,
            riskLevel: metadata.riskLevel || 'low'
          }
        };

        const transactionResult = await this.collections.transactions.insertOne(
          transactionRecord,
          { session }
        );

        // Step 4: Update account statistics atomically
        await Promise.all([
          this.collections.accountStats.updateOne(
            { accountId: fromAccountId },
            {
              $inc: { 
                totalDebits: amount,
                transactionCount: 1,
                outgoingTransferCount: 1
              },
              $set: { 
                lastActivity: new Date(),
                lastDebitAmount: amount
              },
              $push: {
                recentTransactions: {
                  $each: [transactionResult.insertedId],
                  $slice: -100 // Keep only last 100 transactions
                }
              }
            },
            { session, upsert: true }
          ),

          this.collections.accountStats.updateOne(
            { accountId: toAccountId },
            {
              $inc: { 
                totalCredits: amount,
                transactionCount: 1,
                incomingTransferCount: 1
              },
              $set: { 
                lastActivity: new Date(),
                lastCreditAmount: amount
              },
              $push: {
                recentTransactions: {
                  $each: [transactionResult.insertedId],
                  $slice: -100
                }
              }
            },
            { session, upsert: true }
          )
        ]);

        // Step 5: Create audit log entry
        await this.collections.auditLog.insertOne({
          eventType: 'funds_transfer',
          entityType: 'account',
          entities: [fromAccountId, toAccountId],
          transactionId: transactionResult.insertedId,
          changes: {
            fromAccount: {
              balanceChange: -amount,
              newBalance: fromAccount.value.balance - amount
            },
            toAccount: {
              balanceChange: amount,
              newBalance: toAccount.value.balance
            }
          },
          metadata: metadata,
          timestamp: new Date(),
          sessionId: session.id
        }, { session });

        // Step 6: Trigger notifications if required
        if (amount >= 1000 || metadata.notifyUsers) {
          await this.collections.notifications.insertMany([
            {
              userId: fromAccount.value.userId,
              type: 'debit_notification',
              title: 'Funds Transfer Sent',
              message: `$${amount} transferred to account ${toAccountId}`,
              amount: amount,
              relatedTransactionId: transactionResult.insertedId,
              createdAt: new Date(),
              status: 'pending',
              priority: amount >= 10000 ? 'high' : 'normal'
            },
            {
              userId: toAccount.value.userId,
              type: 'credit_notification',
              title: 'Funds Transfer Received',
              message: `$${amount} received from account ${fromAccountId}`,
              amount: amount,
              relatedTransactionId: transactionResult.insertedId,
              createdAt: new Date(),
              status: 'pending',
              priority: amount >= 10000 ? 'high' : 'normal'
            }
          ], { session });
        }

        // Return comprehensive transaction result
        return {
          success: true,
          transactionId: transactionResult.insertedId,
          fromAccount: {
            id: fromAccountId,
            previousBalance: fromAccount.value.balance,
            newBalance: fromAccount.value.balance - amount
          },
          toAccount: {
            id: toAccountId,
            previousBalance: toAccount.value.balance - amount,
            newBalance: toAccount.value.balance
          },
          amount: amount,
          timestamp: transactionRecord.timestamp,
          fees: transactionRecord.fees,
          metadata: transactionRecord.metadata
        };

      }, this.transactionConfig.financial);

      return result;

    } catch (error) {
      console.error('Transaction failed:', error.message);

      // All changes are automatically rolled back by MongoDB
      throw new Error(`Transfer failed: ${error.message}`);

    } finally {
      await session.endSession();
    }
  }

  async processComplexOrder(orderData) {
    const session = this.client.startSession();

    try {
      const result = await session.withTransaction(async () => {
        // Complex multi-collection atomic operation

        // Step 1: Validate customer and apply discounts
        const customer = await this.collections.customers.findOneAndUpdate(
          { _id: orderData.customerId, status: 'active' },
          {
            $inc: { orderCount: 1 },
            $set: { lastOrderDate: new Date() }
          },
          { session, returnDocument: 'after' }
        );

        if (!customer.value) {
          throw new Error('Invalid customer');
        }

        // Calculate dynamic pricing based on customer tier
        const discountRate = this.calculateCustomerDiscount(customer.value);
        const discountedTotal = orderData.subtotal * (1 - discountRate);

        // Step 2: Reserve inventory for all items atomically
        const inventoryUpdates = orderData.items.map(async (item) => {
          const inventoryResult = await this.collections.inventory.findOneAndUpdate(
            {
              productId: item.productId,
              quantity: { $gte: item.quantity },
              status: 'available'
            },
            {
              $inc: { 
                quantity: -item.quantity,
                reserved: item.quantity,
                totalSold: item.quantity
              },
              $set: { lastSaleDate: new Date() }
            },
            { session, returnDocument: 'after' }
          );

          if (!inventoryResult.value) {
            throw new Error(`Insufficient inventory for product ${item.productId}`);
          }

          return {
            productId: item.productId,
            quantityReserved: item.quantity,
            newAvailableQuantity: inventoryResult.value.quantity,
            unitPrice: item.unitPrice,
            totalPrice: item.unitPrice * item.quantity
          };
        });

        const reservedInventory = await Promise.all(inventoryUpdates);

        // Step 3: Create comprehensive order record
        const order = {
          _id: orderData.orderId || new ObjectId(),
          customerId: orderData.customerId,
          customerTier: customer.value.tier,
          items: reservedInventory,
          pricing: {
            subtotal: orderData.subtotal,
            discountRate: discountRate,
            discountAmount: orderData.subtotal - discountedTotal,
            total: discountedTotal,
            currency: 'USD'
          },
          fulfillment: {
            status: 'confirmed',
            expectedShipDate: this.calculateShipDate(orderData.shippingMethod),
            shippingMethod: orderData.shippingMethod,
            trackingNumber: null
          },
          payment: {
            method: orderData.paymentMethod,
            status: 'pending',
            processingFee: this.calculateProcessingFee(discountedTotal)
          },
          timestamps: {
            ordered: new Date(),
            confirmed: new Date()
          },
          metadata: orderData.metadata || {}
        };

        const orderResult = await this.collections.orders.insertOne(order, { session });

        // Step 4: Process payment transaction
        if (orderData.paymentMethod === 'account_balance') {
          await this.processAccountPayment(
            orderData.customerId, 
            discountedTotal, 
            orderResult.insertedId,
            session
          );
        }

        // Step 5: Update customer statistics
        await this.collections.customers.updateOne(
          { _id: orderData.customerId },
          {
            $inc: { 
              totalSpent: discountedTotal,
              loyaltyPoints: Math.floor(discountedTotal * 0.1)
            },
            $push: {
              orderHistory: {
                $each: [orderResult.insertedId],
                $slice: -50 // Keep last 50 orders
              }
            }
          },
          { session }
        );

        // Step 6: Create fulfillment tasks
        await this.collections.notifications.insertOne({
          type: 'fulfillment_task',
          orderId: orderResult.insertedId,
          items: reservedInventory,
          priority: customer.value.tier === 'premium' ? 'high' : 'normal',
          assignedTo: null,
          status: 'pending',
          createdAt: new Date()
        }, { session });

        return {
          success: true,
          orderId: orderResult.insertedId,
          customer: {
            id: customer.value._id,
            tier: customer.value.tier,
            newOrderCount: customer.value.orderCount
          },
          order: {
            total: discountedTotal,
            itemsReserved: reservedInventory.length,
            status: 'confirmed'
          },
          inventory: reservedInventory
        };

      }, this.transactionConfig.business);

      return result;

    } catch (error) {
      console.error('Order processing failed:', error.message);
      throw error;

    } finally {
      await session.endSession();
    }
  }

  async batchProcessTransactions(transactions, batchSize = 10) {
    // Process transactions in batches with individual transaction isolation
    const results = [];
    const errors = [];

    for (let i = 0; i < transactions.length; i += batchSize) {
      const batch = transactions.slice(i, i + batchSize);

      const batchPromises = batch.map(async (txn, index) => {
        try {
          const result = await this.executeTransactionByType(txn);
          return { index: i + index, success: true, result };
        } catch (error) {
          return { index: i + index, success: false, error: error.message, transaction: txn };
        }
      });

      const batchResults = await Promise.allSettled(batchPromises);

      batchResults.forEach((promiseResult, batchIndex) => {
        if (promiseResult.status === 'fulfilled') {
          const txnResult = promiseResult.value;
          if (txnResult.success) {
            results.push(txnResult);
          } else {
            errors.push(txnResult);
          }
        } else {
          errors.push({
            index: i + batchIndex,
            success: false,
            error: promiseResult.reason.message,
            transaction: batch[batchIndex]
          });
        }
      });
    }

    return {
      totalProcessed: transactions.length,
      successful: results.length,
      failed: errors.length,
      results: results,
      errors: errors,
      successRate: (results.length / transactions.length) * 100
    };
  }

  async executeTransactionByType(transaction) {
    switch (transaction.type) {
      case 'transfer':
        return await this.transferFunds(
          transaction.fromAccount,
          transaction.toAccount,
          transaction.amount,
          transaction.metadata
        );

      case 'order':
        return await this.processComplexOrder(transaction.orderData);

      case 'payment':
        return await this.processPayment(transaction.paymentData);

      default:
        throw new Error(`Unknown transaction type: ${transaction.type}`);
    }
  }

  // Helper methods for business logic
  calculateCustomerDiscount(customer) {
    const tierDiscounts = {
      'premium': 0.15,
      'gold': 0.10,
      'silver': 0.05,
      'bronze': 0.02,
      'standard': 0.0
    };

    const baseDiscount = tierDiscounts[customer.tier] || 0;
    const orderCountBonus = Math.min(customer.orderCount * 0.001, 0.05);

    return Math.min(baseDiscount + orderCountBonus, 0.25); // Cap at 25%
  }

  calculateShipDate(shippingMethod) {
    const shippingDays = {
      'overnight': 1,
      'express': 2,
      'standard': 5,
      'economy': 7
    };

    const days = shippingDays[shippingMethod] || 5;
    const shipDate = new Date();
    shipDate.setDate(shipDate.getDate() + days);

    return shipDate;
  }

  calculateProcessingFee(amount) {
    return Math.max(amount * 0.029, 0.30); // 2.9% + $0.30 minimum
  }

  async processAccountPayment(customerId, amount, orderId, session) {
    return await this.transferFunds(
      customerId, // Assuming customer accounts for simplicity
      'merchant_account_id',
      amount,
      { 
        orderId: orderId,
        paymentType: 'order_payment'
      }
    );
  }
}

// Benefits of MongoDB transactions:
// 1. Automatic rollback on any failure - no manual cleanup required
// 2. ACID compliance ensures data consistency across multiple collections
// 3. Isolation levels prevent dirty reads and phantom reads
// 4. Durability guarantees with configurable write concerns
// 5. Simplified error handling - all-or-nothing semantics
// 6. Built-in deadlock detection and resolution
// 7. Performance optimization with snapshot isolation
// 8. Cross-shard transactions in distributed deployments
// 9. Integration with replica sets for high availability
// 10. Familiar transaction patterns for SQL developers

// Advanced transaction patterns for complex distributed scenarios
class AdvancedTransactionPatterns {
  constructor(mongoClient) {
    this.client = mongoClient;
    this.db = mongoClient.db('enterprise_platform');
  }

  async executeNestedBusinessTransaction(businessOperation) {
    const session = this.client.startSession();

    try {
      const result = await session.withTransaction(async () => {
        // Nested transaction pattern with savepoints simulation
        const checkpoints = [];

        try {
          // Checkpoint 1: Customer validation and setup
          const customerValidation = await this.validateAndSetupCustomer(
            businessOperation.customerId, 
            session
          );
          checkpoints.push('customer_validation');

          // Checkpoint 2: Inventory allocation across multiple warehouses
          const inventoryAllocation = await this.allocateInventoryAcrossWarehouses(
            businessOperation.items,
            businessOperation.deliveryLocation,
            session
          );
          checkpoints.push('inventory_allocation');

          // Checkpoint 3: Financial authorization and holds
          const financialAuthorization = await this.authorizePaymentWithHolds(
            businessOperation.paymentDetails,
            inventoryAllocation.totalCost,
            session
          );
          checkpoints.push('financial_authorization');

          // Checkpoint 4: Complex business rules validation
          const businessRulesValidation = await this.validateComplexBusinessRules(
            customerValidation,
            inventoryAllocation,
            financialAuthorization,
            session
          );
          checkpoints.push('business_rules');

          // Checkpoint 5: Finalize all operations atomically
          const finalization = await this.finalizeBusinessOperation(
            businessOperation,
            {
              customer: customerValidation,
              inventory: inventoryAllocation,
              financial: financialAuthorization,
              rules: businessRulesValidation
            },
            session
          );

          return {
            success: true,
            businessOperationId: finalization.operationId,
            checkpointsCompleted: checkpoints,
            details: finalization
          };

        } catch (error) {
          // Enhanced error context with checkpoint information
          throw new Error(`Business transaction failed at ${checkpoints[checkpoints.length - 1] || 'initialization'}: ${error.message}`);
        }

      }, {
        readConcern: { level: 'snapshot' },
        writeConcern: { w: 'majority', j: true },
        maxCommitTimeMS: 30000 // Extended timeout for complex operations
      });

      return result;

    } finally {
      await session.endSession();
    }
  }

  async validateAndSetupCustomer(customerId, session) {
    // Customer validation with comprehensive business context
    const customer = await this.db.collection('customers').findOneAndUpdate(
      {
        _id: customerId,
        status: 'active',
        creditStatus: { $nin: ['suspended', 'blocked'] }
      },
      {
        $set: { lastActivityDate: new Date() },
        $inc: { transactionAttempts: 1 }
      },
      { session, returnDocument: 'after' }
    );

    if (!customer.value) {
      throw new Error('Customer validation failed');
    }

    // Check customer limits and restrictions
    const customerLimits = await this.db.collection('customer_limits').findOne(
      { customerId: customerId },
      { session }
    );

    const riskAssessment = await this.db.collection('risk_assessments').findOne(
      { customerId: customerId, status: 'active' },
      { session }
    );

    return {
      customer: customer.value,
      limits: customerLimits,
      riskProfile: riskAssessment,
      validated: true
    };
  }

  async allocateInventoryAcrossWarehouses(items, deliveryLocation, session) {
    // Complex inventory allocation across multiple warehouses
    const allocationResults = [];
    let totalCost = 0;

    for (const item of items) {
      // Find optimal warehouse allocation
      const warehouseAllocation = await this.db.collection('warehouse_inventory').aggregate([
        {
          $match: {
            productId: item.productId,
            availableQuantity: { $gte: item.requestedQuantity },
            status: 'active'
          }
        },
        {
          $addFields: {
            // Calculate shipping cost and delivery time
            shippingCost: {
              $multiply: [
                "$shippingRates.base",
                { $add: [1, "$shippingRates.distanceMultiplier"] }
              ]
            },
            estimatedDeliveryDays: {
              $ceil: { $divide: ["$distanceFromDelivery", 500] }
            }
          }
        },
        {
          $sort: {
            shippingCost: 1,
            estimatedDeliveryDays: 1,
            availableQuantity: -1
          }
        },
        { $limit: 1 }
      ], { session }).toArray();

      if (warehouseAllocation.length === 0) {
        throw new Error(`No suitable warehouse found for product ${item.productId}`);
      }

      const selectedWarehouse = warehouseAllocation[0];

      // Reserve inventory atomically
      const reservationResult = await this.db.collection('warehouse_inventory').findOneAndUpdate(
        {
          _id: selectedWarehouse._id,
          availableQuantity: { $gte: item.requestedQuantity }
        },
        {
          $inc: {
            availableQuantity: -item.requestedQuantity,
            reservedQuantity: item.requestedQuantity
          },
          $push: {
            reservations: {
              quantity: item.requestedQuantity,
              reservedAt: new Date(),
              expiresAt: new Date(Date.now() + 30 * 60 * 1000), // 30-minute expiry
              customerId: items.customerId
            }
          }
        },
        { session, returnDocument: 'after' }
      );

      if (!reservationResult.value) {
        throw new Error(`Failed to reserve inventory for product ${item.productId}`);
      }

      const itemCost = item.requestedQuantity * selectedWarehouse.unitPrice;
      totalCost += itemCost;

      allocationResults.push({
        productId: item.productId,
        warehouseId: selectedWarehouse.warehouseId,
        quantity: item.requestedQuantity,
        unitPrice: selectedWarehouse.unitPrice,
        totalPrice: itemCost,
        shippingCost: selectedWarehouse.shippingCost,
        estimatedDelivery: selectedWarehouse.estimatedDeliveryDays,
        reservationId: reservationResult.value.reservations[reservationResult.value.reservations.length - 1]
      });
    }

    return {
      allocations: allocationResults,
      totalCost: totalCost,
      warehousesInvolved: [...new Set(allocationResults.map(a => a.warehouseId))]
    };
  }

  async authorizePaymentWithHolds(paymentDetails, amount, session) {
    // Financial authorization with temporary holds
    const paymentMethod = await this.db.collection('payment_methods').findOne(
      {
        _id: paymentDetails.paymentMethodId,
        customerId: paymentDetails.customerId,
        status: 'active'
      },
      { session }
    );

    if (!paymentMethod) {
      throw new Error('Invalid payment method');
    }

    // Create payment authorization hold
    const authorizationHold = {
      customerId: paymentDetails.customerId,
      paymentMethodId: paymentDetails.paymentMethodId,
      amount: amount,
      currency: 'USD',
      authorizationCode: this.generateAuthorizationCode(),
      status: 'authorized',
      expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24-hour expiry
      createdAt: new Date()
    };

    const authResult = await this.db.collection('payment_authorizations').insertOne(
      authorizationHold,
      { session }
    );

    // Update customer available credit if applicable
    if (paymentMethod.type === 'credit_account') {
      await this.db.collection('credit_accounts').updateOne(
        {
          customerId: paymentDetails.customerId,
          availableCredit: { $gte: amount }
        },
        {
          $inc: {
            availableCredit: -amount,
            pendingCharges: amount
          }
        },
        { session }
      );
    }

    return {
      authorizationId: authResult.insertedId,
      authorizationCode: authorizationHold.authorizationCode,
      authorizedAmount: amount,
      expiresAt: authorizationHold.expiresAt,
      paymentMethod: paymentMethod.type
    };
  }

  async validateComplexBusinessRules(customer, inventory, financial, session) {
    // Complex business rules validation
    const businessRules = [];

    // Rule 1: Customer tier restrictions
    const tierRestrictions = await this.db.collection('tier_restrictions').findOne(
      { tier: customer.customer.tier },
      { session }
    );

    if (tierRestrictions && inventory.totalCost > tierRestrictions.maxOrderValue) {
      throw new Error(`Order exceeds maximum value for ${customer.customer.tier} tier`);
    }

    businessRules.push({
      rule: 'tier_restrictions',
      passed: true,
      details: `Order value ${inventory.totalCost} within limits for tier ${customer.customer.tier}`
    });

    // Rule 2: Geographic shipping restrictions
    const shippingRestrictions = await this.db.collection('shipping_restrictions').findOne(
      {
        countries: customer.customer.shippingAddress?.country,
        productCategories: { $in: inventory.allocations.map(a => a.productCategory) }
      },
      { session }
    );

    if (shippingRestrictions?.restricted) {
      throw new Error('Shipping restrictions apply to this order');
    }

    businessRules.push({
      rule: 'shipping_restrictions',
      passed: true,
      details: 'No shipping restrictions found'
    });

    // Rule 3: Fraud detection rules
    const fraudScore = await this.calculateFraudScore(customer, inventory, financial);

    if (fraudScore > 75) {
      throw new Error('Order flagged by fraud detection system');
    }

    businessRules.push({
      rule: 'fraud_detection',
      passed: true,
      details: `Fraud score: ${fraudScore}/100`
    });

    return {
      rulesValidated: businessRules,
      fraudScore: fraudScore,
      allRulesPassed: true
    };
  }

  async finalizeBusinessOperation(operation, validationResults, session) {
    // Create comprehensive business operation record
    const businessOperation = {
      operationType: operation.type,
      customerId: operation.customerId,

      customerDetails: validationResults.customer,
      inventoryAllocation: validationResults.inventory,
      financialAuthorization: validationResults.financial,
      businessRulesValidation: validationResults.rules,

      status: 'completed',
      timestamps: {
        initiated: operation.initiatedAt || new Date(),
        validated: new Date(),
        completed: new Date()
      },

      metadata: {
        requestId: operation.requestId,
        channel: operation.channel || 'api',
        userAgent: operation.userAgent,
        ipAddress: operation.ipAddress
      }
    };

    const operationResult = await this.db.collection('business_operations').insertOne(
      businessOperation,
      { session }
    );

    // Create audit trail
    await this.db.collection('audit_trail').insertOne({
      entityType: 'business_operation',
      entityId: operationResult.insertedId,
      action: 'completed',
      performedBy: operation.customerId,
      details: businessOperation,
      timestamp: new Date()
    }, { session });

    // Trigger post-transaction workflows
    await this.db.collection('workflow_triggers').insertOne({
      triggerType: 'business_operation_completed',
      operationId: operationResult.insertedId,
      workflowsToExecute: [
        'send_confirmation_email',
        'update_customer_analytics',
        'trigger_fulfillment_process',
        'update_inventory_forecasting'
      ],
      priority: 'normal',
      scheduledFor: new Date(),
      status: 'pending'
    }, { session });

    return {
      operationId: operationResult.insertedId,
      completedAt: new Date(),
      summary: {
        customer: validationResults.customer.customer.email,
        totalValue: validationResults.inventory.totalCost,
        itemsAllocated: validationResults.inventory.allocations.length,
        warehousesInvolved: validationResults.inventory.warehousesInvolved.length,
        authorizationCode: validationResults.financial.authorizationCode
      }
    };
  }

  generateAuthorizationCode() {
    return Math.random().toString(36).substr(2, 9).toUpperCase();
  }

  async calculateFraudScore(customer, inventory, financial) {
    // Simplified fraud scoring algorithm
    let score = 0;

    // Customer history factor
    if (customer.customer.orderCount < 5) score += 20;
    if (customer.customer.accountAge < 30) score += 15;

    // Order size factor
    if (inventory.totalCost > 1000) score += 10;
    if (inventory.totalCost > 5000) score += 20;

    // Geographic factor
    if (customer.customer.shippingAddress?.country !== customer.customer.billingAddress?.country) {
      score += 15;
    }

    // Payment method factor
    if (financial.paymentMethod === 'new_credit_card') score += 25;

    return Math.min(score, 100);
  }
}