fix: Ensure input postcode is always parsed

app/api/route.test.ts

@@ -2,7 +2,6 @@ import { POST } from "../api/route";
 import * as calculationService from "../services/calculationService";
 import calculateFairhold from "../models/testClasses";
 import { NextResponse } from "next/server";
-import { calculationSchema, Calculation } from "../schemas/calculationSchema";
 
 // Mock dependencies
 jest.mock("../services/calculationService");
@@ -18,7 +17,7 @@ const callResponse = (res: unknown) => {
 };
 
 describe("POST API Route", () => {
-  const mockRequest = (data: Calculation | string) => ({
+  const mockRequest = (data: unknown) => ({
     json: jest.fn().mockResolvedValueOnce(data),
   });
 
@@ -27,14 +26,14 @@ describe("POST API Route", () => {
   });
 
   it("should return processed data for valid apiSchema input", async () => {
-    const validApiInput = calculationSchema.parse({
+    const validApiInput = {
       housePostcode: "SE17 1PE",
       houseSize: 100,
       houseAge: 3,
       houseBedrooms: 2,
       houseType: "D",
       maintenancePercentage: 0.02,
-    });
+    };
 
     const householdData = {
       /* mock household data */
@@ -54,9 +53,21 @@ describe("POST API Route", () => {
     const res = await POST(req as unknown as Request);
 
     // Assertions
-    expect(calculationService.getHouseholdData).toHaveBeenCalledWith(
-      validApiInput
-    );
+    expect(calculationService.getHouseholdData).toHaveBeenCalledWith({
+      ...validApiInput,
+      // Parsed postcode object
+      housePostcode: {
+        area: "SE",
+        district: "SE17",
+        incode: "1PE",
+        outcode: "SE17",
+        postcode: "SE17 1PE",
+        sector: "SE17 1",
+        subDistrict: null,
+        unit: "PE",
+        valid: true,
+      },
+    });
     expect(calculateFairhold).toHaveBeenCalledWith(householdData);
     expect(res).toEqual(NextResponse.json(processedData));
   });
@@ -77,14 +88,14 @@ describe("POST API Route", () => {
   });
 
   it("should handle service errors", async () => {
-    const validApiInput = calculationSchema.parse({
+    const validApiInput = {
       housePostcode: "SE17 1PE",
       houseSize: 100,
       houseAge: 3,
       houseBedrooms: 2,
       houseType: "D",
       maintenancePercentage: 0.02,
-    });
+    };
 
     const errorMessage = "Service error";
 
@@ -98,9 +109,21 @@ describe("POST API Route", () => {
     callResponse(res);
 
     // Assertions
-    expect(calculationService.getHouseholdData).toHaveBeenCalledWith(
-      validApiInput
-    );
+    expect(calculationService.getHouseholdData).toHaveBeenCalledWith({
+      ...validApiInput,
+      // Parsed postcode object
+      housePostcode: { 
+        area: "SE",
+        district: "SE17",
+        incode: "1PE",
+        outcode: "SE17",
+        postcode: "SE17 1PE",
+        sector: "SE17 1",
+        subDistrict: null,
+        unit: "PE",
+        valid: true,
+      },
+    });
     expect(NextResponse.json).toHaveBeenCalledWith(
       { error: errorMessage },
       { status: 500 }

app/api/route.ts

@@ -1,5 +1,4 @@
 import { NextResponse } from "next/server";
-import { api, apiSchema } from "../schemas/apiSchema";
 import { calculationSchema } from "../schemas/calculationSchema";
 import * as calculationService from "../services/calculationService";
 import calculateFairhold from "../models/testClasses";
@@ -8,12 +7,7 @@ export async function POST(req: Request) {
   try {
     // Parse and validate user input
     const data = await req.json();
-    let input: api;
-    if (!apiSchema.safeParse(data).success) {
-      input = calculationSchema.parse(data);
-    } else {
-      input = data;
-    }
+    const input = calculationSchema.parse(data);
     const householdData = await calculationService.getHouseholdData(input);
     const processedData = calculateFairhold(householdData);
     return NextResponse.json(processedData);

app/data/itlRepo.ts

@@ -13,8 +13,7 @@ const getItl3ByPostcodeDistrict = async (
       },
     });
 
-    // Cast to string as 'not: null' clause in Prisma query does not type narrow
-    return itl3 as string;
+    return itl3;
   } catch (error) {
     throw new Error(
       `Data error: Unable get get itl3 for postcode district ${postcodeDistrict}`

app/models/testClasses.ts

@@ -1,4 +1,4 @@
-import { ValidPostcode } from "../schemas/apiSchema";
+import { ValidPostcode } from './../schemas/calculationSchema';
 import { createForecastParameters } from "./ForecastParameters";
 import { Household } from "./Household";
 import { HouseType, MaintenancePercentage, Property } from "./Property";

app/schemas/calculationSchema.ts

@@ -1,10 +1,13 @@
 import { z } from "zod";
-import { parse as parsePostcode, fix as fixPostcode } from "postcode";
+import {
+  parse as parsePostcode,
+  isValid as isValidPostcode,
+} from "postcode";
 import { HOUSE_TYPES } from "../models/Property";
 import { MAINTENANCE_LEVELS } from "../models/constants";
 
 // Type not exported by postcode lib directly
-type ValidPostcode = Extract<ReturnType<typeof parsePostcode>, { valid: true }>;
+export type ValidPostcode = Extract<ReturnType<typeof parsePostcode>, { valid: true }>;
 
 const HouseTypeEnum = z.enum(HOUSE_TYPES);
 
@@ -23,7 +26,7 @@ export const calculationSchema = z.object({
   housePostcode: z
     .string()
     .min(1, "housePostcode is required")
-    .refine(fixPostcode, "Invalid postcode")
+    .refine(isValidPostcode, "Invalid postcode")
     .transform(parsePostcode)
     .refine((postcode): postcode is ValidPostcode => postcode.valid),
   houseSize: z.coerce.number().positive("houseSize must be a positive integer"),

app/schemas/formSchema.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { fix as fixPostcode } from "postcode";
+import { isValid as isValidPostcode } from "postcode";
 import { HOUSE_TYPES } from "../models/Property";
 import { maintenancePercentageSchema } from "../schemas/calculationSchema";
 
@@ -11,17 +11,17 @@ const HouseTypeEnum = z.enum(HOUSE_TYPES);
 export const formSchema = z.object({
   housePostcode: z
     .string()
-    .min(1, "housePostcode is required")
-    .refine(fixPostcode, "Invalid postcode"),
-  houseSize: z.coerce.number().positive("houseSize must be a positive integer"),
-  houseAge: z.coerce.number().positive("houseAge must be a positive integer"),
+    .min(1, "Postcode is required")
+    .refine(isValidPostcode, "Invalid postcode"),
+  houseSize: z.coerce.number().positive("House size must be a positive number"),
+  houseAge: z.coerce.number().positive("House age must be a positive number"),
   houseBedrooms: z.coerce
     .number()
-    .positive("houseBedrooms must be a positive integer"),
+    .positive("House bedrooms must be a positive number"),
   houseType: HouseTypeEnum.refine(
     (value) => HouseTypeEnum.options.includes(value),
     {
-      message: `houseType is required and must be one of ${HOUSE_TYPES}`,
+      message: `House type is required`,
     }
   ),
   maintenancePercentage: maintenancePercentageSchema,

app/services/calculationService.test.ts

@@ -10,7 +10,7 @@ import { socialRentAdjustmentsService } from "./socialRentAdjustmentsService";
 import { socialRentEarningsService } from "./socialRentEarningsService";
 import { rentService } from "./rentService";
 import { parse } from "postcode";
-import { ValidPostcode } from "../schemas/apiSchema";
+import { ValidPostcode } from "../schemas/calculationSchema";
 
 jest.mock("./itlService");
 jest.mock("./gdhiService");