@pdtf/schemas 3.4.1-1 → 3.4.1-2

package/index.js

@@ -22,23 +22,23 @@ const extensionOverlays = {
   jk: require("./src/schemas/v3/overlays/extensions/jk.json"),
   sb: require("./src/schemas/v3/overlays/extensions/sb.json"),
   hs: require("./src/schemas/v3/overlays/extensions/hs.json"),
-  
+
   // Property Features Extensions
   oa: require("./src/schemas/v3/overlays/extensions/oa.json"),
   la: require("./src/schemas/v3/overlays/extensions/la.json"),
   sf: require("./src/schemas/v3/overlays/extensions/sf.json"),
   mc: require("./src/schemas/v3/overlays/extensions/mc.json"),
-  
+
   // Ownership & Financial Extensions
   er: require("./src/schemas/v3/overlays/extensions/er.json"),
   ma: require("./src/schemas/v3/overlays/extensions/ma.json"),
   tf: require("./src/schemas/v3/overlays/extensions/tf.json"),
-  
+
   // Utilities & Services Extensions
   sl: require("./src/schemas/v3/overlays/extensions/sl.json"),
   hi: require("./src/schemas/v3/overlays/extensions/hi.json"),
   fd: require("./src/schemas/v3/overlays/extensions/fd.json"),
-  
+
   // Transaction Extensions
   oc: require("./src/schemas/v3/overlays/extensions/oc.json"),
 };
@@ -165,10 +165,109 @@ const getTransactionSchema = (
       },
       arrayMerge: combineMerge,
     });
+
+    // Post-merge: Ensure overlay metadata is preserved
+    mergedSchema = preserveOverlayMetadata(mergedSchema, overlaySchema);
   });
   return mergedSchema;
 };
 
