split handler into smaller functions

src/handler.js

@@ -8,97 +8,122 @@ const RedirectResponse = require("./response/RedirectResponse");
 const PlainTextResponse = require("./response/PlainTextResponse");
 const logging = require("./lib/logging");
 
-module.exports = (container) => async (event) => {
-  const request = new Request(event, container.config.ENCRYPTION_KEY);
-
-  let error;
-  let response;
+const validateRecaptcha = (recaptchaFn) => async (request) => {
+  const isValid = await recaptchaFn(request);
 
-  try {
-    const isValidRecaptcha = await container.isValidRecaptcha(request);
+  if (!isValid) {
+    throw new ForbiddenError("Form submission failed recaptcha");
+  }
 
-    if (!isValidRecaptcha) {
-      throw new ForbiddenError("Form submission failed recaptcha");
-    }
+  return request;
+};
 
-    error = request.validate(container.config.WHITELISTED_RECIPIENTS);
+const validateRequest = (whitelist) => async (request) => {
+  const error = request.validate(whitelist);
 
-    if (error) {
-      throw error;
-    }
+  if (error) {
+    throw error;
+  }
 
-    const recipientCount = [].concat(
-      request.recipients.cc,
-      request.recipients.bcc,
-      request.recipients.replyTo
-    ).length;
+  return request;
+};
 
-    logging.info(
-      `sending to '${request.recipients.to}' and ${recipientCount} other recipients`
-    );
+const sendEmail = (sender, senderArn, subject, mailerFn) => async (request) => {
+  const recipientCount = [].concat(
+    request.recipients.cc,
+    request.recipients.bcc,
+    request.recipients.replyTo
+  ).length;
+
+  logging.info(
+    `sending to '${request.recipients.to}' and ${recipientCount} other recipients`
+  );
+
+  const email = new Email(
+    sender,
+    senderArn,
+    subject,
+    request.recipients,
+    request.body
+  );
+
+  const serviceError = email.validate();
+
+  if (serviceError) {
+    throw serviceError;
+  }
 
-    const email = new Email(
-      container.config.SENDER,
-      container.config.SENDER_ARN,
-      container.config.MSG_SUBJECT,
-      request.recipients,
-      request.body
-    );
+  await mailerFn(email);
 
-    error = email.validate();
+  return request;
+};
 
-    if (error) {
-      throw error;
+const buildSuccessResponse = (message, templateFn) => async (request) => {
+  if (request.isJsonResponse()) {
+    return new JsonResponse(200, message);
+  } else if (request.isRedirectResponse()) {
+    return new RedirectResponse(302, message, request.redirect);
+  } else {
+    try {
+      const template = await templateFn();
+      return new HtmlResponse(200, message, template);
+    } catch (error) {
+      logging.error("unable to load template file", error);
+      return new PlainTextResponse(200, message);
     }
+  }
+};
 
-    await container.sendEmail(email);
-
-    const message = container.config.MSG_RECEIVE_SUCCESS;
-
-    if (request.isJsonResponse()) {
-      response = new JsonResponse(200, message);
-    } else if (request.isRedirectResponse()) {
-      response = new RedirectResponse(302, message, request.redirect);
-    } else {
-      try {
-        response = new HtmlResponse(
-          200,
-          message,
-          await container.loadTemplate()
-        );
-      } catch (error) {
-        logging.error("unable to load template file", error);
-        response = new PlainTextResponse(200, message);
-      }
-    }
-  } catch (error) {
-    logging.error("error was caught while executing receive lambda", error);
+const buildErrorResponse = (isJsonResponse, templateFn) => async (error) => {
+  logging.error("error was caught while executing receive lambda", error);
 
-    let statusCode = 500;
-    let message = "An unexpected error occurred";
+  let statusCode = 500;
+  let message = "An unexpected error occurred";
 
-    if (error instanceof HttpError) {
-      statusCode = error.statusCode;
-      message = error.message;
-    }
+  if (error instanceof HttpError) {
+    statusCode = error.statusCode;
+    message = error.message;
+  }
 
-    if (request.isJsonResponse()) {
-      response = new JsonResponse(statusCode, message);
-    } else {
-      try {
-        response = new HtmlResponse(
-          statusCode,
-          message,
-          await container.loadTemplate()
-        );
-      } catch (error) {
-        logging.error("unable to load template file", error);
-        response = new PlainTextResponse(statusCode, message);
-      }
+  if (isJsonResponse) {
+    return new JsonResponse(statusCode, message);
+  } else {
+    try {
+      const template = await templateFn();
+      return new HtmlResponse(statusCode, message, template);
+    } catch (error) {
+      logging.error("unable to load template file", error);
+      return new PlainTextResponse(statusCode, message);
     }
   }
+};
 
+const handleResponse = async (response) => {
   logging.info(`returning http ${response.statusCode} response`);
 
   return response.build();
 };
+
+module.exports = (container) => async (event) => {
+  const request = new Request(event, container.config.ENCRYPTION_KEY);
+
+  return Promise.resolve()
+    .then(validateRecaptcha(container.isValidRecaptcha))
+    .then(validateRequest(container.config.WHITELISTED_RECIPIENTS))
+    .then(
+      sendEmail(
+        container.config.SENDER,
+        container.config.SENDER_ARN,
+        container.config.MSG_SUBJECT,
+        container.sendEmail
+      )
+    )
+    .then(
+      buildSuccessResponse(
+        container.config.MSG_RECEIVE_SUCCESS,
+        container.loadTemplate
+      )
+    )
+    .catch(buildErrorResponse(request.isJsonResponse(), container.loadTemplate))
+    .then(handleResponse);
+};