feat: [AB#16129] crtk business activities email

Author: somabadri

.gitignore

@@ -1,5 +1,7 @@
 # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 
+web/next-env.d.ts
+
 # dependencies
 web/node_modules
 /.pnp

api/src/api/crtkEmailRouter.test.ts

@@ -0,0 +1,76 @@
+import { crtkEmailRouter } from "@api/crtkEmailRouter";
+import { CrtkEmailMetadata } from "@businessnjgovnavigator/shared";
+import { PowerAutomateEmailClient } from "@domain/types";
+import { setupExpress } from "@libs/express";
+import { DummyLogWriter, LogWriterType } from "@libs/logWriter";
+import { Express } from "express";
+import { StatusCodes } from "http-status-codes";
+import request from "supertest";
+
+describe("crtkEmailRouter", () => {
+  let app: Express;
+  let logger: LogWriterType;
+  let stubCrtkEmailClient: jest.Mocked<PowerAutomateEmailClient>;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    logger = DummyLogWriter;
+    stubCrtkEmailClient = {
+      sendEmail: jest.fn(),
+      health: jest.fn(),
+    };
+
+    app = setupExpress(false);
+    app.use(crtkEmailRouter(stubCrtkEmailClient, logger));
+  });
+
+  const emailMetaData: CrtkEmailMetadata = {
+    username: "test user",
+    email: "test@example.com",
+    businessName: "Test Business",
+    businessStatus: "Operating",
+    businessAddress: "123 Main Street",
+    industry: "Test Industry",
+    ein: "123456789",
+    naicsCode: "123456",
+    businessActivities: "These are my business activities. We do a lot of things.",
+    materialOrProducts: "These are my materials and products.",
+  };
+
+  it("sends a request with emailMetaData and returns a success response", async () => {
+    stubCrtkEmailClient.sendEmail.mockResolvedValue({
+      statusCode: StatusCodes.OK,
+      message: "Email confirmation successfully sent",
+    });
+
+    const response = await request(app).post("/crtk-email").send({ emailMetaData });
+
+    expect(stubCrtkEmailClient.sendEmail).toHaveBeenCalledWith(emailMetaData);
+    expect(response.status).toEqual(StatusCodes.OK);
+    expect(response.body).toEqual("SUCCESS");
+  });
+
+  it("throws an error if status is not 200", async () => {
+    stubCrtkEmailClient.sendEmail.mockResolvedValue({
+      statusCode: StatusCodes.FORBIDDEN,
+      message: "Auth Failed",
+    });
+
+    const response = await request(app).post("/crtk-email").send({ emailMetaData });
+
+    expect(stubCrtkEmailClient.sendEmail).toHaveBeenCalledWith(emailMetaData);
+    expect(response.status).toEqual(StatusCodes.INTERNAL_SERVER_ERROR);
+    expect(response.body).toEqual("FAILED");
+  });
+
+  it("handles error if request fails", async () => {
+    const errorMessage = "Failed to send email";
+    stubCrtkEmailClient.sendEmail.mockRejectedValue(new Error(errorMessage));
+
+    const response = await request(app).post("/crtk-email").send({ emailMetaData });
+
+    expect(stubCrtkEmailClient.sendEmail).toHaveBeenCalledWith(emailMetaData);
+    expect(response.status).toEqual(StatusCodes.INTERNAL_SERVER_ERROR);
+    expect(response.body).toEqual("FAILED");
+  });
+});

api/src/api/crtkEmailRouter.ts

@@ -0,0 +1,35 @@
+import { PowerAutomateEmailClient } from "@domain/types";
+import type { LogWriterType } from "@libs/logWriter";
+import { Router } from "express";
+import { StatusCodes } from "http-status-codes";
+
+export const crtkEmailRouter = (
+  powerAutomateClient: PowerAutomateEmailClient,
+  logger: LogWriterType,
+): Router => {
+  const router = Router();
+
+  router.post("/crtk-email", async (req, res) => {
+    const { emailMetaData } = req.body;
+
+    try {
+      const response = await powerAutomateClient.sendEmail(emailMetaData);
+      logger.LogInfo(response.message);
+      if (response.statusCode === 200) {
+        const status = StatusCodes.OK;
+        res.status(status).json("SUCCESS");
+      } else {
+        const status = StatusCodes.INTERNAL_SERVER_ERROR;
+        logger.LogError(`Failed to send CRTK email: ${response.message}`);
+        res.status(status).json("FAILED");
+      }
+    } catch (error) {
+      const status = StatusCodes.INTERNAL_SERVER_ERROR;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.LogError(errorMessage);
+      res.status(status).json("FAILED");
+    }
+  });
+
+  return router;
+};

