AWS Lambda: Serverless Functions — Triggers, Layers, Cold Starts & API Gateway

// Lambda: Full REST API handler dengan routing
const AWS = require('aws-sdk');
const dynamodb = new AWS.DynamoDB.DocumentClient();
const TABLE_NAME = process.env.TABLE_NAME || 'users';

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

    const { httpMethod, path, pathParameters, queryStringParameters, body } = event;
    const userId = pathParameters?.userId;

    try {
        // Simple router
        switch (httpMethod) {
            case 'GET':
                if (userId) {
                    return await getUser(userId);
                }
                return await listUsers(queryStringParameters);

            case 'POST':
                return await createUser(JSON.parse(body));

            case 'PUT':
                return await updateUser(userId, JSON.parse(body));

            case 'DELETE':
                return await deleteUser(userId);

            default:
                return response(405, { error: 'Method not allowed' });
        }
    } catch (error) {
        console.error('Error:', error);
        return response(500, { error: 'Internal server error' });
    }
};

// Helper: Format response
function response(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)
    };
}

// CRUD Operations
async function getUser(userId) {
    const result = await dynamodb.get({
        TableName: TABLE_NAME,
        Key: { userId }
    }).promise();

    if (!result.Item) {
        return response(404, { error: 'User not found' });
    }
    return response(200, result.Item);
}

async function listUsers(queryParams) {
    const limit = parseInt(queryParams?.limit) || 20;
    const params = {
        TableName: TABLE_NAME,
        Limit: limit
    };

    // Pagination
    if (queryParams?.lastKey) {
        params.ExclusiveStartKey = JSON.parse(
            Buffer.from(queryParams.lastKey, 'base64').toString()
        );
    }

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

    return response(200, {
        items: result.Items,
        count: result.Count,
        lastKey: result.LastEvaluatedKey
            ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString('base64')
            : null
    });
}

async function createUser(data) {
    const user = {
        userId: data.userId || AWS.util.uuid.v4(),
        name: data.name,
        email: data.email,
        createdAt: new Date().toISOString()
    };

    await dynamodb.put({
        TableName: TABLE_NAME,
        Item: user,
        ConditionExpression: 'attribute_not_exists(userId)'
    }).promise();

    return response(201, user);
}

async function updateUser(userId, data) {
    const result = await dynamodb.update({
        TableName: TABLE_NAME,
        Key: { userId },
        UpdateExpression: 'SET #name = :name, email = :email, updatedAt = :now',
        ExpressionAttributeNames: { '#name': 'name' },
        ExpressionAttributeValues: {
            ':name': data.name,
            ':email': data.email,
            ':now': new Date().toISOString()
        },
        ReturnValues: 'ALL_NEW'
    }).promise();

    return response(200, result.Attributes);
}

async function deleteUser(userId) {
    await dynamodb.delete({
        TableName: TABLE_NAME,
        Key: { userId }
    }).promise();

    return response(204, null);
}