Multi-Region Data Consistency System

import { DynamoDBClient, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';

interface EventRecord {
  eventId: string;
  version: number;
  timestamp: string;
  status: string;
  data: Record<string, any>;
}

export async function processEventWithVersionControl(
  eventId: string,
  updateData: Record<string, any>,
  expectedVersion: number
): Promise<EventRecord> {
  const client = new DynamoDBClient({ region: process.env.AWS_REGION });
  
  try {
    const command = new UpdateItemCommand({
      TableName: process.env.EVENTS_TABLE_NAME,
      Key: marshall({ eventId }),
      UpdateExpression: 'SET #data = :data, #version = :newVersion, #updatedAt = :updatedAt',
      ConditionExpression: '#version = :expectedVersion',
      ExpressionAttributeNames: {
        '#data': 'data',
        '#version': 'version',
        '#updatedAt': 'updatedAt'
      },
      ExpressionAttributeValues: marshall({
        ':data': updateData,
        ':newVersion': expectedVersion + 1,
        ':expectedVersion': expectedVersion,
        ':updatedAt': new Date().toISOString()
      }),
      ReturnValues: 'ALL_NEW'
    });

    const response = await client.send(command);
    return unmarshall(response.Attributes!) as EventRecord;
    
  } catch (error: any) {
    if (error.name === 'ConditionalCheckFailedException') {
      throw new Error(`Concurrent modification detected for event ${eventId}`);
    }
    throw error;
  }
}

import { DynamoDBClient, PutItemCommand, GetItemCommand } from '@aws-sdk/client-dynamodb';
import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
import * as crypto from 'crypto';

const IDEMPOTENCY_TTL_HOURS = 24;

export async function checkIdempotency(
  eventData: Record<string, any>
): Promise<{ isProcessed: boolean; result?: any }> {
  const client = new DynamoDBClient({ region: process.env.AWS_REGION });
  
  const token = crypto
    .createHash('sha256')
    .update(JSON.stringify(eventData))
    .digest('hex');
  
  const tableName = process.env.IDEMPOTENCY_TABLE_NAME!;
  
  try {
    const getCommand = new GetItemCommand({
      TableName: tableName,
      Key: marshall({ idempotencyToken: token })
    });
    
    const existingRecord = await client.send(getCommand);
    
    if (existingRecord.Item) {
      const record = unmarshall(existingRecord.Item);
      console.log(`Event already processed: ${token}`);
      return { isProcessed: true, result: record.result };
    }
    
    return { isProcessed: false };
    
  } catch (error) {
    console.error('Error checking idempotency:', error);
    throw error;
  }
}