AWS Lambda Sample Functions

The pieces of code included here show what an AWS Lambda function implementation looks like in different programming languages.

Generated response

Each of the sample functions in this document generates the following JSON response:

{
  "state": {
    "transactionsCursor": "2018-01-01T00:00:00Z"
  },
  "insert": {
    "transactions": [
      {
        "date": "2017-12-31T05:12:05Z",
        "order_id": 1001,
        "amount": "$1200",
        "discount": "$12"
      },
      {
        "date": "2017-12-31T06:12:04Z",
        "order_id": 1001,
        "amount": "$1200",
        "discount": "$12"
      }
    ]
  },
  "delete": {
    "transactions": [
      {
        "date": "2017-12-31T05:12:05Z",
        "order_id": 1000,
        "amount": "$1200",
        "discount": "$12"
      },
      {
        "date": "2017-12-31T06:12:04Z",
        "order_id": 1000,
        "amount": "$1200",
        "discount": "$12"
      }
    ]
  },
  "schema": {
    "transactions": {
      "primary_key": [
        "order_id",
        "date"
      ]
    }
  },
  "hasMore": "true"
}

For more information about each of the fields in this response, see the Sync Overview section of our Functions documentation.

---

Go

package main

import (
    "github.com/aws/aws-lambda-go/lambda"
)

type Request struct {
    State   map[string]string `json:"state"`
    Secrets map[string]string `json:"secrets"`
}

type Response struct {
    State   map[string]string   `json:"state"`
    Insert  map[string][]Record `json:"insert"`
    Delete  map[string][]Record `json:"delete"`
    Schema  map[string]Key      `json:"schema"`
    HasMore bool                `json:"hasMore"`
}

type Key struct {
    PrimaryKey []string `json:"primary_key"`
}

type Record struct {
    Date     string `json:"date"`
    OrderId  int    `json:"order_id"`
    Amount   string `json:"amount"`
    Discount string `json:"discount"`
}

func handleLambdaEvent(request Request) (Response, error) {
    insertTransactions, deleteTransactions, newTransactionsCursor := apiResponse(request.State, request.Secrets)

    newState := make(map[string]string)
    newState["transactionsCursor"] = newTransactionsCursor

    primary_key := make([]string, 0)
    primary_key = append(primary_key, "order_id")
    primary_key = append(primary_key, "date")

    transactionsSchema := make(map[string]Key)
    transactionsSchema["transactions"] = Key{PrimaryKey: primary_key}

    return Response{State: newState, Insert: insertTransactions, Delete: deleteTransactions, Schema: transactionsSchema, HasMore: false}, nil
}

func apiResponse(state map[string]string, secrets map[string]string) (map[string][]Record, map[string][]Record, string) {
    insertTransactions := make(map[string][]Record)
    insertTransactions["transactions"] = append(insertTransactions["transactions"], Record{Date: "2017-12-31T05:12:05Z", OrderId: 1001, Amount: "$1200", Discount: "$12"})
    insertTransactions["transactions"] = append(insertTransactions["transactions"], Record{Date: "2017-12-31T05:12:05Z", OrderId: 1002, Amount: "$1345", Discount: "$14"})

    deleteTransactions := make(map[string][]Record)
    deleteTransactions["transactions"] = append(deleteTransactions["transactions"], Record{Date: "2017-12-31T05:12:05Z", OrderId: 1001, Amount: "$1200", Discount: "$12"})

    return insertTransactions, deleteTransactions, "2018-01-01T00:00:00Z"
}

func main() {
    lambda.Start(handleLambdaEvent)
}

---

Java

package com.amazonaws.lambda.demo;

import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class LambdaFunctionHandler implements RequestHandler<Request, Response> {
    private static final ObjectMapper MAPPER = new ObjectMapper();
    
    @Override
    public Response handleRequest(Request request, Context context) {
        return apiResponse(request.state, request.secrets);
    }
    
    Response apiResponse(Object state, Object secrets) {
        Record record1 = new Record(Instant.parse("2017-12-31T05:12:05Z"), 1001L, "$1200", "$12");
        Record record2 = new Record(Instant.parse("2017-12-31T06:12:04Z"), 1001L, "$1200", "$12");
        
        Record record3 = new Record(Instant.parse("2017-12-31T05:12:05Z"), 1000L, "$1200", "$12");
        Record record4 = new Record(Instant.parse("2017-12-31T06:12:04Z"), 1000L, "$1200", "$12");
        
        HashMap<String, Instant> newState = new HashMap<>();
        newState.put("transactionCursor", Instant.parse("2018-01-01T00:00:00Z"));

        state = newState;
        
        List<Record> records = new ArrayList<>();
        records.add(record1);
        records.add(record2);
        
        Map<String, Object> insert = new HashMap<>();
        insert.put("transactions", records);
        
        records.clear();
        records.add(record3);
        records.add(record4);
        
        Map<String, Object> delete = new HashMap<>();
        delete.put("transactions", records);
        
        List<String> primaryKey = new ArrayList<>();
        primaryKey.add("order_id");
        primaryKey.add("date");
        
        Map<String, List<String>> transactionsSchema = new HashMap<>();
        transactionsSchema.put("primary_key", primaryKey);
        
        Map<String, Object> schema = new HashMap<>();
        schema.put("transactions", transactionsSchema);
        
        return new Response(state, insert, delete, schema, true);
    }
}

