diff --git a/todo-src/addTodo/app.js b/todo-src/addTodo/app.js
index 2ca3b586..4248dd03 100644
--- a/todo-src/addTodo/app.js
+++ b/todo-src/addTodo/app.js
@@ -2,92 +2,93 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const { metricScope, Unit } = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" })
-const { v1: uuidv1 } = require('uuid');
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
+const { v1: uuidv1 } = require("uuid");
 
 // environment variables
-const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
-const options = { region: REGION }
-AWS.config.update({ region: REGION })
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
-})
-
-function isValidRequest(context, event) {
-    return (event.body !== null)
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
+
+function isValidRequest(event) {
+  return event.body !== null;
 }
 
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
-
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
 function addRecord(event) {
-
-    let usernameField = {
-        "cognito-username": getCognitoUsername(event)
-    }
-
-    // auto generated date fields
-    let d = new Date()
-    let dISO = d.toISOString()
-    let auto_fields = {
-        "id": uuidv1(),
-        "creation_date": dISO,
-        "lastupdate_date": dISO
-    }
-
-    //merge the json objects
-    let item_body = {...usernameField, ...auto_fields, ...JSON.parse(event.body) }
-
-    console.log(item_body);
-    
-    //final params to DynamoDB
-    const params = {
-        TableName: TABLE_NAME,
-        Item: item_body
-    }
-
-    return docClient.put(params)
+  let usernameField = {
+    "cognito-username": getCognitoUsername(event),
+  };
+
+  // auto generated date fields
+  let dISO = new Date().toISOString();
+  let auto_fields = {
+    id: uuidv1(),
+    creation_date: dISO,
+    lastupdate_date: dISO,
+  };
+
+  //merge the json objects
+  let item_body = {
+    ...usernameField,
+    ...auto_fields,
+    ...JSON.parse(event.body),
+  };
+
+  console.log(item_body);
+
+  //final params to DynamoDB
+  const params = {
+    TableName: TABLE_NAME,
+    Item: item_body,
+  };
+
+  return docClient.put(params);
 }
 
 // Lambda Handler
-exports.addToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({ Service: "addTodo" })
-            metrics.setProperty("RequestId", context.requestId)
-
-            if (!isValidRequest(context, event)) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: "Error: Invalid request" })
-            }
-
-            try {
-                let data = await addRecord(event).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: err.message })
-            }
-        }
-    )
\ No newline at end of file
+exports.addToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "addTodo" });
+  metrics.setProperty("RequestId", context.requestId);
+
+  if (!isValidRequest(context, event)) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: "Error: Invalid request" });
+  }
+
+  try {
+    let data = await addRecord(event).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: err.message });
+  }
+});
diff --git a/todo-src/completeTodo/app.js b/todo-src/completeTodo/app.js
index 6e898da2..3e3ec30c 100644
--- a/todo-src/completeTodo/app.js
+++ b/todo-src/completeTodo/app.js
@@ -2,81 +2,81 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const { metricScope, Unit } = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" })
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
 
 // environment variables
-const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
-const options = { region: REGION }
-AWS.config.update({ region: REGION })
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
-})
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
 
-function isValidRequest(context, event) {
-    return (event !== null) &&
-        (event.pathParameters !== null) &&
-        (event.pathParameters.id !== null) &&
-        (/^[\w-]+$/.test(event.pathParameters.id))
+function isValidRequest(event) {
+  return (
+    event !== null &&
+    event.pathParameters !== null &&
+    event.pathParameters.id !== null &&
+    /^[\w-]+$/.test(event.pathParameters.id)
+  );
 }
 
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
-
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
 function updateRecord(username, recordId) {
-    let params = {
-        TableName: TABLE_NAME,
-        Key: { 
-            "cognito-username": username,
-            "id": recordId
-        },
-        UpdateExpression: "set #field = :value",
-        ExpressionAttributeNames: { '#field': 'completed' },
-        ExpressionAttributeValues: { ':value': true }
-    }
-    return docClient.update(params)
+  let params = {
+    TableName: TABLE_NAME,
+    Key: {
+      "cognito-username": username,
+      id: recordId,
+    },
+    UpdateExpression: "set #field = :value",
+    ExpressionAttributeNames: { "#field": "completed" },
+    ExpressionAttributeValues: { ":value": true },
+  };
+  return docClient.update(params);
 }
 
 // Lambda Handler
-exports.completeToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({ Service: "completeTodo" })
-            metrics.setProperty("RequestId", context.requestId)
-
-            if (!isValidRequest(context, event)) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: "Error: Invalid request" })
-            }
+exports.completeToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "completeTodo" });
+  metrics.setProperty("RequestId", context.requestId);
 
