@pdtf/schemas 3.6.0-36 → 3.6.0-38

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

@@ -165,6 +165,15 @@ describe("Extension Overlays", () => {
         "sc",
         "pc",
         "ph", // SEF25
+        "dk",
+        "rw",
+        "sd",
+        "lc",
+        "wg",
+        "ic",
+        "nd",
+        "mi",
+        "tr", // SEF25 (new)
       ];
 
       expect(Object.keys(extensionOverlays).sort()).toEqual(
@@ -486,9 +495,14 @@ describe("Extension Overlays", () => {
       const cost = noBranch?.properties?.associatedCost;
       expect(cost).toBeDefined();
       expect(cost.ntsRef).toBe("U1.1");
-      expect(cost.required).toEqual(["amount", "frequency"]);
-      expect(cost.properties.amount.type).toBe("number");
+      expect(cost.required).toEqual(["frequency"]);
       expect(cost.properties.frequency.type).toBe("string");
+      // amount now lives inside the frequency-discriminator's "Per month"/"Per year" branch
+      const costBranch = cost.oneOf?.find((b) =>
+        b.properties?.frequency?.enum?.includes("Per month")
+      );
+      expect(costBranch?.properties?.amount?.type).toBe("number");
+      expect(costBranch?.required).toEqual(["amount"]);
     });
 
     test("should merge supply costs extension into mainsFoulDrainage No/Not known branch", () => {
@@ -504,7 +518,13 @@ describe("Extension Overlays", () => {
       const cost = noBranch?.properties?.associatedCost;
       expect(cost).toBeDefined();
       expect(cost.ntsRef).toBe("U1.2");
-      expect(cost.required).toEqual(["amount", "frequency"]);
+      expect(cost.required).toEqual(["frequency"]);
+      // amount now lives inside the frequency-discriminator's "Per month"/"Per year" branch
+      const costBranch = cost.oneOf?.find((b) =>
+        b.properties?.frequency?.enum?.includes("Per month")
+      );
+      expect(costBranch?.properties?.amount?.type).toBe("number");
+      expect(costBranch?.required).toEqual(["amount"]);
     });
 
     test("should merge parking permit cost and frequency into controlledParking Yes branch", () => {
@@ -642,6 +662,25 @@ describe("Extension Overlays", () => {
         expect(result).toBe(true);
       });
 
+      test("should validate private water with no associated costs", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/waterAndDrainage/water/mainsWater",
+          schemaId,
+          overlays
+        );
+
+        const result = validator({
+          yesNo: "No",
+          details: "Private borehole",
+          associatedCost: {
+            amount: 0,
+            frequency: "Not applicable",
+          },
+        });
+
+        expect(result).toBe(true);
+      });
+
       test("should require associated cost for private water supply", () => {
         const validator = getSubschemaValidator(
           "/propertyPack/waterAndDrainage/water/mainsWater",
@@ -957,5 +996,374 @@ describe("Extension Overlays", () => {
         );
       });
     });
+
+    describe("Dropped kerb (dk)", () => {
+      test("should validate Yes answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(true);
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should reject invalid value", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/parking/droppedKerbAccess",
+          schemaId,
+          ["dk"]
+        );
+        expect(validator({ yesNo: "Maybe" })).toBe(false);
+      });
+
+      test("should not be required without dk overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const parking = schema.properties?.propertyPack?.properties?.parking;
+        expect(parking?.required || []).not.toContain("droppedKerbAccess");
+      });
+
+      test("should be required with dk overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["dk"]);
+        const parking = schema.properties?.propertyPack?.properties?.parking;
+        expect(parking?.required).toContain("droppedKerbAccess");
+      });
+    });
+
+    describe("Private right of way (rw)", () => {
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Neighbour has access through garden" })).toBe(true);
+      });
+
+      test("should reject Yes without details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(false);
+      });
+
+      test("should reject Yes with empty details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/rightsAndInformalArrangements/rightsOrArrangements/privateRightOfWay",
+          schemaId,
+          ["rw"]
+        );
+        expect(validator({ yesNo: "Yes", details: "" })).toBe(false);
+      });
+
+      test("should not be required without rw overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements;
+        expect(rights?.required || []).not.toContain("privateRightOfWay");
+      });
+
+      test("should be required with rw overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["rw"]);
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements;
+        expect(rights?.required).toContain("privateRightOfWay");
+      });
+    });
+
+    describe("Storm/fire/flood damage (sd)", () => {
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Flood damage in 2020" })).toBe(true);
+      });
+
+      test("should reject Yes without details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/environmentalIssues/stormFireFloodDamage",
+          schemaId,
+          ["sd"]
+        );
+        expect(validator({ yesNo: "Yes" })).toBe(false);
+      });
+
+      test("should not be required without sd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues;
+        expect(env?.required || []).not.toContain("stormFireFloodDamage");
+      });
+
+      test("should be required with sd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["sd"]);
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues;
+        expect(env?.required).toContain("stormFireFloodDamage");
+      });
+    });
+
+    describe("Solar lease costs (lc)", () => {
+      test("should validate Not applicable frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 0, frequency: "Not applicable" })).toBe(true);
+      });
+
+      test("should validate amount and frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75, frequency: "Per month" })).toBe(true);
+      });
+
+      test("should reject missing amount", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ frequency: "Per month" })).toBe(false);
+      });
+
+      test("should reject missing frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75 })).toBe(false);
+      });
+
+      test("should reject invalid frequency", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/electricity/solarPanels/panelsOwnedOutright/associatedCost",
+          schemaId,
+          ["lc"]
+        );
+        expect(validator({ amount: 75, frequency: "Weekly" })).toBe(false);
+      });
+    });
+
+    describe("Warranties and guarantees (wg)", () => {
+      const warrantyCategoryPaths = [
+        { path: "newHomeWarranty", ref: "W1.1" },
+        { path: "roofingWork", ref: "W1.2" },
+        { path: "dampProofingTreatment", ref: "W1.3" },
+        { path: "centralHeatingAndorPlumbing", ref: "W1.4" },
+        { path: "electricalRepairOrInstallation", ref: "W1.5" },
+        { path: "subsidenceWork", ref: "W1.6" },
+        { path: "otherGuarantees", ref: "W1.7" },
+      ];
+
+      test("should have ntsRef on all warranty categories when wg overlay loaded", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", "wg"]);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        // Warranty fields are in oneOf[1] (hasValidGuaranteesOrWarranties = Yes)
+        const yesBranch = warranties.oneOf[1];
+
+        warrantyCategoryPaths.forEach(({ path, ref }) => {
+          expect(yesBranch.properties[path]?.ntsRef).toBe(ref);
+        });
+      });
+
+      test("should mark warranty categories as required when wg overlay loaded", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", "wg"]);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        const yesBranch = warranties.oneOf[1];
+        warrantyCategoryPaths.forEach(({ path }) => {
+          expect(yesBranch.required).toContain(path);
+        });
+      });
+
+      test("should not require warranty categories without any overlay", () => {
+        const schema = getTransactionSchema(schemaId, []);
+        const warranties =
+          schema.properties?.propertyPack?.properties?.guaranteesWarrantiesAndIndemnityInsurances;
+
+        const yesBranch = warranties.oneOf[1];
+        // Without any overlay, warranty categories should not be in required
+        expect(yesBranch.required || []).not.toContain("newHomeWarranty");
+        expect(yesBranch.required || []).not.toContain("electricalRepairOrInstallation");
+      });
+    });
+
+    describe("Insurance claims (ic)", () => {
+      test("should mark insuranceClaims as required in isInsured=Yes branch", () => {
+        const schema = getTransactionSchema(schemaId, ["ic"]);
+        const insurance = schema.properties?.propertyPack?.properties?.insurance;
+        // oneOf[1] is isInsured=Yes
+        const yesBranch = insurance.oneOf[1];
+        expect(yesBranch?.required).toContain("insuranceClaims");
+      });
+
+      test("should validate insuranceClaims No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/insurance/insuranceClaims",
+          schemaId,
+          ["baspiV5", "ic"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate insuranceClaims Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/insurance/insuranceClaims",
+          schemaId,
+          ["baspiV5", "ic"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Storm damage claim in 2019" })).toBe(true);
+      });
+    });
+
+    describe("Neighbour development (nd)", () => {
+      test("should add ntsRef to neighbourDevelopment", () => {
+        const schema = getTransactionSchema(schemaId, ["nd"]);
+        const nd = schema.properties?.propertyPack?.properties?.notices
+          ?.properties?.neighbourDevelopment;
+        expect(nd?.ntsRef).toBe("N1.1");
+      });
+
+      test("should add ntsRef via nd overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["nd"]);
+        const notices = schema.properties?.propertyPack?.properties?.notices;
+        expect(notices?.ntsRef).toBe("N1");
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/notices/neighbourDevelopment",
+          schemaId,
+          ["baspiV5", "nd"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+    });
+
+    describe("Other material issue (mi)", () => {
+      test("should mark otherMaterialIssue as required", () => {
+        const schema = getTransactionSchema(schemaId, ["mi"]);
+        const additional = schema.properties?.propertyPack?.properties?.additionalInformation;
+        expect(additional?.required).toContain("otherMaterialIssue");
+      });
+
+      test("should not require otherMaterialIssue without mi overlay", () => {
+        const schema = getTransactionSchema(schemaId, []);
+        const additional = schema.properties?.propertyPack?.properties?.additionalInformation;
+        expect(additional?.required || []).not.toContain("otherMaterialIssue");
+      });
+
+      test("should validate No answer", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/additionalInformation/otherMaterialIssue",
+          schemaId,
+          ["baspiV5", "mi"]
+        );
+        expect(validator({ yesNo: "No" })).toBe(true);
+      });
+
+      test("should validate Yes with details", () => {
+        const validator = getSubschemaValidator(
+          "/propertyPack/additionalInformation/otherMaterialIssue",
+          schemaId,
+          ["baspiV5", "mi"]
+        );
+        expect(validator({ yesNo: "Yes", details: "Previous subsidence issues" })).toBe(true);
+      });
+    });
+
+    describe("Title restrictions (tr)", () => {
+      test("should require titleRestrictions in freehold branch with tr overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["tr"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        // oneOf[0] is Freehold
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.properties?.titleRestrictions).toBeDefined();
+        expect(freeholdBranch?.required).toContain("titleRestrictions");
+      });
+
+      test("should not require titleRestrictions without tr overlay", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.required || []).not.toContain("titleRestrictions");
+      });
+
+      test("should have correct ntsRef", () => {
+        const schema = getTransactionSchema(schemaId, ["tr"]);
+        const items = schema.properties?.propertyPack?.properties?.ownership
+          ?.properties?.ownershipsToBeTransferred?.items;
+        const freeholdBranch = items.oneOf[0];
+        expect(freeholdBranch?.properties?.titleRestrictions?.ntsRef).toBe("T1.1");
+      });
+    });
+
+    describe("All SEF25 extensions combined", () => {
+      const allSef25 = ["sc", "pc", "ph", "dk", "rw", "sd", "lc", "wg", "ic", "nd", "mi", "tr"];
+
+      test("should load all SEF25 extensions together without error", () => {
+        const schema = getTransactionSchema(schemaId, ["baspiV5", ...allSef25]);
+        expect(schema).toBeDefined();
+        expect(schema.properties?.propertyPack).toBeDefined();
+      });
+
+      test("should not interfere with existing NTS2 extensions when combined", () => {
+        const schema = getTransactionSchema(schemaId, ["nts2025", ...allSef25]);
+
+        // NTS2 fields still work
+        const si = schema.properties?.propertyPack?.properties?.specialistIssues;
+        expect(si?.properties?.wellsDitchesShaft?.ntsRef).toBe("H1.1");
+
+        // New SEF25 fields present
+        const parking = schema.properties?.propertyPack?.properties?.parking?.properties;
+        expect(parking?.droppedKerbAccess).toBeDefined();
+
+        const env = schema.properties?.propertyPack?.properties?.environmentalIssues?.properties;
+        expect(env?.stormFireFloodDamage).toBeDefined();
+
+        const rights = schema.properties?.propertyPack?.properties?.rightsAndInformalArrangements
+          ?.properties?.rightsOrArrangements?.properties;
+        expect(rights?.privateRightOfWay).toBeDefined();
+      });
+    });
   });
 });

