feat(backend): allow minimal waitlist POST data (#1072)

* feat(core): update subscriber schema to allow nullable fields object

* fix(backend): update error message for missing emailer values

* feat(core): add v2 schema for waitlist answers with email validation

* feat(backend): add utility function to map waitlist answers to subscriber format

* fix(backend): update error message for missing emailer values

* feat(backend): enhance waitlist service to support v2 answer schema and update mapping utility

* test(backend): add tests for waitlist controller to support v2 answer schema

* test(backend): add validation tests for waitlist controller to handle missing schema version

* style(web): format onChange function in FreqSelect component for better readability

* Update packages/backend/src/waitlist/controller/waitlist.controller.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fix(backend): update error message for missing emailer configuration

* fix(backend): include fields in email subscriber mapping for schema version 1

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: tyler-dane

packages/backend/src/__tests__/drivers/email.driver.ts

@@ -40,11 +40,13 @@ export class EmailDriver {
     },
     tagId: string,
   ): Promise<Response_TagSubscriber> {
+    const fields = subscriber.fields ?? undefined;
     return Promise.resolve({
       subscriber: {
         tagId,
         ...subscriber,
         tagged_at: new Date().toISOString(),
+        fields,
         first_name: subscriber.first_name!,
       },
     });
@@ -53,9 +55,11 @@ export class EmailDriver {
   private static async upsertSubscriber(
     subscriber: Subscriber & { id: number; created_at: string },
   ): Promise<Response_UpsertSubscriber> {
+    const fields = subscriber.fields ?? undefined;
     return Promise.resolve({
       subscriber: {
         ...subscriber,
+        fields,
         first_name: subscriber.first_name!,
       },
     });

packages/backend/src/waitlist/controller/waitlist.controller-add.test.ts

@@ -1,41 +1,80 @@
+import type { Express } from "express";
 import request from "supertest";
-import type { Answers_v1 } from "@core/types/waitlist/waitlist.answer.types";
+import type {
+  Answers_v1,
+  Answers_v2,
+} from "@core/types/waitlist/waitlist.answer.types";
 
 describe("POST /api/waitlist", () => {
-  beforeEach(() => jest.resetModules());
-  it("should return 400 if answers are invalid", async () => {
-    jest.doMock("../service/waitlist.service", () => ({
-      __esModule: true,
-      default: {
-        addToWaitlist: jest.fn(),
-      },
-    }));
+  let app: Express;
+  let mockAddToWaitlist: jest.Mock;
+
+  const createTestApp = async (mocks?: {
+    env?: Record<string, unknown>;
+    service?: Record<string, unknown>;
+  }) => {
+    if (mocks?.env) {
+      jest.doMock("@backend/common/constants/env.constants", () => mocks.env);
+    }
+    if (mocks?.service) {
+      jest.doMock("../service/waitlist.service", () => mocks.service);
+    }
+
     const { WaitlistController } = await import("./waitlist.controller");
     const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    const testApp = express();
+    testApp.use(express.json());
+    testApp.post("/api/waitlist", WaitlistController.addToWaitlist);
+    return testApp;
+  };
+
+  beforeEach(() => {
+    jest.resetModules();
+    mockAddToWaitlist = jest.fn();
+  });
+
+  it("should return 400 if answers are invalid", async () => {
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
 
     const res = await request(app)
       .post("/api/waitlist")
       .send({ email: "", name: "" });
 
     expect(res.status).toBe(400);
     expect(res.error).toBeDefined();
+    expect(mockAddToWaitlist).not.toHaveBeenCalled();
   });
 
-  it("should return 200 if answers are valid", async () => {
-    jest.doMock("../service/waitlist.service", () => ({
-      __esModule: true,
-      default: {
-        addToWaitlist: jest.fn().mockResolvedValue(undefined),
+  it("should return 400 if schema version is missing", async () => {
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
       },
-    }));
-    const { WaitlistController } = await import("./waitlist.controller");
-    const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    });
+
+    const res = await request(app)
+      .post("/api/waitlist")
+      .send({ email: "test@example.com" });
+
+    expect(res.status).toBe(400);
+    expect(res.error).toBeDefined();
+    expect(mockAddToWaitlist).not.toHaveBeenCalled();
+  });
+
+  it("should return 200 if v1 answers are valid", async () => {
+    mockAddToWaitlist.mockResolvedValue(undefined);
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
 
     const answers: Answers_v1 = {
       email: "test@example.com",
@@ -47,22 +86,43 @@ describe("POST /api/waitlist", () => {
       currentlyPayingFor: [],
       anythingElse: "I'm a test",
     };
+
+    const res = await request(app).post("/api/waitlist").send(answers);
+
+    expect(res.status).toBe(200);
+    expect(res.body.error).not.toBeDefined();
+    expect(mockAddToWaitlist).toHaveBeenCalledWith(answers.email, answers);
+  });
+
+  it("should return 200 if v2 answers are valid", async () => {
+    mockAddToWaitlist.mockResolvedValue(undefined);
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
+
+    const answers: Answers_v2 = {
+      email: "test@example.com",
+      schemaVersion: "2",
+    };
+
     const res = await request(app).post("/api/waitlist").send(answers);
 
     expect(res.status).toBe(200);
     expect(res.body.error).not.toBeDefined();
+    expect(mockAddToWaitlist).toHaveBeenCalledWith(answers.email, answers);
   });
-  // this test is at the bottom to avoid
-  // having to reset ENV in each test
+
   it("should return 500 if emailer values are missing", async () => {
-    jest.doMock("@backend/common/constants/env.constants", () => ({
-      ENV: {},
-    }));
-    const { WaitlistController } = await import("./waitlist.controller");
-    const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    app = await createTestApp({
+      env: { ENV: {} },
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
 
     const answers: Answers_v1 = {
       email: "test@example.com",
@@ -73,8 +133,11 @@ describe("POST /api/waitlist", () => {
       currentlyPayingFor: [],
       profession: "Founder",
     };
+
     const res = await request(app).post("/api/waitlist").send(answers);
     expect(res.status).toBe(500);
-    expect(res.body.error).toBe("Emailer values are missing");
+    expect(res.body.error).toBe(
+      "Missing required emailer configuration: EMAILER_SECRET or EMAILER_WAITLIST_TAG_ID",
+    );
   });
 });

packages/backend/src/waitlist/controller/waitlist.controller.ts

@@ -2,54 +2,61 @@ import { Request, Response } from "express";
 import { z } from "zod";
 import { BaseError } from "@core/errors/errors.base";
 import { Logger } from "@core/logger/winston.logger";
-import { Answers } from "@core/types/waitlist/waitlist.answer.types";
-import { Schema_Waitlist } from "@core/types/waitlist/waitlist.types";
+import {
+  Answers,
+  Answers_v1,
+  Answers_v2,
+} from "@core/types/waitlist/waitlist.answer.types";
 import { isMissingWaitlistTagId } from "@backend/common/constants/env.util";
 import { findCompassUserBy } from "../../user/queries/user.queries";
 import WaitlistService from "../service/waitlist.service";
 import { EmailSchema } from "../types/waitlist.types";
 
 const logger = Logger("app:waitlist.controller");
+const WaitlistAnswerSchema = Answers.v1.or(Answers.v2);
 
 export class WaitlistController {
   private static EmailQuerySchema = z.object({ email: EmailSchema });
 
+  private static handleError(err: unknown, res: Response) {
+    if (err instanceof BaseError) {
+      logger.error(err);
+      return res.status(err.statusCode).json({ error: err.description });
+    }
+    if (err instanceof Error) {
+      logger.error(err);
+      return res.status(500).json({ error: err.message });
+    }
+    logger.error("caught unknown error");
+    return res.status(500).json({ error: "Server error" });
+  }
+
   static async addToWaitlist(
-    req: Request<unknown, unknown, Schema_Waitlist>,
+    req: Request<unknown, unknown, Answers_v1 | Answers_v2>,
     res: Response,
   ) {
     if (isMissingWaitlistTagId()) {
-      return res.status(500).json({ error: "Emailer values are missing" });
+      return res.status(500).json({
+        error:
+          "Missing required emailer configuration: EMAILER_SECRET or EMAILER_WAITLIST_TAG_ID",
+      });
     }
 
-    const parseResult = Answers.v1.safeParse(req.body);
+    const parseResult = WaitlistAnswerSchema.safeParse(req.body);
     if (!parseResult.success) {
       return res
         .status(400)
-        .json({ error: "Invalid input", details: parseResult.error.flatten() });
+        .json({ error: "Invalid waitlist data", details: parseResult.error });
     }
 
-    const answers = parseResult.data;
     try {
       const result = await WaitlistService.addToWaitlist(
-        answers.email,
-        answers,
+        parseResult.data.email,
+        parseResult.data,
       );
       return res.status(200).json(result);
     } catch (err) {
-      // If the error is a BaseError (including EmailerError), return its status and description
-      if (err instanceof BaseError) {
-        logger.error(err);
-        return res.status(err.statusCode).json({ error: err.description });
-      }
-      // If it's a generic Error, return its message
-      if (err instanceof Error) {
-        logger.error(err);
-        return res.status(500).json({ error: err.message });
-      }
-      // Otherwise, return a generic server error
-      logger.error("caught unknown error");
-      return res.status(500).json({ error: "Server error" });
+      return WaitlistController.handleError(err, res);
     }
   }
 
@@ -81,14 +88,22 @@ export class WaitlistController {
         findCompassUserBy("email", email),
         WaitlistService.getWaitlistRecord(email),
       ]);
+
     const isActive = !!existingUser;
-    const status = {
+    const name =
+      waitlistRecord && "firstName" in waitlistRecord
+        ? {
+            firstName: waitlistRecord.firstName,
+            lastName: waitlistRecord.lastName,
+          }
+        : undefined;
+
+    return res.status(200).json({
       isOnWaitlist,
       isInvited,
       isActive,
-      firstName: waitlistRecord?.firstName ?? existingUser?.firstName,
-      lastName: waitlistRecord?.lastName ?? existingUser?.lastName,
-    };
-    return res.status(200).json(status);
+      firstName: name?.firstName ?? existingUser?.firstName,
+      lastName: name?.lastName ?? existingUser?.lastName,
+    });
   }
 }

packages/backend/src/waitlist/service/waitlist.service.ts

@@ -1,7 +1,9 @@
 import { Logger } from "@core/logger/winston.logger";
 import { mapWaitlistUserToEmailSubscriber } from "@core/mappers/subscriber/map.subscriber";
-import { Subscriber } from "@core/types/email/email.types";
-import { Answers_v1 } from "@core/types/waitlist/waitlist.answer.types";
+import {
+  Answers_v1,
+  Answers_v2,
+} from "@core/types/waitlist/waitlist.answer.types";
 import {
   Result_InviteToWaitlist,
   Result_Waitlist,
@@ -11,24 +13,17 @@ import { isMissingWaitlistInviteTagId } from "@backend/common/constants/env.util
 import { Response_TagSubscriber } from "@backend/email/email.types";
 import EmailService from "../../email/email.service";
 import { WaitlistRepository } from "../repo/waitlist.repo";
+import { mapWaitlistAnswerToSubscriber } from "./waitlist.service.util";
 
 const logger = Logger("app:waitlist.service");
+
 class WaitlistService {
   static async addToWaitlist(
     email: string,
-    answer: Answers_v1,
+    answer: Answers_v1 | Answers_v2,
   ): Promise<Result_Waitlist> {
     if (ENV.EMAILER_SECRET && ENV.EMAILER_WAITLIST_TAG_ID) {
-      const subscriber: Subscriber = {
-        email_address: email,
-        first_name: answer.firstName,
-        state: "active",
-        fields: {
-          "Last name": answer.lastName,
-          Birthday: "1970-01-01",
-          Source: answer.source,
-        },
-      };
+      const subscriber = mapWaitlistAnswerToSubscriber(email, answer);
       await EmailService.addTagToSubscriber(
         subscriber,
         ENV.EMAILER_WAITLIST_TAG_ID,