-            try {
-                let username = getCognitoUsername(event);
-                let data = await updateRecord(username, event.pathParameters.id).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: err.message })
-            }
-        }
-    )
+  if (!isValidRequest(context, event)) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: "Error: Invalid request" });
+  }
 
+  try {
+    let username = getCognitoUsername(event);
+    let data = await updateRecord(username, event.pathParameters.id).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: err.message });
+  }
+});
diff --git a/todo-src/deleteTodo/app.js b/todo-src/deleteTodo/app.js
index 7769183d..09dce06d 100644
--- a/todo-src/deleteTodo/app.js
+++ b/todo-src/deleteTodo/app.js
@@ -2,78 +2,82 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const { metricScope, Unit } = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" })
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
 
 // environment variables
-const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
-const options = { region: REGION }
-AWS.config.update({ region: REGION })
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
-})
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
 
-function isValidRequest(context, event) {
-    return (event !== null) &&
-        (event.pathParameters !== null) &&
-        (event.pathParameters.id !== null) &&
-        (/^[\w-]+$/.test(event.pathParameters.id))
+function isValidRequest(event) {
+  return (
+    event !== null &&
+    event.pathParameters !== null &&
+    event.pathParameters.id !== null &&
+    /^[\w-]+$/.test(event.pathParameters.id)
+  );
 }
 
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
-
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
-
 function deleteRecordById(username, recordId) {
-    let params = {
-        TableName: TABLE_NAME,
-        Key: {
-            "cognito-username": username,
-            "id": recordId
-        }
-    }
+  let params = {
+    TableName: TABLE_NAME,
+    Key: {
+      "cognito-username": username,
+      id: recordId,
+    },
+  };
 
-    return docClient.delete(params)
+  return docClient.delete(params);
 }
 
 // Lambda Handler
-exports.deleteToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({ Service: "deleteTodo" })
-            metrics.setProperty("RequestId", context.requestId)
+exports.deleteToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "deleteTodo" });
+  metrics.setProperty("RequestId", context.requestId);
 
-            if (!isValidRequest(context, event)) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: "Error: Invalid request" })
-            }
+  if (!isValidRequest(context, event)) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: "Error: Invalid request" });
+  }
 
-            try {
-                let username = getCognitoUsername(event);
-                let data = await deleteRecordById(username, event.pathParameters.id).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: err.message })
-            }
-        })
+  try {
+    let username = getCognitoUsername(event);
+    let data = await deleteRecordById(
+      username,
+      event.pathParameters.id
+    ).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: err.message });
+  }
+});
diff --git a/todo-src/getAllTodo/app.js b/todo-src/getAllTodo/app.js
index 5b4e8b50..f787b38b 100644
--- a/todo-src/getAllTodo/app.js
+++ b/todo-src/getAllTodo/app.js
@@ -2,73 +2,71 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const {metricScope, Unit} = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({apiVersion: "2012-10-08"})
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
 
 // environment variables
-const {TABLE_NAME, ENDPOINT_OVERRIDE, REGION} = process.env
-const options = {region: REGION}
-AWS.config.update({region: REGION})
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: {'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders},
-})
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
 
 // Get cognito username from claims
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
-
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
 // Retrieve all the items by cognito-username
 function getRecords(username) {
-    let params = {
-        TableName: TABLE_NAME,
-        KeyConditionExpression: "#username = :username",
-        ExpressionAttributeNames:{
-            "#username": "cognito-username"
-        },
-        ExpressionAttributeValues: {
-            ":username": username
-        }
-    }
+  let params = {
+    TableName: TABLE_NAME,
+    KeyConditionExpression: "#username = :username",
+    ExpressionAttributeNames: {
+      "#username": "cognito-username",
+    },
+    ExpressionAttributeValues: {
+      ":username": username,
+    },
+  };
 
-    return docClient.query(params)
+  return docClient.query(params);
 }
 
 // Lambda Handler
