@pdtf/schemas 3.6.0-17 → 3.6.0-19

package/src/schemas/v3/skeleton.json

@@ -1222,7 +1222,8 @@
       },
       "controlledParking": {
         "yesNo": "variant",
-        "annualCostOfPermit": "number"
+        "annualCostOfPermit": "number",
+        "costOfPermitFrequency": "string"
       },
       "vehicleTypeRestriction": {
         "yesNo": "variant",
@@ -1759,6 +1760,22 @@
         "yesNo": "variant",
         "details": "string",
         "attachments": "string"
+      },
+      "wellsDitchesShaft": {
+        "yesNo": "variant",
+        "details": "string"
+      },
+      "damagedOrExposedElectrics": {
+        "yesNo": "variant",
+        "details": "string"
+      },
+      "damageToFlooringOrStaircases": {
+        "yesNo": "variant",
+        "details": "string"
+      },
+      "knownAreasInPoorCondition": {
+        "yesNo": "variant",
+        "details": "string"
       }
     },
     "fixturesAndFittings": {
@@ -2431,6 +2448,10 @@
         "mainsWater": {
           "yesNo": "variant",
           "details": "string",
+          "associatedCost": {
+            "amount": "number",
+            "frequency": "string"
+          },
           "supplier": "string",
           "stopcock": {
             "location": "string",
@@ -2499,6 +2520,10 @@
             "dateLastServiced": "string",
             "attachments": "string",
             "details": "string"
+          },
+          "associatedCost": {
+            "amount": "number",
+            "frequency": "string"
           }
         },
         "surfaceDrainageCharge": {

package/src/tests/v3/extensionOverlays.test.js

@@ -2,6 +2,7 @@ const {
   getTransactionSchema,
   extensionOverlays,
   getValidator,
+  getSubschemaValidator,
 } = require("../../../index.js");
 
 const schemaId =
@@ -161,6 +162,9 @@ describe("Extension Overlays", () => {
         "hi",
         "fd", // Utilities & Services
         "oc", // Transaction
+        "sc",
+        "pc",
+        "ph", // SEF25
       ];
 
       expect(Object.keys(extensionOverlays).sort()).toEqual(
@@ -469,6 +473,96 @@ describe("Extension Overlays", () => {
       ).toBeTruthy();
     });
 
+    test("should merge supply costs extension into mainsWater No branch", () => {
+      const schema = getTransactionSchema(schemaId, ["sc"]);
+      const mainsWater =
+        schema.properties?.propertyPack?.properties?.waterAndDrainage
+          ?.properties?.water?.properties?.mainsWater;
+
+      expect(mainsWater?.oneOf).toBeDefined();
+
+      // Branch 0 is yesNo="No" — should now contain associatedCost
+      const noBranch = mainsWater.oneOf[0];
+      const cost = noBranch?.properties?.associatedCost;
+      expect(cost).toBeDefined();
+      expect(cost.sef25Ref).toBe("U1.1");
+      expect(cost.required).toEqual(["amount", "frequency"]);
+      expect(cost.properties.amount.type).toBe("number");
+      expect(cost.properties.frequency.type).toBe("string");
+    });
+
+    test("should merge supply costs extension into mainsFoulDrainage No/Not known branch", () => {
+      const schema = getTransactionSchema(schemaId, ["sc"]);
+      const mainsFoul =
+        schema.properties?.propertyPack?.properties?.waterAndDrainage
+          ?.properties?.drainage?.properties?.mainsFoulDrainage;
+
+      expect(mainsFoul?.oneOf).toBeDefined();
+
+      // Branch 2 is yesNo="No"/"Not known" — should now contain associatedCost
+      const noBranch = mainsFoul.oneOf[2];
+      const cost = noBranch?.properties?.associatedCost;
+      expect(cost).toBeDefined();
+      expect(cost.sef25Ref).toBe("U1.2");
+      expect(cost.required).toEqual(["amount", "frequency"]);
+    });
+
+    test("should merge parking permit frequency into controlledParking Yes branch", () => {
+      const schema = getTransactionSchema(schemaId, ["pc"]);
+      const controlled =
+        schema.properties?.propertyPack?.properties?.parking?.properties
+          ?.controlledParking;
+
+      expect(controlled?.oneOf).toBeDefined();
+
+      // Branch 1 is yesNo="Yes"
+      const yesBranch = controlled.oneOf[1];
+      const freq = yesBranch?.properties?.costOfPermitFrequency;
+      expect(freq).toBeDefined();
+      expect(freq.sef25Ref).toBe("P1.1");
+      expect(freq.type).toBe("string");
+
+      // Existing annualCostOfPermit should still be present
+      expect(yesBranch.properties.annualCostOfPermit).toBeDefined();
+    });
+
+    test("should merge all 4 property hazard fields into specialistIssues", () => {
+      const schema = getTransactionSchema(schemaId, ["ph"]);
+      const si =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties;
+
+      const expectedFields = [
+        { key: "wellsDitchesShaft", ref: "H1.1" },
+        { key: "damagedOrExposedElectrics", ref: "H1.2" },
+        { key: "damageToFlooringOrStaircases", ref: "H1.3" },
+        { key: "knownAreasInPoorCondition", ref: "H1.4" },
+      ];
+
+      expectedFields.forEach(({ key, ref }) => {
+        expect(si[key]).toBeDefined();
+        expect(si[key].sef25Ref).toBe(ref);
+        expect(si[key].required).toContain("yesNo");
+        expect(si[key].discriminator?.propertyName).toBe("yesNo");
+        expect(si[key].oneOf).toHaveLength(2);
+
+        // "No" branch should not require details
+        const noBranch = si[key].oneOf.find((b) =>
+          b.properties?.yesNo?.enum?.includes("No")
+        );
+        expect(noBranch).toBeDefined();
+        expect(noBranch.required).toBeUndefined();
+
+        // "Yes" branch should require details
+        const yesBranch = si[key].oneOf.find((b) =>
+          b.properties?.yesNo?.enum?.includes("Yes")
+        );
+        expect(yesBranch).toBeDefined();
+        expect(yesBranch.required).toContain("details");
+        expect(yesBranch.properties.details.minLength).toBe(1);
+      });
+    });
+
     test("should not require additional fields when 'No' is selected in extension overlays", () => {
       // Test the 'as' (additional searches) extension overlay
       const schema = getTransactionSchema(schemaId, ["as"]);
@@ -522,4 +616,343 @@ describe("Extension Overlays", () => {
       }
     });
   });
+
+  describe("SEF25 extension validation", () => {
+    describe("Supply costs (sc)", () => {
+      const overlays = ["baspiV5", "sc"];
+
+      test("should validate valid private water cost", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Private borehole",
+          associatedCost: {
+            amount: 50,
+            frequency: "Per month",
+          },
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should validate private water with no associated cost (cost is optional at schema level)", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Private well",
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should reject invalid frequency value for water cost", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Borehole",
+          associatedCost: {
+            amount: 100,
+            frequency: "Weekly",
+          },
+        });
+
+        expect(result).toBe(false);
+      });
+
+      test("should reject non-numeric amount for water cost", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Borehole",
+          associatedCost: {
+            amount: "fifty pounds",
+            frequency: "Per month",
+          },
+        });
+
+        expect(result).toBe(false);
+      });
+
+      test("should validate valid private sewerage cost", () => {
+        // Use sc without baspiV5 to avoid strict offMainsDrainageSystem requirements
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/drainage/mainsFoulDrainage",
+          schemaId,
+          ["sc"]
+        );
+
+        const result = validator({
+          yesNo: "No",
+          associatedCost: {
+            amount: 200,
+            frequency: "Per year",
+          },
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should reject invalid frequency for sewerage cost", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/drainage/mainsFoulDrainage",
+          schemaId,
+          ["sc"]
+        );
+
+        const result = validator({
+          yesNo: "No",
+          associatedCost: {
+            amount: 200,
+            frequency: "Quarterly",
+          },
+        });
+
+        expect(result).toBe(false);
+      });
+
+      test("should not allow associated cost when mains water is Yes", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        // When yesNo="Yes", associatedCost should cause validation failure
+        // because it's only defined in the "No" oneOf branch
+        const result = validator({
+          yesNo: "Yes",
+          supplier: "Thames Water",
+          associatedCost: {
+            amount: 50,
+            frequency: "Per month",
+          },
+        });
+
+        expect(result).toBe(false);
+      });
+    });
+
+    describe("Parking permit cost (pc)", () => {
+      const overlays = ["baspiV5", "pc"];
+
+      test("should validate valid parking permit with frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/controlledParking",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "Yes",
+          annualCostOfPermit: 150,
+          costOfPermitFrequency: "Per year",
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should validate parking permit with monthly frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/controlledParking",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "Yes",
+          annualCostOfPermit: 12.50,
+          costOfPermitFrequency: "Per month",
+        });
+
+        expect(result).toBe(true);
+      });
+
+      test("should reject invalid frequency for parking permit", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/controlledParking",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "Yes",
+          annualCostOfPermit: 150,
+          costOfPermitFrequency: "Per quarter",
+        });
+
+        expect(result).toBe(false);
+      });
+
+      test("should validate No answer without cost fields", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/controlledParking",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+        });
+
+        expect(result).toBe(true);
+      });
+    });
+
+    describe("Property hazards (ph)", () => {
+      const overlays = ["ph"];
+      const hazardFields = [
+        "wellsDitchesShaft",
+        "damagedOrExposedElectrics",
+        "damageToFlooringOrStaircases",
+        "knownAreasInPoorCondition",
+      ];
+
+      hazardFields.forEach((field) => {
+        test(`${field}: should validate "No" answer`, () => {
+          const validator = getSubschemaValidator(
+            `/propertyPack/specialistIssues/${field}`,
+            schemaId,
+            overlays
+          );
+
+          const result = validator({ yesNo: "No" });
+          expect(result).toBe(true);
+        });
+
+        test(`${field}: should validate "Yes" with details`, () => {
+          const validator = getSubschemaValidator(
+            `/propertyPack/specialistIssues/${field}`,
+            schemaId,
+            overlays
+          );
+
+          const result = validator({
+            yesNo: "Yes",
+            details: "Some description of the issue",
+          });
+          expect(result).toBe(true);
+        });
+
+        test(`${field}: should reject "Yes" without details`, () => {
+          const validator = getSubschemaValidator(
+            `/propertyPack/specialistIssues/${field}`,
+            schemaId,
+            overlays
+          );
+
+          const result = validator({ yesNo: "Yes" });
+          expect(result).toBe(false);
+        });
+
+        test(`${field}: should reject "Yes" with empty details`, () => {
+          const validator = getSubschemaValidator(
+            `/propertyPack/specialistIssues/${field}`,
+            schemaId,
+            overlays
+          );
+
+          const result = validator({ yesNo: "Yes", details: "" });
+          expect(result).toBe(false);
+        });
+
+        test(`${field}: should reject invalid yesNo value`, () => {
+          const validator = getSubschemaValidator(
+            `/propertyPack/specialistIssues/${field}`,
+            schemaId,
+            overlays
+          );
+
+          const result = validator({ yesNo: "Maybe" });
+          expect(result).toBe(false);
+        });
+      });
+    });
+
+    describe("Combined SEF25 extensions", () => {
+      test("should load all three SEF25 extensions together", () => {
+        const schema = getTransactionSchema(schemaId, [
+          "baspiV5",
+          "sc",
+          "pc",
+          "ph",
+        ]);
+
+        // Supply costs
+        const waterCost =
+          schema.properties?.propertyPack?.properties?.waterAndDrainage
+            ?.properties?.water?.properties?.mainsWater?.oneOf?.[0]?.properties
+            ?.associatedCost;
+        expect(waterCost).toBeDefined();
+
+        const sewerageCost =
+          schema.properties?.propertyPack?.properties?.waterAndDrainage
+            ?.properties?.drainage?.properties?.mainsFoulDrainage?.oneOf?.[2]
+            ?.properties?.associatedCost;
+        expect(sewerageCost).toBeDefined();
+
+        // Parking
+        const parkingFreq =
+          schema.properties?.propertyPack?.properties?.parking?.properties
+            ?.controlledParking?.oneOf?.[1]?.properties?.costOfPermitFrequency;
+        expect(parkingFreq).toBeDefined();
+
+        // Hazards
+        const si =
+          schema.properties?.propertyPack?.properties?.specialistIssues
+            ?.properties;
+        expect(si?.wellsDitchesShaft).toBeDefined();
+        expect(si?.damagedOrExposedElectrics).toBeDefined();
+        expect(si?.damageToFlooringOrStaircases).toBeDefined();
+        expect(si?.knownAreasInPoorCondition).toBeDefined();
+      });
+
+      test("should not interfere with existing NTS2 extensions", () => {
+        const schema = getTransactionSchema(schemaId, [
+          "nts2023",
+          "jk",
+          "hs",
+          "sc",
+          "pc",
+          "ph",
+        ]);
+
+        const si =
+          schema.properties?.propertyPack?.properties?.specialistIssues;
+
+        // Existing NTS2 extensions still work
+        expect(si?.properties?.japaneseKnotweed?.ntsRef).toBe("A5.3");
+        expect(si?.properties?.ongoingHealthOrSafetyIssue?.ntsRef).toBe(
+          "A5.5"
+        );
+        expect(si?.required).toContain("japaneseKnotweed");
+        expect(si?.required).toContain("ongoingHealthOrSafetyIssue");
+
+        // SEF25 hazards also present
+        expect(si?.properties?.wellsDitchesShaft?.sef25Ref).toBe("H1.1");
+        expect(si?.properties?.knownAreasInPoorCondition?.sef25Ref).toBe(
+          "H1.4"
+        );
+      });
+    });
+  });
 });