+// Function to ensure overlay metadata properties are preserved after merging
+const preserveOverlayMetadata = (mergedSchema, overlaySchema) => {
+  const metadataKeys = [
+    "ntsRef",
+    "nts2Ref",
+    "baspi4Ref",
+    "baspi5Ref",
+    "ta6Ref",
+    "ta7Ref",
+    "ta10Ref",
+    "lpe1Ref",
+    "fme1Ref",
+    "con29RRef",
+    "con29DWRef",
+    "llc1Ref",
+    "rdsRef",
+    "oc1Ref",
+    "piqRef",
+    "sr24Ref",
+    "discriminator",
+  ];
+
+  // Helper to get a unique key signature for a schema branch (for matching oneOf branches)
+  const getBranchSignature = (obj) => {
+    if (!obj || typeof obj !== "object") return "";
+    if (obj.properties) {
+      return Object.keys(obj.properties).sort().join(",");
+    }
+    return Object.keys(obj).sort().join(",");
+  };
+
+  const traverseAndPreserve = (merged, overlay, path = "") => {
+    if (!overlay || typeof overlay !== "object") return;
+
+    // If both are arrays, try to match by signature, else fallback to index
+    if (Array.isArray(overlay) && Array.isArray(merged)) {
+      // Build a map of overlay signatures
+      const overlaySignatures = overlay.map(getBranchSignature);
+      const mergedSignatures = merged.map(getBranchSignature);
+      for (let i = 0; i < overlay.length; i++) {
+        const oSig = overlaySignatures[i];
+        // Try to find a matching branch in merged by signature
+        let mIdx = mergedSignatures.indexOf(oSig);
+        if (mIdx === -1) mIdx = i; // fallback to index if not found
+        if (merged[mIdx] !== undefined) {
+          traverseAndPreserve(merged[mIdx], overlay[i], path + `[${mIdx}]`);
+        }
+      }
+      return;
+    }
+
+    Object.keys(overlay).forEach((key) => {
+      const overlayValue = overlay[key];
+      const mergedValue = merged[key];
+
+      if (metadataKeys.includes(key) && overlayValue !== undefined) {
+        // For metadata keys, preserve the overlay value
+        merged[key] = overlayValue;
+      } else if (
+        key === "required" &&
+        Array.isArray(overlayValue) &&
+        Array.isArray(mergedValue)
+      ) {
+        // For required arrays, merge them uniquely (don't overwrite)
+        merged[key] = [...new Set([...mergedValue, ...overlayValue])];
+      } else if (
+        key === "required" &&
+        Array.isArray(overlayValue) &&
+        !Array.isArray(mergedValue)
+      ) {
+        // If merged doesn't have required array but overlay does, use overlay's
+        merged[key] = overlayValue;
+      } else if (
+        overlayValue &&
+        typeof overlayValue === "object" &&
+        !Array.isArray(overlayValue) &&
+        mergedValue &&
+        typeof mergedValue === "object" &&
+        !Array.isArray(mergedValue)
+      ) {
+        traverseAndPreserve(mergedValue, overlayValue, path + "/" + key);
+      } else if (
+        Array.isArray(overlayValue) &&
+        Array.isArray(mergedValue) &&
+        ["oneOf", "anyOf", "allOf"].includes(key)
+      ) {
+        // Recursively handle schema composition arrays (handled above)
+        traverseAndPreserve(mergedValue, overlayValue, path + `/${key}`);
+      }
+    });
+  };
+
+  traverseAndPreserve(mergedSchema, overlaySchema);
+  return mergedSchema;
+};
+
 // Add helper function to generate cache key
 const generateOverlayKey = (overlays) => {
   if (!overlays) return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdtf/schemas",
-  "version": "3.4.1-1",
+  "version": "3.4.1-2",
   "description": "Property Data Trust Framework Schemas and Utilities",
   "main": "index.js",
   "directories": {

package/src/examples/v3/exampleTransaction.json

@@ -18,7 +18,11 @@
         "countryCode": "GBR"
       },
       "role": "Seller",
-      "sellersCapacity": { "capacity": "Legal Owner" },
+      "sellersCapacity": {
+        "capacity": "Legal Owner",
+        "sellersCapacityDetails": "Selling as the legal owner of the property",
+        "attachments": "To follow"
+      },
       "externalIds": { "Moverly": "123434" }
     },
     {

package/src/schemas/v3/property-transaction-milestones.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Transaction Milestones",
+  "description": "Schema for tracking transaction milestones throughout the conveyancing process",
+  "type": "object",
+  "properties": {
+    "listed": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "legalForms": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "soldSubjectToContract": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "searches": {
+      "type": "object",
+      "properties": {
+        "ordered": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "enquiries": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "exchangeOfContracts": {
+      "type": "object",
+      "properties": {
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "completion": {
+      "type": "object",
+      "properties": {
+        "started": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    }
+  }
+}

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

@@ -4,35 +4,60 @@ const {
   getValidator,
 } = require("../../../index.js");
 
-const schemaId = "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
+const schemaId =
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
 
 describe("Extension Overlays", () => {
-  
   describe("String key support", () => {
     test("should load extension overlays using string keys", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "jk"]);
-      const jkProp = schema.properties?.propertyPack?.properties?.specialistIssues?.properties?.japaneseKnotweed;
-      
+      const jkProp =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties?.japaneseKnotweed;
+
       expect(jkProp).toBeDefined();
       expect(jkProp.ntsRef).toBe("A5.3");
     });
 
     test("should work with multiple extension string keys", () => {
-      const schema = getTransactionSchema(schemaId, ["nts2023", "jk", "tf", "ma"]);
-      
-      const jkProp = schema.properties?.propertyPack?.properties?.specialistIssues?.properties?.japaneseKnotweed;
-      const tfProp = schema.properties?.propertyPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]?.properties?.transferFees;
-      const maProp = schema.properties?.propertyPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation?.properties?.contactDetails;
-      
+      const schema = getTransactionSchema(schemaId, [
+        "nts2023",
+        "jk",
+        "tf",
+        "ma",
+        "er",
+      ]);
+
+      const jkProp =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties?.japaneseKnotweed;
+      const tfProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]
+          ?.properties?.transferFees;
+      const maProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation?.properties?.contactDetails;
+      const erProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[0]?.properties
+          ?.estateRentcharges;
+
       expect(jkProp?.ntsRef).toBe("A5.3");
       expect(tfProp?.ntsRef).toBe("A3.5.1.1");
       expect(maProp?.ntsRef).toBe("A1.5.4");
+      expect(erProp?.ntsRef).toBe("A3.4");
     });
 
     test("should be equivalent to direct object access", () => {
       const schemaString = getTransactionSchema(schemaId, ["nts2023", "jk"]);
-      const schemaDirect = getTransactionSchema(schemaId, ["nts2023", extensionOverlays.jk]);
-      
+      const schemaDirect = getTransactionSchema(schemaId, [
+        "nts2023",
+        extensionOverlays.jk,
+      ]);
+
       expect(schemaString).toEqual(schemaDirect);
     });
   });
@@ -40,8 +65,10 @@ describe("Extension Overlays", () => {
   describe("Individual extension functionality", () => {
     test("should add Japanese Knotweed extension correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "jk"]);
-      const jkProp = schema.properties?.propertyPack?.properties?.specialistIssues?.properties?.japaneseKnotweed;
-      
+      const jkProp =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties?.japaneseKnotweed;
+
       expect(jkProp).toBeDefined();
       expect(jkProp.ntsRef).toBe("A5.3");
       expect(jkProp.required).toContain("yesNo");
@@ -50,17 +77,26 @@ describe("Extension Overlays", () => {
 
     test("should add Transfer Fees extension correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "tf"]);
-      const tfProp = schema.properties?.propertyPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]?.properties?.transferFees;
-      
+      const tfProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]
+          ?.properties?.transferFees;
+
       expect(tfProp).toBeDefined();
       expect(tfProp.ntsRef).toBe("A3.5.1.1");
-      expect(tfProp.title).toBe("Are there any additional fees payable on sale or letting?");
+      expect(tfProp.title).toBe(
+        "Are there any additional fees payable on sale or letting?"
+      );
     });
 
     test("should add Managing Agent extension correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "ma"]);
-      const maProp = schema.properties?.propertyPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation?.properties?.contactDetails;
-      
+      const maProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation?.properties?.contactDetails;
+
       expect(maProp).toBeDefined();
       expect(maProp.ntsRef).toBe("A1.5.4");
       expect(maProp.required).toContain("contacts");
@@ -68,32 +104,76 @@ describe("Extension Overlays", () => {
 
     test("should add Solar Panels extension correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "sl"]);
-      const slProp = schema.properties?.propertyPack?.properties?.electricity?.properties?.solarPanels?.oneOf?.[1]?.properties?.panelsOwnedOutright;
-      
+      const slProp =
+        schema.properties?.propertyPack?.properties?.electricity?.properties
+          ?.solarPanels?.oneOf?.[1]?.properties?.panelsOwnedOutright;
+
       expect(slProp).toBeDefined();
       expect(slProp.ntsRef).toBe("B3.7.1");
     });
 
     test("should add Heating Installation extension correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "hi"]);
-      const hiProp = schema.properties?.propertyPack?.properties?.heating?.properties?.heatingSystem?.oneOf?.[1]?.properties?.centralHeatingDetails?.properties?.centralHeatingInstalled;
-      
+      const hiProp =
+        schema.properties?.propertyPack?.properties?.heating?.properties
+          ?.heatingSystem?.oneOf?.[1]?.properties?.centralHeatingDetails
+          ?.properties?.centralHeatingInstalled;
+
       expect(hiProp).toBeDefined();
       expect(hiProp.ntsRef).toBe("B3.4.3.2");
     });
+
+    test("should add Estate Rentcharges extension correctly", () => {
+      const schema = getTransactionSchema(schemaId, ["nts2023", "er"]);
+      const erProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[0]?.properties
+          ?.estateRentcharges;
+
+      expect(erProp).toBeDefined();
+      expect(erProp.ntsRef).toBe("A3.4");
+      expect(erProp.required).toContain("yesNo");
+      expect(erProp.discriminator?.propertyName).toBe("yesNo");
+      expect(erProp.oneOf).toBeDefined();
+      expect(Array.isArray(erProp.oneOf)).toBe(true);
+      expect(erProp.oneOf.length).toBeGreaterThan(0);
+
+      // Check the conditional branch for "Yes" response
+      const yesBranch = erProp.oneOf.find(
+        (branch) =>
+          branch.required?.includes("details") &&
+          branch.required?.includes("amount")
+      );
+      expect(yesBranch).toBeDefined();
+      expect(yesBranch.properties?.details?.ntsRef).toBe("A3.4.2");
+      expect(yesBranch.properties?.amount?.ntsRef).toBe("A3.4.3");
+    });
   });
 
   describe("Extension overlay availability", () => {
     test("should export all extension overlays", () => {
       const expectedKeys = [
-        "as", "dr", "jk", "sb", "hs",  // Specialist Issues
-        "oa", "la", "sf", "mc",        // Property Features
-        "er", "ma", "tf",              // Ownership & Financial
-        "sl", "hi", "fd",              // Utilities & Services
-        "oc"                           // Transaction
+        "as",
+        "dr",
+        "jk",
+        "sb",
+        "hs", // Specialist Issues
+        "oa",
+        "la",
+        "sf",
+        "mc", // Property Features
+        "er",
+        "ma",
+        "tf", // Ownership & Financial
+        "sl",
+        "hi",
+        "fd", // Utilities & Services
+        "oc", // Transaction
       ];
-      
-      expect(Object.keys(extensionOverlays).sort()).toEqual(expectedKeys.sort());
+
+      expect(Object.keys(extensionOverlays).sort()).toEqual(
+        expectedKeys.sort()
+      );
     });
 
     test("should have valid JSON structure for all extensions", () => {
@@ -110,78 +190,131 @@ describe("Extension Overlays", () => {
     test("should produce equivalent result to nts2 when all relevant extensions are combined", () => {
       // Get the full NTS2 schema
       const nts2Schema = getTransactionSchema(schemaId, ["nts2025"]);
-      
+
       // Get NTS base with all relevant extensions
       const allExtensions = [
         "nts2023",
         // Specialist issues extensions
-        "as", "dr", "jk", "sb", "hs",
-        // Property features extensions  
-        "oa", "la", "sf", "mc",
+        "as",
+        "dr",
+        "jk",
+        "sb",
+        "hs",
+        // Property features extensions
+        "oa",
+        "la",
+        "sf",
+        "mc",
         // Ownership & financial extensions
-        "er", "ma", "tf", 
+        "er",
+        "ma",
+        "tf",
         // Utilities & services extensions
-        "sl", "hi", "fd",
+        "sl",
+        "hi",
+        "fd",
         // Transaction extensions
-        "oc"
+        "oc",
       ];
-      
-      const ntsWithAllExtensions = getTransactionSchema(schemaId, allExtensions);
-      
+
+      const ntsWithAllExtensions = getTransactionSchema(
+        schemaId,
+        allExtensions
+      );
+
       // Compare key structural elements
       const nts2PropPack = nts2Schema.properties?.propertyPack;
       const extPropPack = ntsWithAllExtensions.properties?.propertyPack;
-      
+
       // Check that specialist issues section exists in both
       expect(nts2PropPack?.properties?.specialistIssues).toBeDefined();
       expect(extPropPack?.properties?.specialistIssues).toBeDefined();
-      
+
       // Check key specialist issues properties
       const nts2SI = nts2PropPack.properties.specialistIssues.properties;
       const extSI = extPropPack.properties.specialistIssues.properties;
-      
+
       expect(extSI?.japaneseKnotweed).toBeDefined();
       expect(extSI?.dryRotEtcTreatment).toBeDefined();
       expect(extSI?.containsAsbestos).toBeDefined();
       expect(extSI?.subsidenceOrStructuralFault).toBeDefined();
       expect(extSI?.ongoingHealthOrSafetyIssue).toBeDefined();
-      
+
       // Check that references match (extensions use ntsRef, NTS2 uses nts2Ref)
       if (nts2SI?.japaneseKnotweed && extSI?.japaneseKnotweed) {
         expect(extSI.japaneseKnotweed.ntsRef).toBe("A5.3");
         // NTS2 might have nts2Ref instead - this is expected difference
       }
-      
+
       // Check outside areas
-      expect(extPropPack?.properties?.residentialPropertyFeatures?.properties?.outsideAreas).toBeDefined();
-      
+      expect(
+        extPropPack?.properties?.residentialPropertyFeatures?.properties
+          ?.outsideAreas
+      ).toBeDefined();
+
       // Check leasehold extensions
-      const leaseholdInfo = extPropPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation;
+      const leaseholdInfo =
+        extPropPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation;
       expect(leaseholdInfo?.properties?.contactDetails).toBeDefined(); // Managing agent
-      expect(leaseholdInfo?.properties?.serviceCharge?.oneOf?.[1]?.properties?.transferFees).toBeDefined(); // Transfer fees
-      
+      expect(
+        leaseholdInfo?.properties?.serviceCharge?.oneOf?.[1]?.properties
+          ?.transferFees
+      ).toBeDefined(); // Transfer fees
+
       // Check utility extensions
-      expect(extPropPack?.properties?.electricity?.properties?.solarPanels?.oneOf?.[1]?.properties?.panelsOwnedOutright).toBeDefined();
-      expect(extPropPack?.properties?.heating?.properties?.heatingSystem?.oneOf?.[1]?.properties?.centralHeatingDetails?.properties?.centralHeatingInstalled).toBeDefined();
-      
+      expect(
+        extPropPack?.properties?.electricity?.properties?.solarPanels
+          ?.oneOf?.[1]?.properties?.panelsOwnedOutright
+      ).toBeDefined();
+      expect(
+        extPropPack?.properties?.heating?.properties?.heatingSystem?.oneOf?.[1]
+          ?.properties?.centralHeatingDetails?.properties
+          ?.centralHeatingInstalled
+      ).toBeDefined();
+
       // Check construction extensions
-      expect(extPropPack?.properties?.typeOfConstruction?.properties?.loft).toBeDefined();
-      expect(extPropPack?.properties?.typeOfConstruction?.properties?.sprayFoamInsulation).toBeDefined();
-      
+      expect(
+        extPropPack?.properties?.typeOfConstruction?.properties?.loft
+      ).toBeDefined();
+      expect(
+        extPropPack?.properties?.typeOfConstruction?.properties
+          ?.sprayFoamInsulation
+      ).toBeDefined();
+
       // Check completion and moving
-      expect(extPropPack?.properties?.completionAndMoving?.properties?.otherPropertyInChain).toBeDefined();
+      expect(
+        extPropPack?.properties?.completionAndMoving?.properties
+          ?.otherPropertyInChain
+      ).toBeDefined();
     });
 
     test("should validate data successfully with all extensions", () => {
       const allExtensions = [
-        "nts2023", "as", "dr", "jk", "sb", "hs", "oa", "la", "sf", "mc", 
-        "er", "ma", "tf", "sl", "hi", "fd", "oc"
+        "nts2023",
+        "as",
+        "dr",
+        "jk",
+        "sb",
+        "hs",
+        "oa",
+        "la",
+        "sf",
+        "mc",
+        "er",
+        "ma",
+        "tf",
+        "sl",
+        "hi",
+        "fd",
+        "oc",
       ];
-      
+
       const validator = getValidator(schemaId, allExtensions);
       expect(validator).toBeDefined();
       expect(typeof validator).toBe("function");
-      
+
       // Test with minimal valid data structure
       const testData = {
         propertyPack: {
@@ -205,11 +338,11 @@ describe("Extension Overlays", () => {
             dryRotEtcTreatment: { yesNo: "No" },
             containsAsbestos: { yesNo: "No" },
             subsidenceOrStructuralFault: { yesNo: "No" },
-            ongoingHealthOrSafetyIssue: { yesNo: "No" }
-          }
-        }
+            ongoingHealthOrSafetyIssue: { yesNo: "No" },
+          },
+        },
       };
-      
+
       // This might not validate due to missing required fields, but validator should not throw
       expect(() => validator(testData)).not.toThrow();
     });
@@ -218,8 +351,9 @@ describe("Extension Overlays", () => {
   describe("Extension merging behavior", () => {
     test("should preserve required arrays when merging extensions", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "jk", "as"]);
-      const siSection = schema.properties?.propertyPack?.properties?.specialistIssues;
-      
+      const siSection =
+        schema.properties?.propertyPack?.properties?.specialistIssues;
+
       expect(siSection?.required).toBeDefined();
       expect(siSection.required).toContain("japaneseKnotweed");
       expect(siSection.required).toContain("containsAsbestos");
@@ -227,8 +361,10 @@ describe("Extension Overlays", () => {
 
     test("should handle discriminator patterns correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "jk"]);
-      const jkProp = schema.properties?.propertyPack?.properties?.specialistIssues?.properties?.japaneseKnotweed;
-      
+      const jkProp =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties?.japaneseKnotweed;
+
       expect(jkProp?.discriminator).toBeDefined();
       expect(jkProp.discriminator.propertyName).toBe("yesNo");
       expect(jkProp.oneOf).toBeDefined();
@@ -237,17 +373,25 @@ describe("Extension Overlays", () => {
 
     test("should merge oneOf schemas correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "tf"]);
-      const tfProp = schema.properties?.propertyPack?.properties?.ownership?.properties?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]?.properties?.transferFees;
-      
+      const tfProp =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2]?.properties
+          ?.leaseholdInformation?.properties?.serviceCharge?.oneOf?.[1]
+          ?.properties?.transferFees;
+
       expect(tfProp?.oneOf).toBeDefined();
       expect(tfProp.oneOf.length).toBeGreaterThan(0);
-      
+
       // Check the structure - details should be in the conditional oneOf branch
-      const conditionalBranch = tfProp.oneOf.find(branch => 
-        branch.properties?.details || branch.required?.includes("details")
+      const conditionalBranch = tfProp.oneOf.find(
+        (branch) =>
+          branch.properties?.details || branch.required?.includes("details")
       );
       expect(conditionalBranch).toBeDefined();
-      expect(conditionalBranch.properties?.details || conditionalBranch.required?.includes("details")).toBeTruthy();
+      expect(
+        conditionalBranch.properties?.details ||
+          conditionalBranch.required?.includes("details")
+      ).toBeTruthy();
     });
   });
-});
+});

package/src/utils/extractExtensionOverlays.js

@@ -11,120 +11,152 @@ const extensionMappings = {
   oa: {
     name: "outsideAreas",
     description: "Outside areas extension for NTS",
-    paths: ["/properties/propertyPack/properties/residentialPropertyFeatures/properties/outsideAreas"]
+    paths: [
+      "/properties/propertyPack/properties/residentialPropertyFeatures/properties/outsideAreas",
+    ],
   },
-  
+
   // Estate rentcharges for freehold
   er: {
     name: "estateRentcharges",
     description: "Estate rentcharges for freehold properties",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/0/properties/estateRentcharges"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/0/properties/estateRentcharges",
+    ],
   },
-  
+
   // Managing agent contact details for leasehold
   ma: {
     name: "managingAgent",
     description: "Managing agent contact details for leasehold",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/contactDetails"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/contactDetails",
+    ],
   },
-  
+
   // Transfer fees for leasehold
   tf: {
     name: "transferFees",
     description: "Transfer fees for leasehold",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/serviceCharge/oneOf/1/properties/transferFees"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/serviceCharge/oneOf/1/properties/transferFees",
+    ],
   },
-  
+
   // Main construction type if standard
   mc: {
     name: "mainConstruction",
     description: "Main construction type if standard form",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/isStandardForm/oneOf/0/properties/constructionType"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/isStandardForm/oneOf/0/properties/constructionType",
+    ],
   },
-  
+
   // Loft access and details
   la: {
     name: "loftAccess",
     description: "Loft access and details",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/loft"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/loft",
+    ],
   },
-  
+
   // Spray foam insulation
   sf: {
     name: "sprayFoam",
     description: "Spray foam insulation",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/sprayFoamInsulation"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/sprayFoamInsulation",
+    ],
   },
-  
+
   // Specialist issues - dry rot
   dr: {
     name: "dryRot",
     description: "Dry rot treatment specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/dryRotEtcTreatment"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/dryRotEtcTreatment",
+    ],
   },
-  
+
   // Specialist issues - asbestos
   as: {
     name: "asbestos",
     description: "Asbestos specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/containsAsbestos"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/containsAsbestos",
+    ],
   },
-  
+
   // Specialist issues - Japanese knotweed
   jk: {
     name: "japaneseKnotweed",
     description: "Japanese knotweed specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/japaneseKnotweed"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/japaneseKnotweed",
+    ],
   },
-  
+
   // Specialist issues - subsidence
   sb: {
     name: "subsidence",
     description: "Subsidence or structural fault specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/subsidenceOrStructuralFault"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/subsidenceOrStructuralFault",
+    ],
   },
-  
+
   // Specialist issues - health and safety
   hs: {
     name: "healthSafety",
     description: "Health and safety specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/ongoingHealthOrSafetyIssue"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/ongoingHealthOrSafetyIssue",
+    ],
   },