package/src/utils/extractExtensionOverlays.js

@@ -214,10 +214,97 @@ const extensionMappings = {
     description: "Property hazards and known issues",
     refType: "sef25Ref",
     paths: [
-      "/properties/propertyPack/properties/specialistIssues/properties/wellsDitchesShaft",
-      "/properties/propertyPack/properties/specialistIssues/properties/damagedOrExposedElectrics",
-      "/properties/propertyPack/properties/specialistIssues/properties/damageToFlooringOrStaircases",
-      "/properties/propertyPack/properties/specialistIssues/properties/knownAreasInPoorCondition",
+      "/properties/propertyPack/properties/specialistIssues",
+    ],
+  },
+
+  // Dropped kerb access to parking
+  dk: {
+    name: "droppedKerbAccess",
+    description: "Dropped kerb access to parking",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/parking/properties/droppedKerbAccess",
+    ],
+  },
+
+  // Private right of way
+  rw: {
+    name: "privateRightOfWay",
+    description: "Private right of way",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/rightsAndInformalArrangements/properties/rightsOrArrangements/properties/privateRightOfWay",
+    ],
+  },
+
+  // Storm, fire or flood damage
+  sd: {
+    name: "stormFireFloodDamage",
+    description: "Storm, fire or flood damage",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/environmentalIssues/properties/stormFireFloodDamage",
+    ],
+  },
+
+  // Solar panel lease costs
+  lc: {
+    name: "solarLeaseCosts",
+    description: "Solar panel lease costs",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/electricity/properties/solarPanels/oneOf/1/properties/panelsOwnedOutright/oneOf/1/properties/associatedCost",
+    ],
+  },
+
+  // Warranties and guarantees upfront
+  wg: {
+    name: "warrantiesGuarantees",
+    description: "Warranties and guarantees upfront Y/N for SEF25",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/guaranteesWarrantiesAndIndemnityInsurances",
+    ],
+  },
+
+  // Insurance claims upfront
+  ic: {
+    name: "insuranceClaims",
+    description: "Insurance claims upfront for SEF25",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/insurance/oneOf/1/properties/insuranceClaims",
+    ],
+  },
+
+  // Neighbour development upfront
+  nd: {
+    name: "neighbourDevelopment",
+    description: "Neighbour development upfront for SEF25",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/notices/properties/neighbourDevelopment",
+    ],
+  },
+
+  // Other material issue upfront
+  mi: {
+    name: "otherMaterialIssue",
+    description: "Other material issue upfront for SEF25",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/additionalInformation/properties/otherMaterialIssue",
+    ],
+  },
+
+  // Title restrictions for freehold
+  tr: {
+    name: "titleRestrictions",
+    description: "Title restrictions for freehold properties",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/0/properties/titleRestrictions",
     ],
   },
 };
