Building a Serverless REST API with Fauna, AWS, and TypeScript

• Node.js (20 or current LTS)
• AWS CLI v2
• Serverless Framework
• AWS account
• Fauna account

• Perform CRUD (Create, Read, Update, Delete) operations from Lambda functions with Fauna as the data layer
• Manage Fauna database with the Serverless Framework
• Manage and deploy your application with the Serverless Framework.

Create a new project

$ serverless create --template aws-nodejs-typescript

$ npm i severless-fauna serverless-dotenv-plugin --save

Configure Fauna resources

service: aws-serverless-api-v2

frameworkVersion: "3"

# Specify donenv
useDotenv: true
# Specify provider
provider:
 name: aws
 runtime: nodejs20.x

# specify providers
plugins:
 - serverless-plugin-typescript
 - serverless-offline

# Fauna configuration
fauna:
 version: 10
 client:
   secret: ${env:FAUNA_SECRET}
 collections:
   Inventory:
     name: Inventory

FAUNA_ROOT_KEY='fnA.............'

# serverless.yml
# … rest of the code above

resources:
 # AWS Secrets Manager resource definition
 Resources:
   FaunaSecret:
     Type: AWS::SecretsManager::Secret
     Properties:
       Name: /aws/reference/secretsmanager/fauna_secret
       Description: "Fauna DB secret for the application"
       # You can set the initial value of the secret here or leave it to configure manually in AWS Console.
       SecretString: '{"FAUNA_SECRET": "your-initial-secret-value"}'

Configure AWS Lambda

# ... rest of the serverless.yml file

provider:
 name: aws
 runtime: nodejs18.x
# Lambda configuration
functions:
 create:
   handler: handler.create
   events:
     - http:
         path: /
         method: post
 readAll:
   handler: handler.read
   events:
     - http:
         path: /
         method: get
 readOne:
   handler: handler.read
   events:
     - http:
         path: /{id}
         method: get
 update:
   handler: handler.update
   events:
     - http:
         path: /{id}
         method: put
 delete:
   handler: handler.deleteItem
   events:
     - http:
         path: /{id}
         method: delete

# ...Rest of the code

Write Lambda “function” code

$ npm i fauna --save

import { APIGatewayProxyHandler } from "aws-lambda";
import { Client, QuerySuccess, fql } from 'fauna';

type InventoryItem = {
 name: string;
 price: number;
 quantity: number;
};

const client = new Client({ secret: process.env.FAUNA_SECRET });

export const create: APIGatewayProxyHandler = async (event) => {
 try {
   if (!event.body) {
     return {
       statusCode: 400,
       body: JSON.stringify({ error: 'Invalid request body' }),
     };
   }

   const data = JSON.parse(event.body) as InventoryItem;

   if (!data) {
     return {
       statusCode: 400,
       body: JSON.stringify({ error: 'Parsed data is invalid' }),
     };
   }

   const response: QuerySuccess<InventoryItem> = await client.query(
     fql`Inventory.create(${data})`
   );

   return {
     statusCode: 200,
     body: JSON.stringify(response),
   };
 } catch (error) {
   return {
     statusCode: 400,
     body: JSON.stringify(error),
   };
 }
};

export const deleteItem: APIGatewayProxyHandler = async (event) => {
 if (!event.pathParameters || !event.pathParameters.id) {
   return {
     statusCode: 400,
     body: JSON.stringify({ error: 'ID is required' }),
   };
 }

 console.log('Path Parameters:', event.pathParameters);

 const id = String(event.pathParameters.id);

 try {
   const response: QuerySuccess<InventoryItem> = await client.query(fql`
     let toDelete = Inventory.byId(${id})
     toDelete!.delete()
   `);

   return {
     statusCode: 200,
     body: JSON.stringify(response),
   };
 } catch (error) {
   return {
     statusCode: 500,
     body: JSON.stringify({ error: error.message }),
   };
 }
};

export const read: APIGatewayProxyHandler = async (event) => {
 try {
   if (event.pathParameters && event.pathParameters.id) {
       console.log('Path Parameters:', event.pathParameters.id);

       const id = String(event.pathParameters.id);
       const response: QuerySuccess<InventoryItem> = await client.query(
           fql`Inventory.byId(${id})`
       );
       return {
           statusCode: 200,
           body: JSON.stringify(response),
       };
   } else {
       const response = await client.query(
           fql`Inventory.all()`
       );
       return {
           statusCode: 200,
           body: JSON.stringify(response),
       };
   }
 } catch (error) {
   return {
     statusCode: 400,
     body: JSON.stringify(error),
   };
 }
};

export const update: APIGatewayProxyHandler = async (event) => {
 try {
   if (!event.pathParameters || !event.pathParameters.id) {
     return {
       statusCode: 400,
       body: JSON.stringify({ error: 'ID must be provided.' }),
     };
   }

   if (!event.body) {
     return {
       statusCode: 400,
       body: JSON.stringify({ error: 'Invalid request body' }),
     };
   }

   console.log('Path Parameters:', event.pathParameters.id);

   const id = event.pathParameters.id;
   const data = JSON.parse(event.body);

   const response: QuerySuccess<InventoryItem> = await client.query(fql`
     let itemToUpdate = Inventory.byId(${id});
     itemToUpdate!.update(${data})`
   );

   return {
     statusCode: 200,
     body: JSON.stringify(response),
   };
 } catch (error) {
   return {
     statusCode: 400,
     body: JSON.stringify(error),
   };
 }
};

Deploy your stack

$ sls deploy

$ sls destroy