package/src/tests/v3/ta7ed5.test.js

@@ -237,9 +237,9 @@ describe("TA7 5th edition overlay", () => {
       expect(validator({ collector: "Landlord" })).toBe(true);
     });
 
-    test("valid with Management company (no otherCollector needed)", () => {
+    test("valid with Management Company (no otherCollector needed)", () => {
       const validator = getSubschemaValidator(path, schemaId, overlays);
-      expect(validator({ collector: "Management company" })).toBe(true);
+      expect(validator({ collector: "Management Company" })).toBe(true);
     });
 
     test("invalid with Other when otherCollector is missing", () => {
@@ -290,7 +290,7 @@ describe("TA7 5th edition overlay", () => {
           ?.collectsGroundRent?.properties?.collector;
       expect(collector?.enum).toEqual([
         "Landlord",
-        "Management company",
+        "Management Company",
         "Other",
       ]);
     });
@@ -324,8 +324,8 @@ describe("TA7 5th edition overlay", () => {
       for (const value of [
         "Freeholder",
         "Landlord",
-        "Management company",
-        "Head leaseholder",
+        "Management Company",
+        "Head Leaseholder",
         "Seller",
       ]) {
         expect(validator({ collector: value })).toBe(true);
@@ -379,8 +379,8 @@ describe("TA7 5th edition overlay", () => {
       expect(collector?.enum).toEqual([
         "Freeholder",
         "Landlord",
-        "Management company",
-        "Head leaseholder",
+        "Management Company",
+        "Head Leaseholder",
         "Seller",
         "Other",
       ]);
@@ -411,7 +411,7 @@ describe("TA7 5th edition overlay", () => {
       expect(
         validator({
           collectsGroundRent: { collector: "Landlord" },
-          collectsbuildingInsurancePremiums: { collector: "Management company" },
+          collectsbuildingInsurancePremiums: { collector: "Management Company" },
         })
       ).toBe(true);
     });
@@ -552,10 +552,10 @@ describe("TA7 5th edition overlay", () => {
       });
       expect(collectsInsurance.oneOf).toHaveLength(2);
 
-      // Branch 1: non-Other values (5 options)
+      // Branch 1: non-Other values (superset of all overlay values)
       const branch1Enum =
         collectsInsurance.oneOf[0].properties.collector.enum;
-      expect(branch1Enum).toHaveLength(5);
+      expect(branch1Enum).toHaveLength(7);
       expect(branch1Enum).not.toContain("Other");
 
       // Branch 2: Other + required otherCollector