Integrating with AWS Lambda & DynamoDB

Create your Airtable base and configure your tables and fields to reflect the information you want to capture, we recommend starting with this example base.

In this step, we'll create a Lambda Function and build a REST API using AWS API Gateway so that our Lambda Function can send information to our DynamoDB. For a more in-depth explanation into how REST APIs work, and why we're building components like Resources and Methods, watch this quick video.

1. Create a Lambda function

   1. Within your AWS account, navigate to Lambda

   2. Select Create Function

   3. Select Author from scratch, add your basic information, and select Create function. We'll revisit this later.
      

2. Create a REST API via AWS API Gateway

   1. Within your AWS account, navigate to API Gateway

   2. Under "Choose an API type" find REST API and select Build

   3. Select New API and give your API a name
      

3. Create Resources - Now we can create the resources for our API. For this project, we'll create two resources.

   1. In the tool bar, click Actions to open the dropdown menu. In the menu, click Create Resource

   2. Create your first resource with the following details:

      1. Resource Name: table

      2. Resource Path: table_name

   3. Within /{table_name} we want a resource for ID so that a user can update/delete an existing item by making a request to /{table_name}/{id}. Within /{table_name}, create your second resource with the following details:

      1. Resource Name: id

      2. Resource Path: {id}

4. Create Methods - Now that we've added our resources, we can create methods under each resource. Our Lambda code will handle most of the routing logic based on HTTP method. For each resource complete the following steps.

   1. Select the resource name in the “Resources” sidebar

   2. In the "Actions" menu select Create Method

   3. Select ANY and click the checkmark to confirm

   4. Select Lambda Function as your integration type

   5. Select Use Lambda Proxy Integration

   6. Name your Lambda Function

   7. Select Save
      

5. Deploy your API Gateway

   1. After you've created methods for both resources, select Deploy API from the “Actions” menu. On first set up, AWS will ask you to set up a Deployment stage. We've called ours “default.”
      
      

   2. Next, you must:

      1. Re-deploy your API Gateway any time you make changes

      2. Keep a record of the Invoke URL as that’s what we actually use to make API requests

   3. After you've deployed your API, you'll be taken to the Stage Editor where you can find your Invoke URL. This will be our endpoint for our API calls. Test your API by making a request via cURL or Postman.

Airtable’s scripting extension allows you to write JavaScript or TypeScript code and deploy it from your base. This enables you to further optimize your workflows by including custom logic in your base. The scripting extension supports the ability to make web-requests to other services via a fetch request. Allowing us to make API calls out to our new AWS API Gateway and Lambda application, which will create and delete data within our DynamoDB database.

Airtable also supports a button field, which can be configured to take a number of different actions after the user clicks on it. One of those actions is the ability to pass a record’s details to a scripting extension and then execute the script with those details.

For our example use case, we want users to consciously make the decision to push updates into DynamoDB vis a button in the Airtable base. In our example, Airtable users plan, draft and collaborate on content in a base. Once it’s ready to publish into our DyanmoDB instance, the user can push a button to send that record into DynamoDB. If the user needs to pull the information from DynamoDB because it’s no longer relevant, users can trigger a deletion by pushing another button in the base.

To configure this workflow you’ll first need to create your scripts and then create the button fields which can be used to trigger those scripts.

