How to fix EXEC returns null - WATCH key modified, optimistic lock failed in Redis

# In one Redis client, watch a key and start a transaction
redis-cli
WATCH mykey
GET mykey
MULTI
SET mykey "new-value"
# Don't run EXEC yet

# In a second Redis client, modify the watched key
redis-cli SET mykey "modified-by-client-2"

# Back in the first client, run EXEC
EXEC
# Returns: (nil) because mykey was modified

// Node.js with node-redis or ioredis
async function incrementCounter(client, key, maxRetries = 10) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      await client.watch(key);
      
      // Read current value
      const current = await client.get(key);
      const newValue = (parseInt(current || '0', 10) + 1).toString();
      
      // Execute transaction
      const multi = client.multi();
      multi.set(key, newValue);
      const results = await multi.exec();
      
      // Check for null (transaction aborted)
      if (results === null) {
        console.log(`Attempt ${attempt + 1} failed, retrying...`);
        continue;
      }
      
      // Success
      console.log(`Transaction succeeded on attempt ${attempt + 1}`);
      return newValue;
    } catch (err) {
      await client.unwatch();
      throw err;
    }
  }
  
  throw new Error(`Transaction failed after ${maxRetries} attempts`);
}

async function incrementWithBackoff(client, key, maxRetries = 10) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    await client.watch(key);
    
    const current = await client.get(key);
    const newValue = (parseInt(current || '0', 10) + 1).toString();
    
    const multi = client.multi();
    multi.set(key, newValue);
    const results = await multi.exec();
    
    if (results !== null) {
      return newValue;
    }
    
    // Exponential backoff: 2^attempt ms, max 100ms
    const delay = Math.min(Math.pow(2, attempt), 100);
    await new Promise(resolve => setTimeout(resolve, delay));
  }
  
  throw new Error('Max retries exceeded');
}

-- Increment counter atomically (increment.lua)
local current = redis.call('GET', KEYS[1]) or '0'
local newValue = tostring(tonumber(current) + 1)
redis.call('SET', KEYS[1], newValue)
return newValue

// Execute the Lua script
const result = await client.eval(
  fs.readFileSync('./increment.lua', 'utf8'),
  1,
  'mycounter'
);

// Shard counter across multiple keys
async function incrementShardedCounter(client, baseKey, numShards = 10) {
  const shard = Math.floor(Math.random() * numShards);
  const shardKey = `${baseKey}:shard:${shard}`;
  
  // Simple INCR, no WATCH needed for single key operations
  return await client.incr(shardKey);
}

// Read total count by summing all shards
async function getTotalCount(client, baseKey, numShards = 10) {
  const pipeline = client.pipeline();
  for (let i = 0; i < numShards; i++) {
    pipeline.get(`${baseKey}:shard:${i}`);
  }
  const results = await pipeline.exec();
  return results.reduce((sum, [err, val]) => sum + parseInt(val || '0', 10), 0);
}