package com.amazonaws.lambda.demo;

public class Request {
    Object state;
    Object secrets;

    public Object getState() {
        return state;
    }

    public void setState(Object state) {
        this.state = state;
    }
    
    public Object getSecrets() {
        return secrets;
    }

    public void setSecrets(Object secrets) {
        this.secrets = secrets;
    }

    public Request(Object state, Object secrets) {
        this.state = state;
        this.secrets = secrets;
    }

    public Request() {
    }
}

package com.amazonaws.lambda.demo;

import java.util.Map;

public class Response {
    Object state;
    Map<String, Object> insert;
    Map<String, Object> delete;
    Map<String, Object> schema;
    boolean hasMore;

    public Object getState() {
        return state;
    }

    public void setState(Object state) {
        this.state = state;
    }
    
    public Map<String, Object> getInsert() {
        return insert;
    }

    public void setDelete(Map<String, Object> insert) {
        this.insert = insert;
    }
    
    public Map<String, Object> getDelete() {
        return delete;
    }

    public void setSchema(Map<String, Object> delete) {
        this.delete = delete;
    }
    
    public Map<String, Object> getSchema() {
        return schema;
    }

    public void setInsert(Map<String, Object> schema) {
        this.schema = schema;
    }
    
    public boolean getHasMore() {
        return hasMore;
    }
    
    public void setHasMore(boolean hasMore) {
        this.hasMore = hasMore;
    }

    public Response(
            Object state, 
            Map<String, Object> insert, 
            Map<String, Object> delete, 
            Map<String, Object> schema, 
            boolean hasMore) {
        this.state = state;
        this.insert = insert;
        this.delete = delete;
        this.schema = schema;
        this.hasMore = hasMore;
    }

    public Response() {
    }
}

package com.amazonaws.lambda.demo;

import java.time.Instant;

public class Record {
    public Instant date;
    public Long order_id;
    public String amount;
    public String discount;
    
    public Record(Instant date, Long order_id, String amount, String discount) {
        this.date = date;
        this.order_id = order_id;
        this.amount = amount;
        this.discount = discount;
    }
}

---

Node.js

exports.handler = (request, context, callback) => {
    callback(null, update(request.state, request.secrets));
};

function update(state, secrets) {
    // Fetch records using api calls
    let [insertTransactions, deleteTransactions, newTransactionsCursor] = apiResponse(state, secrets);

    // Populate records and state
    return ({
        state: {
            transactionsCursor: newTransactionsCursor
        },
        insert: {
            transactions: insertTransactions
        },
        delete: {
            transactions: deleteTransactions
        },
        schema : {
            transactions : {
                primary_key : ['order_id', 'date']
            }
        },
        hasMore : true
    });
}

function apiResponse(state, secrets) {
    var insertTransactions = [
            {"date":'2017-12-31T05:12:05Z', "order_id":1001, "amount":'$1200', "discount":'$12'},
            {"date":'2017-12-31T06:12:04Z', "order_id":1001, "amount":'$1200', "discount":'$12'},
    ];

    var deleteTransactions = [
            {"date":'2017-12-31T05:12:05Z', "order_id":1000, "amount":'$1200', "discount":'$12'},
            {"date":'2017-12-31T06:12:04Z', "order_id":1000, "amount":'$1200', "discount":'$12'},
    ];

    return [insertTransactions, deleteTransactions, '2018-01-01T00:00:00Z'];
}

---

Python

import json

def lambda_handler(request, context):
    # Fetch records using api calls
    (insertTransactions, deleteTransactions, newTransactionCursor) = api_response(request['state'], request['secrets'])
    
    # Populate records in insert    
    insert = {}    
    insert['transactions'] = insertTransactions
    
    delete = {}
    delete['transactions'] = deleteTransactions
    
    state = {}
    state['transactionsCursor'] = newTransactionCursor
    
    transactionsSchema = {}
    transactionsSchema['primary_key'] = ['order_id', 'date']
    
    schema = {}
    schema['transactions'] = transactionsSchema
    
    response = {}
    
    # Add updated state to response
    response['state'] =  state
    
    # Add all the records to be inserted in response
    response['insert'] = insert
    
    # Add all the records to be marked as deleted in response
    response['delete'] = delete
    
    # Add schema defintion in response
    response['schema'] = schema
    
    # Add hasMore flag
    response['hasMore'] = 'true'
    
    return response
    
def api_response(state, secrets):
    # your api call goes here
    insertTransactions = [
            {"date":'2017-12-31T05:12:05Z', "order_id":1001, "amount":'$1200', "discount":'$12'},
            {"date":'2017-12-31T06:12:04Z', "order_id":1001, "amount":'$1200', "discount":'$12'},
    ]
    
    deleteTransactions = [
            {"date":'2017-12-31T05:12:05Z', "order_id":1000, "amount":'$1200', "discount":'$12'},
            {"date":'2017-12-31T06:12:04Z', "order_id":1000, "amount":'$1200', "discount":'$12'},
    ]
    
    return (insertTransactions, deleteTransactions, '2018-01-01T00:00:00Z')

---

For more information, refer to AWS Lambda's online documentation.