Comprehensive comparison for technology in applications

const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
const sns = new AWS.SNS();

const TABLE_NAME = process.env.PRODUCTS_TABLE;
const SNS_TOPIC_ARN = process.env.NOTIFICATION_TOPIC_ARN;

exports.handler = async (event) => {
  console.log('Event received:', JSON.stringify(event, null, 2));

  try {
    const httpMethod = event.httpMethod;
    const pathParameters = event.pathParameters || {};
    const body = event.body ? JSON.parse(event.body) : {};

    let response;

    switch (httpMethod) {
      case 'GET':
        response = await getProduct(pathParameters.productId);
        break;
      case 'POST':
        response = await createProduct(body);
        break;
      case 'PUT':
        response = await updateProduct(pathParameters.productId, body);
        break;
      case 'DELETE':
        response = await deleteProduct(pathParameters.productId);
        break;
      default:
        return buildResponse(405, { message: 'Method not allowed' });
    }

    return buildResponse(200, response);
  } catch (error) {
    console.error('Error processing request:', error);
    return buildResponse(error.statusCode || 500, {
      message: error.message || 'Internal server error'
    });
  }
};

async function getProduct(productId) {
  if (!productId) {
    throw { statusCode: 400, message: 'Product ID is required' };
  }

  const params = {
    TableName: TABLE_NAME,
    Key: { productId }
  };

  const result = await dynamodb.get(params).promise();

  if (!result.Item) {
    throw { statusCode: 404, message: 'Product not found' };
  }

  return result.Item;
}

async function createProduct(data) {
  const { name, price, category } = data;

  if (!name || !price || !category) {
    throw { statusCode: 400, message: 'Name, price, and category are required' };
  }

  const productId = `prod-${Date.now()}`;
  const timestamp = new Date().toISOString();

  const product = {
    productId,
    name,
    price: parseFloat(price),
    category,
    createdAt: timestamp,
    updatedAt: timestamp
  };

  const params = {
    TableName: TABLE_NAME,
    Item: product,
    ConditionExpression: 'attribute_not_exists(productId)'
  };

  await dynamodb.put(params).promise();

  await notifyProductChange('CREATED', product);

  return product;
}

async function updateProduct(productId, data) {
  if (!productId) {
    throw { statusCode: 400, message: 'Product ID is required' };
  }

  const updateExpressions = [];
  const expressionAttributeNames = {};
  const expressionAttributeValues = {};

  if (data.name) {
    updateExpressions.push('#name = :name');
    expressionAttributeNames['#name'] = 'name';
    expressionAttributeValues[':name'] = data.name;
  }

  if (data.price) {
    updateExpressions.push('#price = :price');
    expressionAttributeNames['#price'] = 'price';
    expressionAttributeValues[':price'] = parseFloat(data.price);
  }

  if (data.category) {
    updateExpressions.push('#category = :category');
    expressionAttributeNames['#category'] = 'category';
    expressionAttributeValues[':category'] = data.category;
  }

  updateExpressions.push('#updatedAt = :updatedAt');
  expressionAttributeNames['#updatedAt'] = 'updatedAt';
  expressionAttributeValues[':updatedAt'] = new Date().toISOString();

  const params = {
    TableName: TABLE_NAME,
    Key: { productId },
    UpdateExpression: 'SET ' + updateExpressions.join(', '),
    ExpressionAttributeNames: expressionAttributeNames,
    ExpressionAttributeValues: expressionAttributeValues,
    ConditionExpression: 'attribute_exists(productId)',
    ReturnValues: 'ALL_NEW'
  };

  const result = await dynamodb.update(params).promise();

  await notifyProductChange('UPDATED', result.Attributes);

  return result.Attributes;
}

async function deleteProduct(productId) {
  if (!productId) {
    throw { statusCode: 400, message: 'Product ID is required' };
  }

  const params = {
    TableName: TABLE_NAME,
    Key: { productId },
    ConditionExpression: 'attribute_exists(productId)',
    ReturnValues: 'ALL_OLD'
  };

  const result = await dynamodb.delete(params).promise();

  await notifyProductChange('DELETED', result.Attributes);

  return { message: 'Product deleted successfully', productId };
}

async function notifyProductChange(action, product) {
  if (!SNS_TOPIC_ARN) return;

  const params = {
    TopicArn: SNS_TOPIC_ARN,
    Message: JSON.stringify({ action, product }),
    Subject: `Product ${action}: ${product.name || product.productId}`
  };

  await sns.publish(params).promise();
}

function buildResponse(statusCode, body) {
  return {
    statusCode,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*',
      'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS'
    },
    body: JSON.stringify(body)
  };
}