Comprehensive comparison for DevOps technology in Software Development applications

// amplify/backend/function/productAPI/src/index.js
// Production-grade AWS Amplify Lambda function for product management
// Implements CRUD operations with DynamoDB, error handling, and validation

const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
const { v4: uuidv4 } = require('uuid');

const TABLE_NAME = process.env.PRODUCT_TABLE_NAME;
const CORS_HEADERS = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Headers': 'Content-Type,X-Amz-Date,Authorization,X-Api-Key',
  'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS'
};

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

  try {
    const httpMethod = event.httpMethod;
    const path = event.path;

    // Handle CORS preflight
    if (httpMethod === 'OPTIONS') {
      return buildResponse(200, {});
    }

    // Route handling
    switch (httpMethod) {
      case 'GET':
        return await handleGet(event);
      case 'POST':
        return await handlePost(event);
      case 'PUT':
        return await handlePut(event);
      case 'DELETE':
        return await handleDelete(event);
      default:
        return buildResponse(405, { error: 'Method not allowed' });
    }
  } catch (error) {
    console.error('Error:', error);
    return buildResponse(500, { error: 'Internal server error', message: error.message });
  }
};

async function handleGet(event) {
  const productId = event.pathParameters?.id;

  if (productId) {
    // Get single product
    const params = {
      TableName: TABLE_NAME,
      Key: { id: productId }
    };
    const result = await dynamodb.get(params).promise();
    
    if (!result.Item) {
      return buildResponse(404, { error: 'Product not found' });
    }
    return buildResponse(200, result.Item);
  } else {
    // List all products with pagination
    const limit = event.queryStringParameters?.limit || 20;
    const params = {
      TableName: TABLE_NAME,
      Limit: parseInt(limit)
    };
    
    if (event.queryStringParameters?.lastKey) {
      params.ExclusiveStartKey = JSON.parse(decodeURIComponent(event.queryStringParameters.lastKey));
    }
    
    const result = await dynamodb.scan(params).promise();
    return buildResponse(200, {
      items: result.Items,
      lastKey: result.LastEvaluatedKey ? encodeURIComponent(JSON.stringify(result.LastEvaluatedKey)) : null
    });
  }
}

async function handlePost(event) {
  const body = JSON.parse(event.body);
  
  // Validation
  if (!body.name || !body.price) {
    return buildResponse(400, { error: 'Missing required fields: name and price' });
  }
  
  if (typeof body.price !== 'number' || body.price < 0) {
    return buildResponse(400, { error: 'Invalid price value' });
  }

  const product = {
    id: uuidv4(),
    name: body.name,
    description: body.description || '',
    price: body.price,
    category: body.category || 'general',
    stock: body.stock || 0,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString()
  };

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

  await dynamodb.put(params).promise();
  return buildResponse(201, product);
}

async function handlePut(event) {
  const productId = event.pathParameters?.id;
  if (!productId) {
    return buildResponse(400, { error: 'Product ID required' });
  }

  const body = JSON.parse(event.body);
  const updateExpression = [];
  const expressionAttributeNames = {};
  const expressionAttributeValues = {};

  // Build dynamic update expression
  const allowedFields = ['name', 'description', 'price', 'category', 'stock'];
  allowedFields.forEach(field => {
    if (body[field] !== undefined) {
      updateExpression.push(`#${field} = :${field}`);
      expressionAttributeNames[`#${field}`] = field;
      expressionAttributeValues[`:${field}`] = body[field];
    }
  });

  if (updateExpression.length === 0) {
    return buildResponse(400, { error: 'No valid fields to update' });
  }

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

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

  try {
    const result = await dynamodb.update(params).promise();
    return buildResponse(200, result.Attributes);
  } catch (error) {
    if (error.code === 'ConditionalCheckFailedException') {
      return buildResponse(404, { error: 'Product not found' });
    }
    throw error;
  }
}

async function handleDelete(event) {
  const productId = event.pathParameters?.id;
  if (!productId) {
    return buildResponse(400, { error: 'Product ID required' });
  }

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

  try {
    await dynamodb.delete(params).promise();
    return buildResponse(200, { message: 'Product deleted successfully' });
  } catch (error) {
    if (error.code === 'ConditionalCheckFailedException') {
      return buildResponse(404, { error: 'Product not found' });
    }
    throw error;
  }
}

function buildResponse(statusCode, body) {
  return {
    statusCode,
    headers: CORS_HEADERS,
    body: JSON.stringify(body)
  };
}