1. Create a new scripting extension in your base to Update or Create in DynamoDB. You can copy the following code and paste it in the code editor of the scripting extension you are creating:

   const base_url =  '{{YOUR AWS API GATEWAY URL}}' ; 
   const dynamo_table_name =  '{{YOUR DYNAMODB TABLE NAME}}' ; 
   const primary_dynamo_field =  '{{YOUR DYNAMODB PRIMARY FIELD/KEY NAME}}' ; 
   
   
   // build the URL 
   
   const lambda_url = base_url + dynamo_table_name; 
   
   
   // get our different tables   
   
   const table = base.getTable( 'Table 1' ); 
   const foreign_table = base.getTable( 'Table 2' ); 
   
   
   // get the record from the button action,   
   // or allow the user to run the script and pick a specific record 
   
   const record =  await input.recordAsync( "Select record to update" , table);
   
   /** 
   
   * For a given record, convert it into a JSON object 
   
   * This function iterates over all fields in a record and converts it into a format that we can then send to Dynamo 
   
   * Most of the logic is managing linked record fields.     
   
   * We recursively call the function on any linked records, so that we get all of the linked records' information as well 
   */ 
   
   async function recordToJson(table, record, linked_table_id) { 
    var p = {}; 
    for ( var f  of table.fields) { 
    if (f. type ===  'multipleRecordLinks' && f.options.linkedTableId !== linked_table_id) { 
    var foreign   = base.getTable(f.options.linkedTableId); 
    var res =  await foreign.selectRecordsAsync(); 
    var foreign_recs = record.getCellValue(f.id); 
   
   foreign_recs = foreign_recs ===  null ? [] : foreign_recs 
   p[f.name] = []; 
   
    for ( var r  of foreign_recs){ 
   
   p[f.name].push( await recordToJson(foreign, res.getRecord(r.id), table.id)); 
   } 
   
   p[f.name] =  JSON .stringify(p[f.name]); 
   }  
   else if (f. type !==  'button' && f. type !==  'multipleRecordLinks' ) { 
   p[f.name] = record.getCellValueAsString(f);                 
   } 
   
   } 
   
    return p; 
   } 
   
   
   // build the payload to send and then send to our Lambda 
   
   var payload =  await recordToJson(table, record); 
   var p =  await fetch( 
   
   lambda_url,   
   
   { 
   method: 'POST' , 
   body:  JSON .stringify(payload), 
   headers: { 
    'Content-Type' :  'application/json' 
   } 
   
   } 
   
   ); 
   
   var resp =  await p.json(); 
   
   output.markdown( 'Update sent!' ); 
   output.inspect(resp); 
   
   
   // then write the last updated time for this record back to the table 
   
   output.markdown( 'Updating time sent' ); 
   
   await table.updateRecordAsync( 
   record.id,   
   { 
   
    'Last Pushed to Dynamo' : ( new Date ()).toISOString() 
   
   } 
   
   ); 
   
   output.markdown( '## Done!' );

2. Create another scripting extension in your base to Delete in DynamoDB. You can copy the following code and paste it in the code editor of the scripting extension you are creating:

   const base_url =  '{{YOUR AWS API GATEWAY URL}}' ; 
   const dynamo_table_name =  '{{YOUR DYNAMODB TABLE NAME}}' ; 
   const primary_dynamo_field =  '{{YOUR DYNAMODB PRIMARY FIELD/KEY NAME}}' ; 
   const table = base.getTable( 'Table 1' ); 
   const record =  await input.recordAsync( "Select record to update" , table); 
   const url =    ${base_url} / ${dynamo_table_name} / ${record.getCellValueAsString(primary_dynamo_field)}   ; 
   
   var p =  await fetch( 
   url,   
   
   { 
   method: 'DELETE' , 
   headers: { 
    'Content-Type' :  'application/json' 
   } 
   } 
   
   ); 
   
   var resp =  await p.json(); 
   output.markdown( 'Record deleted!' ); 
   output.inspect(resp); 
   
   await table.deleteRecordAsync(record.id); 
   
   output.markdown( 'Deleted record from base' );

3. Lastly, create the button fields to trigger the scripts to run. Create two button fields:

   1. Create/Update Record

   2. Delete Record

   3. When creating each button field:

      1. Action : Run Script

      2. Dashboard : the dashboard you installed the scripting extension in

      3. Extension : the corresponding update/delete script

You should now be able to trigger these scripts by clicking on the buttons and see the corresponding action take place in your AWS DynamoDB instance.