-exports.getAllToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({Service: "getAllTodo"})
-            metrics.setProperty("RequestId", context.requestId)
-
-            try {
-                let username = getCognitoUsername(event);
-                let data = await getRecords(username).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
+exports.getAllToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "getAllTodo" });
+  metrics.setProperty("RequestId", context.requestId);
 
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                console.error(err.message);
-                return response(400, {message: err.message})
-            }
-        }
-    )
+  try {
+    let username = getCognitoUsername(event);
+    let data = await getRecords(username).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    console.error(err.message);
+    return response(400, { message: err.message });
+  }
+});
diff --git a/todo-src/getTodo/app.js b/todo-src/getTodo/app.js
index 9804377b..883fcebd 100644
--- a/todo-src/getTodo/app.js
+++ b/todo-src/getTodo/app.js
@@ -2,79 +2,78 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const { metricScope, Unit } = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" })
-
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
 
 // environment variables
-const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
-const options = { region: REGION }
-AWS.config.update({ region: REGION })
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
-})
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
 
-function isValidRequest(context, event) {
-    return (event !== null) &&
-        (event.pathParameters !== null) &&
-        (event.pathParameters.id !== null) &&
-        (/^[\w-]+$/.test(event.pathParameters.id))
+function isValidRequest(event) {
+  return (
+    event !== null &&
+    event.pathParameters !== null &&
+    event.pathParameters.id !== null &&
+    /^[\w-]+$/.test(event.pathParameters.id)
+  );
 }
 
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
-
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
 function getRecordById(username, recordId) {
-    let params = {
-        TableName: TABLE_NAME,
-        Key: {
-            "cognito-username": username,
-            "id": recordId
-        }
-    }
+  let params = {
+    TableName: TABLE_NAME,
+    Key: {
+      "cognito-username": username,
+      id: recordId,
+    },
+  };
 
-    return docClient.get(params)
+  return docClient.get(params);
 }
 
 // Lambda Handler
-exports.getToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({ Service: "getTodo" })
-            metrics.setProperty("RequestId", context.requestId)
-            if (!isValidRequest(context, event)) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: "Error: Invalid request" })
-            }
-
-            try {
-                let username = getCognitoUsername(event);
-                let data = await getRecordById(username, event.pathParameters.id).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
+exports.getToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "getTodo" });
+  metrics.setProperty("RequestId", context.requestId);
+  if (!isValidRequest(context, event)) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: "Error: Invalid request" });
+  }
 
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: err.message })
-            }
-        }
-    )
+  try {
+    let username = getCognitoUsername(event);
+    let data = await getRecordById(username, event.pathParameters.id).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: err.message });
+  }
+});
diff --git a/todo-src/updateTodo/app.js b/todo-src/updateTodo/app.js
index 94c7da01..7e92fb17 100644
--- a/todo-src/updateTodo/app.js
+++ b/todo-src/updateTodo/app.js
@@ -2,99 +2,100 @@
 // SPDX-License-Identifier: MIT-0
 
 // default imports
-const AWSXRay = require('aws-xray-sdk-core')
-const AWS = AWSXRay.captureAWS(require('aws-sdk'))
-const { metricScope, Unit } = require("aws-embedded-metrics")
-const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" })
-
+const AWSXRay = require("aws-xray-sdk-core");
+const AWS = AWSXRay.captureAWS(require("aws-sdk"));
+const { metricScope, Unit } = require("aws-embedded-metrics");
+const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" });
 
 // environment variables
-const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
-const options = { region: REGION }
-AWS.config.update({ region: REGION })
+const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env;
+const options = { region: REGION };
+AWS.config.update({ region: REGION });
 
 if (ENDPOINT_OVERRIDE !== "") {
-    options.endpoint = ENDPOINT_OVERRIDE
+  options.endpoint = ENDPOINT_OVERRIDE;
 }
 
-const docClient = new AWS.DynamoDB.DocumentClient(options)
+const docClient = new AWS.DynamoDB.DocumentClient(options);
 // response helper
 const response = (statusCode, body, additionalHeaders) => ({
-    statusCode,
-    body: JSON.stringify(body),
-    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
-})
+  statusCode,
+  body: JSON.stringify(body),
+  headers: {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    ...additionalHeaders,
+  },
+});
 