@@ -405,6 +492,28 @@ function addRequiredArrays(overlay, schema, refConfig) {
   return overlay;
 }
 
+// Annotate intermediate nodes with refs from the source schema
+// This ensures every level of the overlay tree carries an ntsRef
+function addIntermediateRefs(overlay, schema, refConfig) {
+  traverse(overlay).forEach(function (node) {
+    if (node && typeof node === "object" && !Array.isArray(node) && node.properties) {
+      // Skip if this node already has a ref
+      if (node[refConfig.outputRef]) return;
+
+      const schemaPath = "/" + this.path.join("/");
+      try {
+        const schemaNode = jp.get(schema, schemaPath);
+        if (schemaNode && schemaNode[refConfig.ref]) {
+          node[refConfig.outputRef] = schemaNode[refConfig.ref];
+        }
+      } catch (err) {
+        // Path doesn't exist in schema, skip
+      }
+    }
+  });
+  return overlay;
+}
+
 // Generate extension overlays
 Object.entries(extensionMappings).forEach(([code, config]) => {
   const refType = config.refType || "nts2Ref";
@@ -418,6 +527,9 @@ Object.entries(extensionMappings).forEach(([code, config]) => {
   // Add required arrays where needed
   overlay = addRequiredArrays(overlay, combinedSchema, refConfig);
 
+  // Add refs to intermediate nodes in the path hierarchy
+  overlay = addIntermediateRefs(overlay, combinedSchema, refConfig);
+
   // Add schema metadata
   overlay.$schema = "http://json-schema.org/draft-07/schema#";
   overlay.$id = `https://trust.propdata.org.uk/schemas/v3/overlays/extensions/${code}.json`;