@pdtf/schemas 3.6.0-18 → 3.6.0-19

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/utils/extractExtensionOverlays.js

@@ -5,6 +5,30 @@ const path = require("path");
 
 const combinedSchema = require("../schemas/v3/combined.json");
 
+// Derive ref-related field names from a refType
+function getRefConfig(refType) {
+  if (refType === "nts2Ref") {
+    // Legacy mapping: nts2Ref -> ntsRef in output
+    return {
+      ref: "nts2Ref",
+      outputRef: "ntsRef",
+      required: "nts2Required",
+      title: "nts2Title",
+      description: "nts2Description",
+      enumKey: "nts2Enum",
+    };
+  }
+  // For other ref types, derive keys by replacing "Ref" suffix
+  return {
+    ref: refType,
+    outputRef: refType,
+    required: refType.replace("Ref", "Required"),
+    title: refType.replace("Ref", "Title"),
+    description: refType.replace("Ref", "Description"),
+    enumKey: refType.replace("Ref", "Enum"),
+  };
+}
+
 // Define the extension overlay mappings
 const extensionMappings = {
   // Outside areas
@@ -150,18 +174,52 @@ const extensionMappings = {
       "/properties/propertyPack/properties/completionAndMoving/properties/otherPropertyInChain",
     ],
   },
+
+  // Private supply costs (water & sewerage)
+  sc: {
+    name: "supplyCosts",
+    description: "Associated costs for private water and sewerage supply",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/waterAndDrainage/properties/water/properties/mainsWater/oneOf/0/properties/associatedCost",
+      "/properties/propertyPack/properties/waterAndDrainage/properties/drainage/properties/mainsFoulDrainage/oneOf/2/properties/associatedCost",
+    ],
+  },
+
+  // Parking permit costs
+  pc: {
+    name: "parkingPermitCost",
+    description: "Parking permit cost and frequency",
+    refType: "sef25Ref",
+    paths: [
+      "/properties/propertyPack/properties/parking/properties/controlledParking/oneOf/1/properties/costOfPermitFrequency",
+    ],
+  },
+
+  // Property hazards
+  ph: {
+    name: "propertyHazards",
+    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",
+    ],
+  },
 };
 
