Serverless API Architecture¶

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

const USERS_TABLE = process.env.DYNAMODB_TABLE;

// Helper function for responses
const response = (statusCode, body) => ({
  statusCode,
  headers: {
    'Content-Type': 'application/json',
    'Access-Control-Allow-Origin': '*',
  },
  body: JSON.stringify(body),
});

// GET /users
module.exports.getAll = async (event) => {
  try {
    const params = {
      TableName: USERS_TABLE,
      Limit: 100,
    };

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

    return response(200, {
      users: result.Items,
      count: result.Count,
    });
  } catch (error) {
    console.error('Error fetching users:', error);
    return response(500, { error: 'Could not fetch users' });
  }
};

// GET /users/{id}
module.exports.getOne = async (event) => {
  try {
    const { id } = event.pathParameters;

    const params = {
      TableName: USERS_TABLE,
      Key: { id },
    };

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

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

    return response(200, result.Item);
  } catch (error) {
    console.error('Error fetching user:', error);
    return response(500, { error: 'Could not fetch user' });
  }
};

// POST /users
module.exports.create = async (event) => {
  try {
    const data = JSON.parse(event.body);

    // Validation
    if (!data.email || !data.name) {
      return response(400, { error: 'Email and name are required' });
    }

    const user = {
      id: uuidv4(),
      email: data.email,
      name: data.name,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString(),
    };

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

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

    return response(201, user);
  } catch (error) {
    if (error.code === 'ConditionalCheckFailedException') {
      return response(409, { error: 'User already exists' });
    }
    console.error('Error creating user:', error);
    return response(500, { error: 'Could not create user' });
  }
};

// PUT /users/{id}
module.exports.update = async (event) => {
  try {
    const { id } = event.pathParameters;
    const data = JSON.parse(event.body);

    const params = {
      TableName: USERS_TABLE,
      Key: { id },
      UpdateExpression: 'SET #name = :name, updatedAt = :updatedAt',
      ExpressionAttributeNames: {
        '#name': 'name',
      },
      ExpressionAttributeValues: {
        ':name': data.name,
        ':updatedAt': new Date().toISOString(),
      },
      ReturnValues: 'ALL_NEW',
      ConditionExpression: 'attribute_exists(id)',
    };

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

    return response(200, result.Attributes);
  } catch (error) {
    if (error.code === 'ConditionalCheckFailedException') {
      return response(404, { error: 'User not found' });
    }
    console.error('Error updating user:', error);
    return response(500, { error: 'Could not update user' });
  }
};

// DELETE /users/{id}
module.exports.delete = async (event) => {
  try {
    const { id } = event.pathParameters;

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

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

    return response(204, {});
  } catch (error) {
    if (error.code === 'ConditionalCheckFailedException') {
      return response(404, { error: 'User not found' });
    }
    console.error('Error deleting user:', error);
    return response(500, { error: 'Could not delete user' });
  }
};

// Connection pooling for SQL databases
const mysql = require('mysql2/promise');

let connection = null;

const getConnection = async () => {
  if (connection) {
    return connection;
  }

  connection = await mysql.createConnection({
    host: process.env.RDS_PROXY_ENDPOINT,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    ssl: { rejectUnauthorized: false },
  });

  return connection;
};

module.exports.handler = async (event) => {
  const conn = await getConnection();
  const [rows] = await conn.execute('SELECT * FROM users');
  return {
    statusCode: 200,
    body: JSON.stringify(rows),
  };
};

// users/index.js
const { CosmosClient } = require('@azure/cosmos');

const endpoint = process.env.COSMOS_ENDPOINT;
const key = process.env.COSMOS_KEY;
const client = new CosmosClient({ endpoint, key });

const database = client.database('UsersDB');
const container = database.container('Users');

