Serverless Basics

mkdir lambda-api && cd lambda-api
npm init -y
npm pkg set type=module
npm install @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb
npm install -D typescript@5.6 esbuild @types/aws-lambda @types/node

import type { APIGatewayProxyHandlerV2 } from "aws-lambda";
 
export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  return {
    statusCode: 200,
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ message: "hello", requestId: event.requestContext.requestId }),
  };
};

import type { APIGatewayProxyHandlerV2 } from "aws-lambda";
 
export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  if (!event.body) {
    return { statusCode: 400, body: JSON.stringify({ error: "missing body" }) };
  }
 
  const payload = JSON.parse(event.body) as { name?: string };
  if (!payload.name) {
    return { statusCode: 422, body: JSON.stringify({ error: "name required" }) };
  }
 
  return { statusCode: 201, body: JSON.stringify({ id: "1", name: payload.name }) };
};

import { z } from "zod";
 
const envSchema = z.object({
  TABLE_NAME: z.string().min(1),
  NODE_ENV: z.enum(["development", "production", "test"]).default("production"),
});
 
const env = envSchema.parse(process.env);
 
export function getTableName() {
  return env.TABLE_NAME;
}

import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
import type { APIGatewayProxyHandlerV2 } from "aws-lambda";
 
const client = DynamoDBDocumentClient.from(new DynamoDBClient({}));
 
export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  const id = event.pathParameters?.id;
  const res = await client.send(
    new GetCommand({ TableName: process.env.TABLE_NAME!, Key: { id } })
  );
  if (!res.Item) {
    return { statusCode: 404, body: JSON.stringify({ error: "not found" }) };
  }
  return { statusCode: 200, body: JSON.stringify(res.Item) };
};

import type { SQSHandler } from "aws-lambda";
 
export const handler: SQSHandler = async (event) => {
  for (const record of event.Records) {
    const body = JSON.parse(record.body) as { orderId: string };
    await processOrder(body.orderId);
  }
};
 
async function processOrder(orderId: string) {
  console.log(JSON.stringify({ event: "order_processed", orderId }));
}

import type { APIGatewayProxyHandlerV2 } from "aws-lambda";
 
export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  const requestId = event.requestContext.requestId;
  console.log(JSON.stringify({
    level: "info",
    requestId,
    path: event.rawPath,
    method: event.requestContext.http.method,
  }));
 
  return { statusCode: 200, body: JSON.stringify({ ok: true }) };
};

// build.mjs
import * as esbuild from "esbuild";
 
await esbuild.build({
  entryPoints: ["src/handler.ts"],
  bundle: true,
  platform: "node",
  target: "node24",
  outfile: "dist/handler.mjs",
  format: "esm",
  external: ["@aws-sdk/*"],
});

{
  "scripts": {
    "build": "node build.mjs",
    "zip": "cd dist && zip -r ../function.zip handler.mjs"
  }
}

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
 
Resources:
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs24.x
      Handler: handler.handler
      MemorySize: 512
      Timeout: 10
      Architectures: [arm64]
      Environment:
        Variables:
          TABLE_NAME: !Ref OrdersTable
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /orders/{id}
            Method: GET

import express from "express";
import serverless from "serverless-http";
 
const app = express();
app.use(express.json());
app.get("/users", (_req, res) => res.json([]));
 
export const handler = serverless(app);