-  
+
   // Solar panels leased
   sl: {
     name: "solarPanelsLeased",
     description: "Solar panels ownership details",
-    paths: ["/properties/propertyPack/properties/electricity/properties/solarPanels/oneOf/1/properties/panelsOwnedOutright"]
+    paths: [
+      "/properties/propertyPack/properties/electricity/properties/solarPanels/oneOf/1/properties/panelsOwnedOutright",
+    ],
   },
-  
+
   // Heating installation date
   hi: {
     name: "heatingInstalled",
     description: "Central heating installation date",
-    paths: ["/properties/propertyPack/properties/heating/properties/heatingSystem/oneOf/1/properties/centralHeatingDetails/properties/centralHeatingInstalled"]
+    paths: [
+      "/properties/propertyPack/properties/heating/properties/heatingSystem/oneOf/1/properties/centralHeatingDetails/properties/centralHeatingInstalled",
+    ],
   },
-  
+
   // Flood defences
   fd: {
     name: "floodDefences",
     description: "Flood defence information",
-    paths: ["/properties/propertyPack/properties/environmentalIssues/properties/flooding/properties/floodDefences"]
+    paths: [
+      "/properties/propertyPack/properties/environmentalIssues/properties/flooding/properties/floodDefences",
+    ],
   },
-  
+
   // Other property in chain
   oc: {
     name: "otherPropertyChain",
     description: "Other property in chain dependency",
-    paths: ["/properties/propertyPack/properties/completionAndMoving/properties/otherPropertyInChain"]
-  }
+    paths: [
+      "/properties/propertyPack/properties/completionAndMoving/properties/otherPropertyInChain",
+    ],
+  },
 };
 
 // Function to extract properties at specific paths with nts2Ref
 function extractPathsWithNts2Ref(schema, paths) {
   const result = {};
-  
-  paths.forEach(path => {
+
+  paths.forEach((path) => {
     try {
       const value = jp.get(schema, path);
       if (value && hasNts2Ref(value)) {
@@ -135,14 +167,14 @@ function extractPathsWithNts2Ref(schema, paths) {
       console.warn(`Path not found: ${path}`);
     }
   });
-  
+
   return result;
 }
 
 // Check if an object or its descendants have nts2Ref
 function hasNts2Ref(obj) {
   let found = false;
-  traverse(obj).forEach(function(element) {
+  traverse(obj).forEach(function (element) {
     if (element && element.nts2Ref) {
       found = true;
       this.stop();
@@ -154,23 +186,23 @@ function hasNts2Ref(obj) {
 // Extract only NTS2-specific properties (with nts2Ref)
 function extractNts2Properties(obj) {
   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;
-  
+
   // Handle discriminator
   if (obj.discriminator) {
     result.discriminator = obj.discriminator;
   }
-  
+
   // Recursively process properties
   if (obj.properties) {
     result.properties = {};
-    Object.keys(obj.properties).forEach(key => {
+    Object.keys(obj.properties).forEach((key) => {
       const prop = obj.properties[key];
       if (hasNts2Ref(prop)) {
         result.properties[key] = extractNts2Properties(prop);
@@ -181,14 +213,14 @@ function extractNts2Properties(obj) {
       delete result.properties;
     }
   }
-  
+
   // Handle arrays
   if (obj.items) {
     if (hasNts2Ref(obj.items)) {
       result.items = extractNts2Properties(obj.items);
     }
   }
-  
+
   // Handle oneOf
   if (obj.oneOf) {
     const processedOneOf = [];
@@ -201,7 +233,9 @@ function extractNts2Properties(obj) {
           if (schema.properties[propName]) {
             if (!extracted.properties) extracted.properties = {};
             extracted.properties[propName] = {
-              enum: schema.properties[propName].nts2Enum || schema.properties[propName].enum
+              enum:
+                schema.properties[propName].nts2Enum ||
+                schema.properties[propName].enum,
             };
           }
         }
@@ -212,20 +246,29 @@ function extractNts2Properties(obj) {
       result.oneOf = processedOneOf;
     }
   }
-  
+
   // Copy other JSON Schema keywords that might be present
-  ['type', 'format', 'minimum', 'maximum', 'minLength', 'maxLength', 'minItems', 'maxItems'].forEach(keyword => {
+  [
+    "type",
+    "format",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+  ].forEach((keyword) => {
     if (obj[keyword] !== undefined) {
       result[keyword] = obj[keyword];
     }
   });
-  
+
   return result;
 }
 
 // Add required array at parent levels if needed
 function addRequiredArrays(overlay, schema) {
-  traverse(overlay).forEach(function(node) {
+  traverse(overlay).forEach(function (node) {
     if (node && node.properties) {
       const schemaPath = "/" + this.path.join("/");
       try {
@@ -233,7 +276,9 @@ function addRequiredArrays(overlay, schema) {
         if (schemaNode && schemaNode.nts2Required) {
           // Filter to only include properties that exist in this overlay
           const overlayProps = Object.keys(node.properties);
-          const requiredProps = schemaNode.nts2Required.filter(prop => overlayProps.includes(prop));
+          const requiredProps = schemaNode.nts2Required.filter((prop) =>
+            overlayProps.includes(prop)
+          );
           if (requiredProps.length > 0) {
             node.required = requiredProps;
           }
@@ -249,23 +294,25 @@ function addRequiredArrays(overlay, schema) {
 // Generate extension overlays
 Object.entries(extensionMappings).forEach(([code, config]) => {
   console.log(`\nGenerating extension overlay: ${code} (${config.name})`);
-  
+
   // Extract the specific paths
   let overlay = extractPathsWithNts2Ref(combinedSchema, config.paths);
-  
+
   // Add required arrays where needed
   overlay = addRequiredArrays(overlay, combinedSchema);
-  
+
   // 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`;
   overlay.$comment = config.description;
-  
+
   // Write the overlay file
-  const fileName = path.join(__dirname, `../schemas/v3/overlays/extensions/${code}.json`);
+  const fileName = path.join(
+    __dirname,
+    `../schemas/v3/overlays/extensions/${code}.json`
+  );
   fs.writeFileSync(fileName, JSON.stringify(overlay, null, 2));
   console.log(`Extension overlay ${code} written to ${fileName}`);
 });
 
-
-console.log("\nExtension overlay extraction complete!");
+console.log("\nExtension overlay extraction complete!");