module.exports = async function (context, req) {
  context.log('Processing HTTP request');

  const method = req.method;
  const userId = context.bindingData.id;

  try {
    switch (method) {
      case 'GET':
        if (userId) {
          // Get specific user
          const { resource } = await container.item(userId, userId).read();
          if (!resource) {
            context.res = {
              status: 404,
              body: { error: 'User not found' },
            };
            return;
          }
          context.res = {
            status: 200,
            body: resource,
          };
        } else {
          // Get all users
          const { resources } = await container.items
            .query('SELECT * FROM c')
            .fetchAll();
          context.res = {
            status: 200,
            body: { users: resources, count: resources.length },
          };
        }
        break;

      case 'POST':
        const newUser = {
          id: require('uuid').v4(),
          email: req.body.email,
          name: req.body.name,
          createdAt: new Date().toISOString(),
        };

        await container.items.create(newUser);

        context.res = {
          status: 201,
          body: newUser,
        };
        break;

      case 'PUT':
        const { resource: existingUser } = await container
          .item(userId, userId)
          .read();

        if (!existingUser) {
          context.res = {
            status: 404,
            body: { error: 'User not found' },
          };
          return;
        }

        const updatedUser = {
          ...existingUser,
          ...req.body,
          updatedAt: new Date().toISOString(),
        };

        await container.item(userId, userId).replace(updatedUser);

        context.res = {
          status: 200,
          body: updatedUser,
        };
        break;

      case 'DELETE':
        await container.item(userId, userId).delete();
        context.res = {
          status: 204,
        };
        break;

      default:
        context.res = {
          status: 405,
          body: { error: 'Method not allowed' },
        };
    }
  } catch (error) {
    context.log.error('Error:', error);
    context.res = {
      status: 500,
      body: { error: 'Internal server error' },
    };
  }
};

// functions/users/index.js
const { Firestore } = require('@google-cloud/firestore');
const firestore = new Firestore();
const USERS_COLLECTION = 'users';

