fix: [AB#17340] automatic biz name availability search should use formationFormData.businessName

Author: jphechter

api/src/api/userRouter.test.ts

@@ -6,6 +6,7 @@ import { getCurrentDate, parseDate } from "@shared/dateHelpers";
 import { getCurrentBusiness } from "@shared/domain-logic/getCurrentBusiness";
 import { modifyCurrentBusiness } from "@shared/domain-logic/modifyCurrentBusiness";
 import { createEmptyFormationFormData, emptyAddressData } from "@shared/formationData";
+import { randomInt } from "@shared/intHelpers";
 import { LicenseName } from "@shared/license";
 import {
   generateBusiness,
@@ -593,6 +594,51 @@ describe("userRouter", () => {
       });
 
       describe("when businessPersona is 'STARTING'", () => {
+        it("checks name availability using name from formationFormData", async () => {
+          const userData = generateUserDataForBusiness(
+            generateBusiness({
+              profileData: generateStartingProfileData({
+                businessName: "Business Name in Profile",
+              }),
+              formationData: generateFormationData({
+                businessNameAvailability: generateBusinessNameAvailability({
+                  status: "AVAILABLE",
+                  lastUpdatedTimeStamp: sixtyOneMinutesAgo,
+                }),
+                formationFormData: generateFormationFormData({
+                  businessName: "Business Name in Formation Form Data",
+                }),
+              }),
+            }),
+          );
+          stubUnifiedDataClient.get.mockResolvedValue(userData);
+
+          await request(app).get(`/users/123`).set("Authorization", "Bearer user-123-token");
+          expect(stubTimeStampBusinessSearch.search).toHaveBeenCalledWith(
+            "Business Name in Formation Form Data",
+          );
+        });
+
+        it("does not check name availability if formationFormData.businessName is an empty string", async () => {
+          const userData = generateUserDataForBusiness(
+            generateBusiness({
+              formationData: generateFormationData({
+                businessNameAvailability: generateBusinessNameAvailability({
+                  status: "AVAILABLE",
+                  lastUpdatedTimeStamp: sixtyOneMinutesAgo,
+                }),
+                formationFormData: generateFormationFormData({
+                  businessName: "",
+                }),
+              }),
+            }),
+          );
+          stubUnifiedDataClient.get.mockResolvedValue(userData);
+
+          await request(app).get(`/users/123`).set("Authorization", "Bearer user-123-token");
+          expect(stubTimeStampBusinessSearch.search).not.toHaveBeenCalled();
+        });
+
         it("does not update business name search if businessNameAvailability is undefined", async () => {
           const userData = generateUserDataForBusiness(
             generateBusiness({
@@ -733,13 +779,38 @@ describe("userRouter", () => {
 
           await request(app).get(`/users/123`).set("Authorization", "Bearer user-123-token");
           expect(stubTimeStampBusinessSearch.search).toHaveBeenCalledWith(
-            getCurrentBusiness(userData).profileData.businessName,
+            getCurrentBusiness(userData).formationData.formationFormData.businessName,
           );
           expect(stubUpdateOperatingPhase).toHaveBeenCalledWith(userData);
         });
       });
 
       describe("when businessPersona is 'FOREIGN' and Foreign type is Nexus", () => {
+        it("does not seach when nexusDbaName is an empty string", async () => {
+          const userData = generateUserDataForBusiness(
+            generateBusiness({
+              profileData: generateProfileData({
+                businessPersona: "FOREIGN",
+                foreignBusinessTypeIds: ["employeeOrContractorInNJ"],
+              }),
+              formationData: generateFormationData({
+                completedFilingPayment: false,
+                businessNameAvailability: generateBusinessNameAvailability({
+                  status: "UNAVAILABLE",
+                }),
+                dbaBusinessNameAvailability: generateBusinessNameAvailability({
+                  status: "AVAILABLE",
+                  lastUpdatedTimeStamp: sixtyOneMinutesAgo,
+                }),
+              }),
+            }),
+          );
+          stubUnifiedDataClient.get.mockResolvedValue(userData);
+
+          await request(app).get(`/users/123`).set("Authorization", "Bearer user-123-token");
+          expect(stubTimeStampBusinessSearch.search).not.toHaveBeenCalled();
+        });
+
         it("does not recheck business name availability if businessNameAvailability and dbaBusinessNameAvailability are undefined", async () => {
           const userData = generateUserDataForBusiness(
             generateBusiness({
@@ -904,6 +975,7 @@ describe("userRouter", () => {
           const userData = generateUserDataForBusiness(
             generateBusiness({
               profileData: generateProfileData({
+                nexusDbaName: `some-dbaName-${randomInt()}`,
                 businessPersona: "FOREIGN",
                 foreignBusinessTypeIds: ["employeeOrContractorInNJ"],
               }),

api/src/api/userRouter.ts

@@ -418,7 +418,14 @@ export const userRouterFactory = (
       const needsDba = determineIfNexusDbaNameNeeded(currentBusiness);
       const nameToSearch = needsDba
         ? currentBusiness.profileData.nexusDbaName
-        : currentBusiness.profileData.businessName;
+        : currentBusiness.formationData.formationFormData.businessName;
+
+      if (nameToSearch === "") {
+        logger.LogInfo("Skipping name availability search - no name entered yet");
+        return userData;
+      }
+      logger.LogInfo(`Executing name availability search for ${nameToSearch}`);
+
       const response = await timeStampBusinessSearch.search(nameToSearch);
 
       const nameAvailability: NameAvailability = {

api/src/libs/logWriter.ts

@@ -29,7 +29,8 @@ export const DummyLogWriter: LogWriterType = {
 export const ConsoleLogWriter: LogWriterType = {
   LogError: async (message: string, details?: AxiosError): Promise<void> => {
     try {
-      console.error(`${message} - ${JSON.stringify(details?.toJSON())}`);
+      const jsonDetails = typeof details?.toJSON === "function" ? details.toJSON() : details;
+      console.error(`${message} - ${JSON.stringify(jsonDetails)}`);
     } catch (error) {
       console.error(`Error with LogError:${error}`);
     }