-function isValidRequest(context, event) {
-    let isIdValid = (event !== null) &&
-        (event.pathParameters !== null) &&
-        (event.pathParameters.id !== null) &&
-        (/^[\w-]+$/.test(event.pathParameters.id))
+function isValidRequest(event) {
+  let isIdValid =
+    event !== null &&
+    event.pathParameters !== null &&
+    event.pathParameters.id !== null &&
+    /^[\w-]+$/.test(event.pathParameters.id);
 
-    let body = event.body
-    let isBodyValid = (body !== null) &&
-        (body.completed !== null) &&
-        (body.item !== null);
+  let body = event.body;
+  let isBodyValid =
+    body !== null && body.completed !== null && body.item !== null;
 
-    return isIdValid && isBodyValid;
+  return isIdValid && isBodyValid;
 }
 
-function getCognitoUsername(event){
-    let authHeader = event.requestContext.authorizer;
-    if (authHeader !== null)
-    {
-        return authHeader.claims["cognito:username"];
-    }
-    return null;
+function getCognitoUsername(event) {
+  let authHeader = event.requestContext.authorizer;
+  if (authHeader !== null) {
+    return authHeader.claims["cognito:username"];
+  }
+  return null;
 }
 
-
 function updateRecord(username, recordId, eventBody) {
-    let d = new Date()
-    const params = {
-        TableName: TABLE_NAME,
-        Key: {
-            "cognito-username": username,
-            "id": recordId
-        },
-        UpdateExpression: "set completed = :c, lastupdate_date = :lud, #i = :i",
-        ExpressionAttributeNames: {
-            // using ExpressionAttributeNames to show how to
-            // overcome reserved names, in this case <item>
-            '#i': 'item'
-        },
-        ExpressionAttributeValues: {
-            ':c': eventBody.completed,
-            ':lud': d.toISOString(),
-            ':i': eventBody.item
-        },
-        ReturnValues: "ALL_NEW"
-    }
+  let d = new Date();
+  const params = {
+    TableName: TABLE_NAME,
+    Key: {
+      "cognito-username": username,
+      id: recordId,
+    },
+    UpdateExpression: "set completed = :c, lastupdate_date = :lud, #i = :i",
+    ExpressionAttributeNames: {
+      // using ExpressionAttributeNames to show how to
+      // overcome reserved names, in this case <item>
+      "#i": "item",
+    },
+    ExpressionAttributeValues: {
+      ":c": eventBody.completed,
+      ":lud": d.toISOString(),
+      ":i": eventBody.item,
+    },
+    ReturnValues: "ALL_NEW",
+  };
 
-    return docClient.update(params)
+  return docClient.update(params);
 }
 
 // Lambda Handler
-exports.updateToDoItem =
-    metricScope(metrics =>
-        async (event, context, callback) => {
-            metrics.setNamespace('TodoApp')
-            metrics.putDimensions({ Service: "updateTodo" })
-            metrics.setProperty("RequestId", context.requestId)
+exports.updateToDoItem = metricScope((metrics) => async (event, context) => {
+  metrics.setNamespace("TodoApp");
+  metrics.putDimensions({ Service: "updateTodo" });
+  metrics.setProperty("RequestId", context.requestId);
 
-            if (!isValidRequest(context, event)) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: "Error: Invalid request" })
-            }
+  if (!isValidRequest(context, event)) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: "Error: Invalid request" });
+  }
 
-            try {
-                let username = getCognitoUsername(event);
-                let data = await updateRecord(event.pathParameters.id, event.body).promise()
-                metrics.putMetric("Success", 1, Unit.Count)
-                return response(200, data)
-            } catch (err) {
-                metrics.putMetric("Error", 1, Unit.Count)
-                return response(400, { message: err.message })
-            }
-        }
-    )
+  try {
+    let username = getCognitoUsername(event);
+    let data = await updateRecord(
+      event.pathParameters.id,
+      event.body
+    ).promise();
+    metrics.putMetric("Success", 1, Unit.Count);
+    return response(200, data);
+  } catch (err) {
+    metrics.putMetric("Error", 1, Unit.Count);
+    return response(400, { message: err.message });
+  }
+});