-// Function to extract properties at specific paths with nts2Ref
-function extractPathsWithNts2Ref(schema, paths) {
+// Function to extract properties at specific paths with given ref type
+function extractPathsWithRef(schema, paths, refConfig) {
   const result = {};
 
   paths.forEach((path) => {
     try {
       const value = jp.get(schema, path);
-      if (value && hasNts2Ref(value)) {
+      if (value && hasRef(value, refConfig)) {
         // Set the value at the same path in result
-        jp.set(result, path, extractNts2Properties(value));
+        jp.set(result, path, extractRefProperties(value, refConfig));
       }
     } catch (err) {
       console.warn(`Path not found: ${path}`);
@@ -171,11 +229,11 @@ function extractPathsWithNts2Ref(schema, paths) {
   return result;
 }
 
-// Check if an object or its descendants have nts2Ref
-function hasNts2Ref(obj) {
+// Check if an object or its descendants have the specified ref
+function hasRef(obj, refConfig) {
   let found = false;
   traverse(obj).forEach(function (element) {
-    if (element && element.nts2Ref) {
+    if (element && element[refConfig.ref]) {
       found = true;
       this.stop();
     }
@@ -183,16 +241,16 @@ function hasNts2Ref(obj) {
   return found;
 }
 
-// Extract only NTS2-specific properties (with nts2Ref)
-function extractNts2Properties(obj, parentKey) {
+// Extract only ref-specific properties
+function extractRefProperties(obj, refConfig, parentKey) {
   const result = {};
 
-  // Copy nts2-specific metadata at current level
-  if (obj.nts2Ref) result.ntsRef = obj.nts2Ref;
-  if (obj.nts2Required) result.required = obj.nts2Required;
-  if (obj.nts2Title) result.title = obj.nts2Title;
-  if (obj.nts2Description) result.description = obj.nts2Description;
-  if (obj.nts2Enum) result.enum = obj.nts2Enum;
+  // Copy ref-specific metadata at current level
+  if (obj[refConfig.ref]) result[refConfig.outputRef] = obj[refConfig.ref];
+  if (obj[refConfig.required]) result.required = obj[refConfig.required];
+  if (obj[refConfig.title]) result.title = obj[refConfig.title];
+  if (obj[refConfig.description]) result.description = obj[refConfig.description];
+  if (obj[refConfig.enumKey]) result.enum = obj[refConfig.enumKey];
 
   // Handle discriminator
   if (obj.discriminator) {
@@ -204,11 +262,11 @@ function extractNts2Properties(obj, parentKey) {
     result.properties = {};
     Object.keys(obj.properties).forEach((key) => {
       const prop = obj.properties[key];
-      if (hasNts2Ref(prop)) {
-        result.properties[key] = extractNts2Properties(prop, key);
+      if (hasRef(prop, refConfig)) {
+        result.properties[key] = extractRefProperties(prop, refConfig, key);
       }
     });
-    // Only keep properties if we found some with nts2Ref
+    // Only keep properties if we found some with ref
     if (Object.keys(result.properties).length === 0) {
       delete result.properties;
     }
@@ -216,8 +274,8 @@ function extractNts2Properties(obj, parentKey) {
 
   // Handle arrays
   if (obj.items) {
-    if (hasNts2Ref(obj.items)) {
-      result.items = extractNts2Properties(obj.items);
+    if (hasRef(obj.items, refConfig)) {
+      result.items = extractRefProperties(obj.items, refConfig);
     }
   }
 
@@ -225,8 +283,8 @@ function extractNts2Properties(obj, parentKey) {
   if (obj.oneOf) {
     // Always preserve the full array structure and order
     const processedOneOf = obj.oneOf.map((schema, index) => {
-      if (hasNts2Ref(schema)) {
-        const extracted = extractNts2Properties(schema);
+      if (hasRef(schema, refConfig)) {
+        const extracted = extractRefProperties(schema, refConfig);
         // For oneOf schemas, we need to preserve discriminator enum values
         if (obj.discriminator && schema.properties) {
           const propName = obj.discriminator.propertyName;
@@ -234,7 +292,7 @@ function extractNts2Properties(obj, parentKey) {
             if (!extracted.properties) extracted.properties = {};
             extracted.properties[propName] = {
               enum:
-                schema.properties[propName].nts2Enum ||
+                schema.properties[propName][refConfig.enumKey] ||
                 schema.properties[propName].enum,
             };
           }
@@ -258,7 +316,7 @@ function extractNts2Properties(obj, parentKey) {
         }
         return extracted;
       } else {
-        // If this branch doesn't have nts2Ref, preserve the base discriminator enum
+        // If this branch doesn't have ref, preserve the base discriminator enum
         if (obj.discriminator && schema.properties) {
           const propName = obj.discriminator.propertyName;
           if (schema.properties[propName]) {
@@ -281,7 +339,7 @@ function extractNts2Properties(obj, parentKey) {
     // If parentKey is set, and this object has extension metadata, return a stub for the parent
     if (
       parentKey &&
-      (result.ntsRef || result.required || result.discriminator)
+      (result[refConfig.outputRef] || result.required || result.discriminator)
     ) {
       // This is an extension property inside a oneOf branch
       // Return a stub for the parent property with metadata and oneOf structure
@@ -311,16 +369,16 @@ function extractNts2Properties(obj, parentKey) {
 }
 
 // Add required array at parent levels if needed
-function addRequiredArrays(overlay, schema) {
+function addRequiredArrays(overlay, schema, refConfig) {
   traverse(overlay).forEach(function (node) {
     if (node && node.properties) {
       const schemaPath = "/" + this.path.join("/");
       try {
         const schemaNode = jp.get(schema, schemaPath);
-        if (schemaNode && schemaNode.nts2Required) {
+        if (schemaNode && schemaNode[refConfig.required]) {
           // Filter to only include properties that exist in this overlay
           const overlayProps = Object.keys(node.properties);
-          const requiredProps = schemaNode.nts2Required.filter((prop) =>
+          const requiredProps = schemaNode[refConfig.required].filter((prop) =>
             overlayProps.includes(prop)
           );
           if (requiredProps.length > 0) {
@@ -337,13 +395,16 @@ function addRequiredArrays(overlay, schema) {
 
 // Generate extension overlays
 Object.entries(extensionMappings).forEach(([code, config]) => {
-  console.log(`\nGenerating extension overlay: ${code} (${config.name})`);
+  const refType = config.refType || "nts2Ref";
+  const refConfig = getRefConfig(refType);
+
+  console.log(`\nGenerating extension overlay: ${code} (${config.name}) [${refType}]`);
 
   // Extract the specific paths
-  let overlay = extractPathsWithNts2Ref(combinedSchema, config.paths);
+  let overlay = extractPathsWithRef(combinedSchema, config.paths, refConfig);
 
   // Add required arrays where needed
-  overlay = addRequiredArrays(overlay, combinedSchema);
+  overlay = addRequiredArrays(overlay, combinedSchema, refConfig);
 
   // Add schema metadata
   overlay.$schema = "http://json-schema.org/draft-07/schema#";