How to fix TransactionCanceledException: Transaction cancelled in DynamoDB

try {
  await dynamodb.transactWriteItems(params).promise();
} catch (error) {
  if (error.name === 'TransactionCanceledException') {
    console.log('Transaction cancelled. Reasons:', error.CancellationReasons);

    // Example CancellationReasons structure:
    // [
    //   { Code: 'ConditionCheckFailed', Message: 'The conditional request failed' },
    //   { Code: 'None', Message: null }, // This item would have succeeded
    //   { Code: 'ThrottlingError', Message: 'Rate exceeded' }
    // ]

    // Identify which items failed and why
    error.CancellationReasons.forEach((reason, index) => {
      if (reason.Code !== 'None') {
        console.log(`Item ${index} failed: ${reason.Code} - ${reason.Message}`);
      }
    });
  }
}

// Problematic condition that might fail
const params = {
  TransactItems: [
    {
      Update: {
        TableName: 'Orders',
        Key: { orderId: '123' },
        UpdateExpression: 'SET #status = :newStatus',
        ConditionExpression: '#status = :expectedStatus',
        ExpressionAttributeNames: { '#status': 'status' },
        ExpressionAttributeValues: {
          ':newStatus': 'SHIPPED',
          ':expectedStatus': 'PROCESSING' // Might not match current value
        }
      }
    }
  ]
};

// Solution: Check current state before transaction or use more flexible conditions
// Option 1: Fetch current state first
const currentItem = await dynamodb.getItem({
  TableName: 'Orders',
  Key: { orderId: '123' }
}).promise();

// Option 2: Use attribute_exists or attribute_not_exists for existence checks
const saferParams = {
  TransactItems: [
    {
      Update: {
        TableName: 'Orders',
        Key: { orderId: '123' },
        UpdateExpression: 'SET #status = :newStatus',
        ConditionExpression: 'attribute_exists(orderId)', // Less restrictive
        ExpressionAttributeNames: { '#status': 'status' },
        ExpressionAttributeValues: { ':newStatus': 'SHIPPED' }
      }
    }
  ]
};

async function executeTransactionWithRetry(params, maxRetries = 3) {
  let retryCount = 0;

  while (retryCount < maxRetries) {
    try {
      return await dynamodb.transactWriteItems(params).promise();
    } catch (error) {
      if (error.name === 'TransactionCanceledException') {
        const hasConflict = error.CancellationReasons?.some(
          reason => reason.Code === 'TransactionConflict'
        );

        if (hasConflict && retryCount < maxRetries) {
          retryCount++;
          const delay = Math.min(1000, 50 * Math.pow(2, retryCount)); // Exponential backoff
          const jitter = delay * 0.1 * Math.random(); // Add jitter
          await new Promise(resolve => setTimeout(resolve, delay + jitter));
          continue;
        }
      }
      throw error; // Re-throw if not a conflict or retries exhausted
    }
  }

  throw new Error('Max retries exceeded for transaction');
}

// Use ClientRequestToken for idempotent retries
const transactionParams = {
  TransactItems: [
    { Put: { TableName: 'Table1', Item: item1 } },
    { Update: { TableName: 'Table2', Key: key2, UpdateExpression: 'SET #count = #count + :inc' } }
  ],
  ClientRequestToken: 'unique-id-' + Date.now() // Ensures idempotent retries
};

await executeTransactionWithRetry(transactionParams);

# Check current provisioned capacity
aws dynamodb describe-table --table-name YourTableName

# Increase provisioned capacity if consistently throttled
aws dynamodb update-table   --table-name YourTableName   --provisioned-throughput     'ReadCapacityUnits=200,WriteCapacityUnits=100'

# For on-demand tables hitting account limits, request limit increase
aws service-quotas request-service-quota-increase   --service-code dynamodb   --quota-code L-12345678   --desired-value 40000

// Common validation issues:
// 1. Item size exceeds 400KB limit
// 2. Attribute value exceeds 400KB limit
// 3. Invalid data type for attribute
// 4. Reserved keyword used without expression attributes

// Validate item size before transaction
function getItemSizeBytes(item) {
  return Buffer.byteLength(JSON.stringify(item), 'utf8');
}

const item1Size = getItemSizeBytes(item1);
const item2Size = getItemSizeBytes(item2);

if (item1Size > 400 * 1024 || item2Size > 400 * 1024) {
  console.error('Item exceeds 400KB limit');
  // Implement compression or split into multiple items
}

// Check for reserved keywords
const params = {
  TransactItems: [
    {
      Put: {
        TableName: 'Users',
        Item: {
          userId: '123',
          name: 'John',
          // 'status' is a reserved keyword - need expression attributes
          '#status': 'active' // WRONG - will cause validation error
        }
      }
    }
  ]
};

// Correct approach with expression attributes
const correctParams = {
  TransactItems: [
    {
      Put: {
        TableName: 'Users',
        Item: {
          userId: '123',
          name: 'John',
          status: 'active' // OK - not using reserved keyword as attribute name
        }
      }
    }
  ]
};

# Monitor transaction metrics in CloudWatch
aws cloudwatch get-metric-statistics   --namespace "AWS/DynamoDB"   --metric-name "TransactionConflict"   --dimensions Name=TableName,Value=YourTableName   --statistics Sum   --start-time "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)"   --end-time "$(date -u +%Y-%m-%dT%H:%M:%SZ)"   --period 300

# Check UserErrors for validation issues
aws cloudwatch get-metric-statistics   --namespace "AWS/DynamoDB"   --metric-name "UserErrors"   --dimensions Name=TableName,Value=YourTableName   --statistics Sum   --start-time "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ)"   --end-time "$(date -u +%Y-%m-%dT%H:%M:%SZ)"   --period 300