api/src/api/crtkRouter.ts

@@ -1,14 +1,14 @@
 import { getSignedInUserId } from "@api/userRouter";
-import type { DatabaseClient, UpdateCRTK } from "@domain/types";
+import { CrtkBusinessDetails } from "@businessnjgovnavigator/shared";
+import type { DatabaseClient, UpdateCrtk } from "@domain/types";
 import { getDurationMs } from "@libs/logUtils";
 import type { LogWriterType } from "@libs/logWriter";
-import { CRTKBusinessDetails } from "@shared/crtk";
 import type { UserData } from "@shared/userData";
 import { Router } from "express";
 import { StatusCodes } from "http-status-codes";
 
 export const crtkLookupRouterFactory = (
-  updateCRTKUser: UpdateCRTK,
+  updateCrtkUser: UpdateCrtk,
   databaseClient: DatabaseClient,
   logger: LogWriterType,
 ): Router => {
@@ -18,11 +18,11 @@ export const crtkLookupRouterFactory = (
     const method = req.method;
     const endpoint = req.originalUrl;
     const requestStart = Date.now();
-    const businessDetails: CRTKBusinessDetails = req.body.CRTKbusinessDetails;
+    const businessDetails: CrtkBusinessDetails = req.body.crtkBusinessDetails;
     logger.LogInfo(`[START] ${method} ${endpoint} - userId: ${userId}`);
 
     const userData = await databaseClient.get(userId);
-    updateCRTKUser(userData, businessDetails)
+    updateCrtkUser(userData, businessDetails)
       .then(async (response: UserData) => {
         const status = StatusCodes.OK;
         await databaseClient.put(response);

api/src/client/CrtkEmailClient.test.ts

@@ -0,0 +1,80 @@
+import { EmailConfirmationResponse } from "@businessnjgovnavigator/shared";
+import { ApiPowerAutomateClientFactory } from "@client/ApiPowerAutomateClientFactory";
+import { CrtkEmailClient } from "@client/CrtkEmailClient";
+import { PowerAutomateClient } from "@domain/types";
+import { DummyLogWriter } from "@libs/logWriter";
+import { getConfigValue } from "@libs/ssmUtils";
+import { generateEmailConfirmationSubmission } from "@shared/test";
+import { StatusCodes } from "http-status-codes";
+
+jest.mock("@libs/ssmUtils", () => ({
+  getConfigValue: jest.fn(),
+}));
+
+jest.mock("@client/ApiPowerAutomateClientFactory", () => ({
+  ApiPowerAutomateClientFactory: jest.fn(),
+}));
+
+const mockSuccessEmailResponse: EmailConfirmationResponse = {
+  statusCode: 200,
+  message: "Email confirmation successfully sent",
+};
+
+const mockErrorEmailResponse: EmailConfirmationResponse = {
+  statusCode: 500,
+  message: "Failed to send email confirmation",
+};
+
+const mockPowerAutomateClient = ApiPowerAutomateClientFactory as jest.MockedFunction<
+  typeof ApiPowerAutomateClientFactory
+>;
+const getConfigValueMock = getConfigValue as jest.MockedFunction<typeof getConfigValue>;
+const startWorkflow = jest.fn();
+
+describe("CRTK Email Client", () => {
+  const emailClient = CrtkEmailClient(DummyLogWriter);
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    getConfigValueMock.mockImplementation(async (key: string) => {
+      if (key === "crtk_email_url") return "https://example.com/flow";
+      if (key === "crtk_email_key") return "api-key-xyz";
+      throw new Error("unexpected key");
+    });
+
+    mockPowerAutomateClient.mockReturnValue({
+      startWorkflow,
+      health: jest.fn(),
+    } as PowerAutomateClient);
+  });
+
+  describe("sendEmail", () => {
+    it("returns a successful response when email is sent successfully", async () => {
+      startWorkflow.mockResolvedValue({
+        status: StatusCodes.OK,
+        data: { message: mockSuccessEmailResponse.message },
+      });
+      const postBody = generateEmailConfirmationSubmission({});
+      const response = await emailClient.sendEmail(postBody);
+
+      expect(response).toEqual({
+        statusCode: StatusCodes.OK,
+        message: "Email confirmation successfully sent",
+      });
+    });
+
+    it("returns an error response when email cannot be sent", async () => {
+      startWorkflow.mockRejectedValue({
+        message: mockErrorEmailResponse.message,
+      });
+      const postBody = generateEmailConfirmationSubmission({});
+      const response = await emailClient.sendEmail(postBody);
+
+      expect(response).toEqual({
+        statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+        message: "Failed to send email confirmation",
+      });
+    });
+  });
+});

api/src/client/CrtkEmailClient.ts

@@ -0,0 +1,100 @@
+import {
+  EmailConfirmationResponse,
+  EmailConfirmationSubmission,
+} from "@businessnjgovnavigator/shared";
+import { ApiPowerAutomateClientFactory } from "@client/ApiPowerAutomateClientFactory";
+import { HealthCheckMetadata, PowerAutomateEmailClient } from "@domain/types";
+import { LogWriterType } from "@libs/logWriter";
+import { getConfigValue } from "@libs/ssmUtils";
+import { ReasonPhrases, StatusCodes } from "http-status-codes";
+
+const getConfig = async (): Promise<{
+  emailUrl: string;
+  emailKey: string;
+}> => {
+  return {
+    emailUrl: await getConfigValue("crtk_email_url"),
+    emailKey: await getConfigValue("crtk_email_key"),
+  };
+};
+
+export const CrtkEmailClient = (logger: LogWriterType): PowerAutomateEmailClient => {
+  const logId = logger.GetId();
+
+  const sendEmail = async (
+    postBody: EmailConfirmationSubmission,
+  ): Promise<EmailConfirmationResponse> => {
+    const config = await getConfig();
+
+    const crtkPowerAutomateClient = ApiPowerAutomateClientFactory({
+      baseUrl: config.emailUrl,
+      apiKey: config.emailKey,
+      logger,
+    });
+
+    logger.LogInfo(
+      `CRTK Email Client - Id:${logId} - Sending request to ${
+        config.emailUrl
+      } data: ${JSON.stringify(postBody)}`,
+    );
+    return crtkPowerAutomateClient
+      .startWorkflow({ body: postBody })
+      .then((response) => {
+        logger.LogInfo(
+          `CRTK Email Client - Id:${logId} - Response received: ${JSON.stringify(response.data)}`,
+        );
+
+        const successResponse: EmailConfirmationResponse = {
+          statusCode: response.status,
+          message: response.data.message,
+        };
+        return successResponse;
+      })
+      .catch((error) => {
+        logger.LogError(
+          `CRTK Email Client - Id:${logId} - Error received: ${JSON.stringify(error)}`,
+        );
+        const errorResponse: EmailConfirmationResponse = {
+          statusCode: StatusCodes.INTERNAL_SERVER_ERROR,
+          message: error.message,
+        };
+
+        return errorResponse;
+      });
+  };
+
+  const health = async (): Promise<HealthCheckMetadata> => {
+    const config = await getConfig();
+    const crtkPowerAutomateClient = ApiPowerAutomateClientFactory({
+      baseUrl: config.emailUrl,
+      apiKey: config.emailKey,
+      logger,
+    });
+
+    return crtkPowerAutomateClient
+      .health()
+      .then(() => {
+        logger.LogInfo(`CRTK Email Health Check - Id:${logId} - Successful response received.`);
+        return {
+          success: true,
+          data: {
+            message: ReasonPhrases.OK,
+          },
+        };
+      })
+      .catch(() => {
+        logger.LogError(`CRTK Email Health Check - Id:${logId} - Error received.`);
+        return {
+          success: false,
+          data: {
+            message: ReasonPhrases.INTERNAL_SERVER_ERROR,
+          },
+        };
+      });
+  };
+
+  return {
+    sendEmail,
+    health,
+  };
+};