exports.getUsers = async (req, res) => {
  try {
    const snapshot = await firestore.collection(USERS_COLLECTION).get();
    const users = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));

    res.status(200).json({
      users,
      count: users.length,
    });
  } catch (error) {
    console.error('Error fetching users:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

exports.getUser = async (req, res) => {
  try {
    const { id } = req.params;
    const doc = await firestore.collection(USERS_COLLECTION).doc(id).get();

    if (!doc.exists) {
      res.status(404).json({ error: 'User not found' });
      return;
    }

    res.status(200).json({ id: doc.id, ...doc.data() });
  } catch (error) {
    console.error('Error fetching user:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

exports.createUser = async (req, res) => {
  try {
    const { email, name } = req.body;

    if (!email || !name) {
      res.status(400).json({ error: 'Email and name are required' });
      return;
    }

    const user = {
      email,
      name,
      createdAt: new Date().toISOString(),
    };

    const docRef = await firestore.collection(USERS_COLLECTION).add(user);

    res.status(201).json({ id: docRef.id, ...user });
  } catch (error) {
    console.error('Error creating user:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

exports.updateUser = async (req, res) => {
  try {
    const { id } = req.params;
    const updates = req.body;

    const docRef = firestore.collection(USERS_COLLECTION).doc(id);
    const doc = await docRef.get();

    if (!doc.exists) {
      res.status(404).json({ error: 'User not found' });
      return;
    }

    await docRef.update({
      ...updates,
      updatedAt: new Date().toISOString(),
    });

    const updated = await docRef.get();
    res.status(200).json({ id: updated.id, ...updated.data() });
  } catch (error) {
    console.error('Error updating user:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

exports.deleteUser = async (req, res) => {
  try {
    const { id } = req.params;
    const docRef = firestore.collection(USERS_COLLECTION).doc(id);
    const doc = await docRef.get();

    if (!doc.exists) {
      res.status(404).json({ error: 'User not found' });
      return;
    }

    await docRef.delete();
    res.status(204).send();
  } catch (error) {
    console.error('Error deleting user:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

const jwt = require('jsonwebtoken');

const verifyToken = (token) => {
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    return decoded;
  } catch (error) {
    throw new Error('Invalid token');
  }
};

module.exports.handler = async (event) => {
  try {
    const token = event.headers.Authorization.replace('Bearer ', '');
    const user = verifyToken(token);

    // User authenticated, proceed with request
    // ...
  } catch (error) {
    return {
      statusCode: 401,
      body: JSON.stringify({ error: 'Unauthorized' }),
    };
  }
};

const Joi = require('joi');

const userSchema = Joi.object({
  email: Joi.string().email().required(),
  name: Joi.string().min(2).max(50).required(),
  age: Joi.number().integer().min(18).max(120).optional(),
});

module.exports.createUser = async (event) => {
  try {
    const body = JSON.parse(event.body);

    const { error, value } = userSchema.validate(body);
    if (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({ error: error.details[0].message }),
      };
    }

    // Proceed with validated data
    // ...
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'Invalid request body' }),
    };
  }
};

const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

const rateLimit = async (userId, limit = 100, window = 60) => {
  const key = `rate_limit:${userId}`;
  const current = await redis.incr(key);

  if (current === 1) {
    await redis.expire(key, window);
  }

  if (current > limit) {
    throw new Error('Rate limit exceeded');
  }

  return current;
};

module.exports.handler = async (event) => {
  const userId = event.requestContext.authorizer.userId;

  try {
    await rateLimit(userId);
    // Process request
  } catch (error) {
    return {
      statusCode: 429,
      body: JSON.stringify({ error: 'Too many requests' }),
    };
  }
};

const corsHeaders = {
  'Access-Control-Allow-Origin': process.env.ALLOWED_ORIGIN || '*',
  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type, Authorization',
  'Access-Control-Max-Age': '86400',
};

module.exports.handler = async (event) => {
  // Handle preflight requests
  if (event.httpMethod === 'OPTIONS') {
    return {
      statusCode: 200,
      headers: corsHeaders,
      body: '',
    };
  }

  // Process actual request
  return {
    statusCode: 200,
    headers: {
      ...corsHeaders,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ message: 'Success' }),
  };
};

const AWS = require('aws-sdk');
const secretsManager = new AWS.SecretsManager();

let cachedSecret = null;

const getSecret = async (secretName) => {
  if (cachedSecret) {
    return cachedSecret;
  }

  const data = await secretsManager
    .getSecretValue({ SecretId: secretName })
    .promise();

  cachedSecret = JSON.parse(data.SecretString);
  return cachedSecret;
};

module.exports.handler = async (event) => {
  const dbCredentials = await getSecret('prod/db/credentials');
  // Use credentials
};

// warmer.js
module.exports.warm = async (event) => {
  if (event.source === 'serverless-plugin-warmup') {
    console.log('Warming function');
    return 'Lambda is warm';
  }
  // Regular function logic
};

// Reuse connections across invocations
let connection = null;

const getConnection = async () => {
  if (connection && connection.isConnected()) {
    return connection;
  }

  connection = await createDatabaseConnection();
  return connection;
};

module.exports.handler = async (event) => {
  const conn = await getConnection();
  // Use connection
};

const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

const getCachedOrFetch = async (key, fetchFn, ttl = 300) => {
  const cached = await redis.get(key);
  if (cached) {
    return JSON.parse(cached);
  }

  const data = await fetchFn();
  await redis.setex(key, ttl, JSON.stringify(data));
  return data;
};

module.exports.getUser = async (event) => {
  const userId = event.pathParameters.id;

  const user = await getCachedOrFetch(
    `user:${userId}`,
    () => fetchUserFromDatabase(userId),
    600 // 10 minutes TTL
  );

  return {
    statusCode: 200,
    body: JSON.stringify(user),
  };
};

// API handler - responds quickly
module.exports.submitJob = async (event) => {
  const jobId = generateJobId();
  const data = JSON.parse(event.body);

  // Send to queue for processing
  await sqsClient.sendMessage({
    QueueUrl: process.env.PROCESSING_QUEUE_URL,
    MessageBody: JSON.stringify({ jobId, data }),
  }).promise();

  return {
    statusCode: 202,
    body: JSON.stringify({ jobId, status: 'processing' }),
  };
};

// Background processor
module.exports.processJob = async (event) => {
  for (const record of event.Records) {
    const { jobId, data } = JSON.parse(record.body);

    // Long-running processing
    await processData(data);

    // Update job status
    await updateJobStatus(jobId, 'completed');
  }
};

// Process multiple items efficiently
module.exports.processBatch = async (event) => {
  const items = event.Records.map(r => JSON.parse(r.body));

  // Batch database writes
  const batchWrite = {
    RequestItems: {
      [TABLE_NAME]: items.map(item => ({
        PutRequest: { Item: item },
      })),
    },
  };

  await dynamodb.batchWrite(batchWrite).promise();
};

// users.test.js
const { getUser } = require('../functions/users');

describe('getUser', () => {
  it('should return user by ID', async () => {
    const event = {
      pathParameters: { id: '123' },
    };

    const result = await getUser(event);

    expect(result.statusCode).toBe(200);
    expect(JSON.parse(result.body)).toHaveProperty('id', '123');
  });

  it('should return 404 for non-existent user', async () => {
    const event = {
      pathParameters: { id: 'non-existent' },
    };

    const result = await getUser(event);

    expect(result.statusCode).toBe(404);
  });
});

// Structured logging
const log = (level, message, metadata = {}) => {
  console.log(JSON.stringify({
    timestamp: new Date().toISOString(),
    level,
    message,
    ...metadata,
    requestId: context.requestId,
  }));
};

log('info', 'Processing user request', { userId: '123' });
log('error', 'Database connection failed', { error: err.message });