@pdtf/schemas 3.4.1-2 → 3.4.1-4

package/index.js

@@ -92,197 +92,92 @@ const transactionSchemas = {
     v3CoreSchema,
 };
 
-const combineMerge = (target, source, options) => {
-  // Special handling for 'required' arrays - combine them uniquely
-  if (target.some((item) => typeof item === "string")) {
-    return [...new Set([...target, ...source])];
-  }
-
-  // For other arrays, concatenate while preserving uniqueness for primitive values
-  if (!options.isMergeableObject(target[0])) {
-    return [...new Set([...target, ...source])];
-  }
-
-  // Special handling for oneOf arrays - merge matching schemas based on discriminator
-  if (target[0]?.properties && source[0]?.properties) {
-    // Find a common discriminator property (a property with an enum)
-    const findDiscriminator = (schema) => {
-      const props = schema.properties;
-      return Object.keys(props).find((key) => Array.isArray(props[key]?.enum));
-    };
+// Custom array merge function for oneOf arrays
+const arrayMerge = (target, source) => {
+  // For string arrays (enum, required, etc.)
+  if (
+    target.length > 0 &&
+    source.length > 0 &&
+    target[0] &&
+    typeof target[0] === "string" &&
+    source[0] &&
+    typeof source[0] === "string"
+  ) {
+    // For required arrays, combine them (remove duplicates)
+    // Check if this looks like a required array (contains field names, not enum values)
+    const isRequiredArray = target.some(
+      (item) =>
+        typeof item === "string" &&
+        item.length > 0 &&
+        !item.includes("Yes") &&
+        !item.includes("No") &&
+        !item.includes("Not known") &&
+        !item.includes("To be connected")
+    );
 
-    const discriminator = findDiscriminator(target[0]);
-    if (discriminator) {
-      return target.map((targetSchema) => {
-        const targetEnum = targetSchema.properties?.[discriminator]?.enum || [];
-        const matchingSourceSchema = source.find((sourceSchema) => {
-          const sourceEnum =
-            sourceSchema.properties?.[discriminator]?.enum || [];
-          // Check if there's any overlap between the enum values
-          return sourceEnum.some((value) => targetEnum.includes(value));
-        });
-        if (matchingSourceSchema) {
-          return merge(targetSchema, matchingSourceSchema, options);
+    if (isRequiredArray) {
+      // Combine required arrays
+      const combined = [...target];
+      source.forEach((item) => {
+        if (!combined.includes(item)) {
+          combined.push(item);
         }
-        return targetSchema;
       });
+      return combined;
     }
+
+    // For other string arrays (like enum), use source if it exists, otherwise use target
+    return source.length > 0 ? source : target;
+  }
+
+  // If target is empty but source has values, use source
+  if (target.length === 0 && source.length > 0) {
+    return source;
   }
 
-  // For arrays of objects, merge by index and append remaining items
-  const destination = target.slice();
-  source.forEach((item, index) => {
-    if (typeof destination[index] === "undefined") {
-      destination[index] = options.cloneUnlessOtherwiseSpecified(item, options);
-    } else if (options.isMergeableObject(item)) {
-      destination[index] = merge(target[index], item, options);
+  // Ensure we only process arrays of the same length
+  // If source is shorter, pad with nulls
+  // If source is longer, truncate to target length
+  const paddedSource = [...source];
+  while (paddedSource.length < target.length) {
+    paddedSource.push(null);
+  }
+  paddedSource.splice(target.length);
+
+  return target.map((item, index) => {
+    if (paddedSource[index] === null || paddedSource[index] === undefined) {
+      return item;
     }
+    if (item === null || item === undefined) {
+      return paddedSource[index];
+    }
+    // Recursively merge nested objects and arrays
+    return merge(item, paddedSource[index], { arrayMerge });
   });
-  return destination;
 };
 
-const mergeEnums = (target, source) => source;
-
 const getTransactionSchema = (
   schemaId = "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json",
-  overlays // = ["baspiV4"]
+  overlays
 ) => {
   const sourceSchema = transactionSchemas[schemaId];
   if (!overlays || overlays.length < 1) return sourceSchema;
-  let mergedSchema = sourceSchema;
-  overlays.forEach((overlay) => {
-    // Handle both string keys and direct overlay objects
-    const overlaySchema =
-      typeof overlay === "string"
-        ? overlaysMap[schemaId][overlay] || {}
-        : overlay;
-
-    mergedSchema = merge(mergedSchema, overlaySchema, {
-      customMerge: (key) => {
-        if (key === "enum") {
-          return mergeEnums;
-        }
-      },
-      arrayMerge: combineMerge,
-    });
 
-    // Post-merge: Ensure overlay metadata is preserved
-    mergedSchema = preserveOverlayMetadata(mergedSchema, overlaySchema);
+  let mergedSchema = JSON.parse(JSON.stringify(sourceSchema)); // Deep copy
+  overlays.forEach((overlay) => {
+    const overlaySchema = JSON.parse(
+      JSON.stringify(overlaysMap[schemaId][overlay] || {})
+    ); // Deep copy
+    mergedSchema = merge(mergedSchema, overlaySchema, { arrayMerge });
   });
-  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 "";
-  return overlays
-    .map((overlay) => {
-      if (typeof overlay === "string") return overlay;
-      // Generate a simple hash of the object for caching
-      return JSON.stringify(overlay)
-        .split("")
-        .reduce((hash, char) => {
-          return ((hash << 5) - hash + char.charCodeAt(0)) | 0;
-        }, 0)
-        .toString(36);
-    })
-    .join(".");
+  return overlays.join(".");
 };
 
 const getValidator = (schemaId, overlays) => {

package/package.json

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

package/src/examples/v3/exampleTransaction.json

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

package/src/schemas/v3/combined.json

@@ -1862,7 +1862,8 @@
                       }
                     },
                     "baspi4Required": ["wholeFreeholdForSale"],
-                    "baspi5Required": ["wholeFreeholdForSale"]
+                    "baspi5Required": ["wholeFreeholdForSale"],
+                    "nts2Required": ["estateRentcharges"]
                   },
                   {
                     "properties": {

package/src/schemas/v3/overlays/extensions/as.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -34,6 +43,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

package/src/schemas/v3/overlays/extensions/dr.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -31,7 +40,11 @@
                     },
                     "attachments": {
                       "ntsRef": "A5.1.3",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     },
                     "yesNo": {
                       "enum": [

package/src/schemas/v3/overlays/extensions/er.json

@@ -24,6 +24,15 @@
                           }
                         },
                         "oneOf": [
+                          {
+                            "properties": {
+                              "yesNo": {
+                                "enum": [
+                                  "No"
+                                ]
+                              }
+                            }
+                          },
                           {
                             "required": [
                               "details",
@@ -49,7 +58,10 @@
                         ],
                         "type": "object"
                       }
-                    }
+                    },
+                    "required": [
+                      "estateRentcharges"
+                    ]
                   }
                 ]
               }

package/src/schemas/v3/overlays/extensions/fd.json

@@ -21,6 +21,15 @@
                     }
                   },
                   "oneOf": [
+                    {
+                      "properties": {
+                        "hasFloodDefences": {
+                          "enum": [
+                            "No"
+                          ]
+                        }
+                      }
+                    },
                     {
                       "required": [
                         "details"

package/src/schemas/v3/overlays/extensions/hi.json

@@ -13,6 +13,10 @@
                       "properties": {
                         "centralHeatingInstalled": {
                           "ntsRef": "B3.4.3.2",
+                          "oneOf": [
+                            {},
+                            {}
+                          ],
                           "type": "string"
                         }
                       },

package/src/schemas/v3/overlays/extensions/hs.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -33,6 +42,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

package/src/schemas/v3/overlays/extensions/jk.json

@@ -19,6 +19,16 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No",
+                        "Not known"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "managementPlanInPlace"
@@ -26,12 +36,23 @@
                   "properties": {
                     "managementPlanInPlace": {
                       "ntsRef": "A5.3.2",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No",
+                        "Not known"
+                      ]
                     },
                     "yesNo": {
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

package/src/schemas/v3/overlays/extensions/la.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "loftAccess": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details",
@@ -33,11 +42,19 @@
                     },
                     "loftBoarded": {
                       "ntsRef": "A1.2.4.3",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No"
+                      ]
                     },
                     "loftInsulated": {
                       "ntsRef": "A1.2.4.4",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No"
+                      ]
                     },
                     "loftAccess": {
                       "enum": [

package/src/schemas/v3/overlays/extensions/oc.json

@@ -19,6 +19,26 @@
                   "type": "string"
                 }
               },
+              "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "Yes"
+                      ]
+                    }
+                  }
+                }
+              ],
               "type": "object"
             }
           },

package/src/schemas/v3/overlays/extensions/sb.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -33,6 +42,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

package/src/schemas/v3/overlays/extensions/sf.json

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "hasSprayFoamInstalled": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -34,6 +43,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

package/src/schemas/v3/overlays/extensions/sl.json

@@ -23,6 +23,26 @@
                           "type": "string"
                         }
                       },
+                      "oneOf": [
+                        {
+                          "properties": {
+                            "yesNo": {
+                              "enum": [
+                                "Yes"
+                              ]
+                            }
+                          }
+                        },
+                        {
+                          "properties": {
+                            "yesNo": {
+                              "enum": [
+                                "No"
+                              ]
+                            }
+                          }
+                        }
+                      ],
                       "type": "object"
                     }
                   }

package/src/schemas/v3/overlays/extensions/tf.json

@@ -34,6 +34,15 @@
                                       }
                                     },
                                     "oneOf": [
+                                      {
+                                        "properties": {
+                                          "yesNo": {
+                                            "enum": [
+                                              "No"
+                                            ]
+                                          }
+                                        }
+                                      },
                                       {
                                         "required": [
                                           "details"

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

@@ -50,16 +50,6 @@ describe("Extension Overlays", () => {
       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,
-      ]);
-
-      expect(schemaString).toEqual(schemaDirect);
-    });
   });
 
   describe("Individual extension functionality", () => {
@@ -70,6 +60,7 @@ describe("Extension Overlays", () => {
           ?.properties?.japaneseKnotweed;
 
       expect(jkProp).toBeDefined();
+
       expect(jkProp.ntsRef).toBe("A5.3");
       expect(jkProp.required).toContain("yesNo");
       expect(jkProp.discriminator?.propertyName).toBe("yesNo");
@@ -131,6 +122,7 @@ describe("Extension Overlays", () => {
           ?.estateRentcharges;
 
       expect(erProp).toBeDefined();
+
       expect(erProp.ntsRef).toBe("A3.4");
       expect(erProp.required).toContain("yesNo");
       expect(erProp.discriminator?.propertyName).toBe("yesNo");
@@ -359,6 +351,89 @@ describe("Extension Overlays", () => {
       expect(siSection.required).toContain("containsAsbestos");
     });
 
+    test("should make estateRentcharges required when er extension is applied", () => {
+      const schema = getTransactionSchema(schemaId, ["nts2023", "er"]);
+
+      // Check that estateRentcharges is required at the oneOf branch level
+      const freeholdBranch =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[0];
+
+      expect(freeholdBranch).toBeDefined();
+      expect(freeholdBranch.required).toBeDefined();
+      expect(freeholdBranch.required).toContain("estateRentcharges");
+
+      // Verify the estateRentcharges property itself is properly structured
+      const erProp = freeholdBranch.properties?.estateRentcharges;
+      expect(erProp).toBeDefined();
+      expect(erProp.ntsRef).toBe("A3.4");
+      expect(erProp.required).toContain("yesNo");
+    });
+
+    test("should consistently apply required fields at parent level for extension properties", () => {
+      // Test multiple extensions that should have required fields at parent level
+      const schema = getTransactionSchema(schemaId, [
+        "nts2023",
+        "jk",
+        "er",
+        "ma",
+        "tf",
+      ]);
+
+      // Check specialist issues - japaneseKnotweed should be required
+      const siSection =
+        schema.properties?.propertyPack?.properties?.specialistIssues;
+      expect(siSection?.required).toContain("japaneseKnotweed");
+
+      // Check ownership - estateRentcharges should be required in freehold branch
+      const freeholdBranch =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[0];
+      expect(freeholdBranch?.required).toContain("estateRentcharges");
+
+      // Check leasehold - leaseholdInformation should be required in leasehold branch
+      const leaseholdBranch =
+        schema.properties?.propertyPack?.properties?.ownership?.properties
+          ?.ownershipsToBeTransferred?.items?.oneOf?.[2];
+      expect(leaseholdBranch?.required).toContain("leaseholdInformation");
+
+      // Verify that the required arrays are properly merged (not overwritten)
+      // Note: The length check might fail if only one extension is applied to specialistIssues
+      // Let's check what's actually in the required arrays
+      console.log("SpecialistIssues required:", siSection?.required);
+      console.log("FreeholdBranch required:", freeholdBranch?.required);
+      console.log("LeaseholdBranch required:", leaseholdBranch?.required);
+
+      expect(siSection.required.length).toBeGreaterThanOrEqual(1);
+      expect(freeholdBranch.required.length).toBeGreaterThan(0);
+      expect(leaseholdBranch.required.length).toBeGreaterThan(0);
+    });
+
+    test("should merge required arrays for multiple specialist issues overlays", () => {
+      // Apply multiple specialist issues overlays
+      const overlays = ["nts2023", "jk", "as", "dr", "sb", "hs"];
+      const schema = getTransactionSchema(schemaId, overlays);
+      const siSection =
+        schema.properties?.propertyPack?.properties?.specialistIssues;
+
+      // The overlays correspond to these property keys
+      const expectedRequired = [
+        "japaneseKnotweed",
+        "containsAsbestos",
+        "dryRotEtcTreatment",
+        "subsidenceOrStructuralFault",
+        "ongoingHealthOrSafetyIssue",
+      ];
+
+      expect(siSection?.required).toBeDefined();
+      // Should contain all expected keys
+      expectedRequired.forEach((key) => {
+        expect(siSection.required).toContain(key);
+      });
+      // Should be the same length as the number of overlays (excluding nts2023)
+      expect(siSection.required.length).toBe(expectedRequired.length);
+    });
+
     test("should handle discriminator patterns correctly", () => {
       const schema = getTransactionSchema(schemaId, ["nts2023", "jk"]);
       const jkProp =
@@ -393,5 +468,58 @@ describe("Extension Overlays", () => {
           conditionalBranch.required?.includes("details")
       ).toBeTruthy();
     });
+
+    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"]);
+
+      const containsAsbestos =
+        schema.properties?.propertyPack?.properties?.specialistIssues
+          ?.properties?.containsAsbestos;
+
+      expect(containsAsbestos).toBeDefined();
+      expect(containsAsbestos.discriminator?.propertyName).toBe("yesNo");
+      expect(containsAsbestos.oneOf).toBeDefined();
+      expect(containsAsbestos.oneOf).toHaveLength(2); // Both "No" and "Yes" branches
+
+      // Find the "No" branch - it should not have additional required fields
+      const noBranch = containsAsbestos.oneOf.find((branch) =>
+        branch.properties?.yesNo?.enum?.includes("No")
+      );
+      expect(noBranch).toBeDefined();
+      expect(noBranch.properties.yesNo.enum).toEqual(["No"]);
+      // The "No" branch should not have additional required fields beyond "yesNo"
+      expect(noBranch.required).toBeUndefined();
+
+      // Find the "Yes" branch - it should have additional required fields
+      const yesBranch = containsAsbestos.oneOf.find((branch) =>
+        branch.properties?.yesNo?.enum?.includes("Yes")
+      );
+      expect(yesBranch).toBeDefined();
+      expect(yesBranch.properties.yesNo.enum).toEqual(["Yes"]);
+      expect(yesBranch.required).toBeDefined();
+      expect(yesBranch.required).toContain("details");
+
+      // Test that data with "No" answer validates correctly using subschema validation
+      const { getSubschemaValidator } = require("../../../index.js");
+      const subschemaValidator = getSubschemaValidator(
+        "/propertyPack/specialistIssues/containsAsbestos",
+        schemaId,
+        ["as"]
+      );
+
+      const validDataWithNo = {
+        yesNo: "No",
+      };
+
+      const result = subschemaValidator(validDataWithNo);
+      // Handle both boolean and object return types
+      if (typeof result === "boolean") {
+        expect(result).toBe(true);
+      } else {
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      }
+    });
   });
 });

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

@@ -8,7 +8,6 @@ const {
   getValidator,
   getSubschemaValidator,
   getTitleAtPath,
-  overlaysMap,
 } = require("../../../index.js");
 
 const exampleTransaction = require("../../examples/v3/exampleTransaction.json");
@@ -33,14 +32,12 @@ test("sample is valid BASPI", () => {
   expect(testSchema.properties.propertyPack.baspi4Ref).toEqual("0");
   const validator = getValidator(schemaId, ["baspiV4"]);
   const isValid = validator(exampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
 test("sample is valid NTS", () => {
   const validator = getValidator(schemaId, ["nts2023"]);
   const isValid = validator(exampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
@@ -102,7 +99,6 @@ test("sample is valid NTSL if we change it accordingly", () => {
   delete clonedExampleTransaction.propertyPack.priceInformation;
   delete clonedExampleTransaction.propertyPack.ownership;
   const isValid = validator(clonedExampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
@@ -452,227 +448,3 @@ test("validates a valid contract", () => {
   const isValid = validator(data);
   expect(isValid).toBe(true);
 });
-
-test("overlay as key and as object produce identical results", () => {
-  // Get the NTS overlay object directly from the overlays map
-  const ntsOverlayObject = { ...overlaysMap[schemaId]["nts2023"] };
-  // Remove the $id to prevent schema registration conflicts
-  ntsOverlayObject.$id =
-    "https://trust.propdata.org.uk/schemas/v3/overlays/nts2024.json";
-
-  // Get schema using the key
-  const schemaWithKey = getTransactionSchema(schemaId, ["nts2023"]);
-
-  // Get schema using the object
-  const schemaWithObject = getTransactionSchema(schemaId, [ntsOverlayObject]);
-
-  // Create copies without $id for comparison
-  const schemaWithKeyNoId = { ...schemaWithKey };
-  const schemaWithObjectNoId = { ...schemaWithObject };
-  delete schemaWithKeyNoId.$id;
-  delete schemaWithObjectNoId.$id;
-
-  // Deep compare the results (excluding $id)
-  expect(schemaWithObjectNoId).toEqual(schemaWithKeyNoId);
-
-  // Test that validation produces the same errors
-  const validatorWithKey = getValidator(schemaId, ["nts2023"]);
-  const validatorWithObject = getValidator(schemaId, [ntsOverlayObject]);
-
-  validatorWithKey(exampleTransaction);
-  validatorWithObject(exampleTransaction);
-
-  // Compare validation errors
-  expect(validatorWithObject.errors).toEqual(validatorWithKey.errors);
-});
-
-test("correctly merges custom Japanese Knotweed overlay with base schema", () => {
-  // Load the custom overlay
-  const customOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-
-  // Get base schema and schema with overlay
-  const baseSchema = getTransactionSchema(schemaId);
-  const schemaWithOverlay = getTransactionSchema(schemaId, [customOverlay]);
-
-  // Verify that other properties in propertyPack are preserved
-  expect(
-    Object.keys(schemaWithOverlay.properties.propertyPack.properties)
-  ).toEqual(Object.keys(baseSchema.properties.propertyPack.properties));
-
-  // Verify that other properties in specialistIssues are preserved
-  const baseSpecialistIssues =
-    baseSchema.properties.propertyPack.properties.specialistIssues;
-  const overlaidSpecialistIssues =
-    schemaWithOverlay.properties.propertyPack.properties.specialistIssues;
-  expect(Object.keys(overlaidSpecialistIssues.properties)).toEqual(
-    Object.keys(baseSpecialistIssues.properties)
-  );
-
-  // Verify that Japanese Knotweed section is updated
-  const japaneseKnotweed = overlaidSpecialistIssues.properties.japaneseKnotweed;
-  expect(japaneseKnotweed.title).toBe(
-    "Is the property affected by Japanese knotweed?"
-  );
-  expect(japaneseKnotweed.required).toEqual(["yesNo"]);
-
-  // Verify the oneOf conditions are updated
-  expect(japaneseKnotweed.oneOf).toHaveLength(2);
-  expect(japaneseKnotweed.oneOf[0].properties.yesNo.enum).toEqual([
-    "No",
-    "Not known",
-  ]);
-  expect(japaneseKnotweed.oneOf[1].properties.yesNo.enum).toEqual(["Yes"]);
-  expect(japaneseKnotweed.oneOf[1].required).toEqual([
-    "managementPlanInPlace",
-    "attachments",
-  ]);
-});
-
-test("correctly merges multiple overlays using both key and object references", () => {
-  // Load the custom overlay
-  const customOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-
-  // Get schema with both overlays
-  const schemaWithOverlays = getTransactionSchema(schemaId, [
-    "nts2023",
-    customOverlay,
-  ]);
-
-  // Get individual overlay schemas for comparison
-  const ntsSchema = getTransactionSchema(schemaId, ["nts2023"]);
-  const customSchema = getTransactionSchema(schemaId, [customOverlay]);
-
-  // Verify propertyPack structure is preserved
-  const propertyPack = schemaWithOverlays.properties.propertyPack;
-  expect(Object.keys(propertyPack.properties)).toEqual(
-    expect.arrayContaining(
-      Object.keys(ntsSchema.properties.propertyPack.properties)
-    )
-  );
-
-  // Verify Japanese Knotweed changes from custom overlay are present
-  const japaneseKnotweed =
-    propertyPack.properties.specialistIssues.properties.japaneseKnotweed;
-  expect(japaneseKnotweed.title).toBe(
-    "Is the property affected by Japanese knotweed?"
-  );
-  expect(japaneseKnotweed.oneOf[1].required).toEqual([
-    "managementPlanInPlace",
-    "attachments",
-  ]);
-
-  // Verify customRef properties are correctly merged
-  expect(propertyPack.customRef).toBe("JKW");
-  expect(propertyPack.properties.specialistIssues.customRef).toBe("JKW.7");
-  expect(japaneseKnotweed.customRef).toBe("JKW.7.8");
-  expect(
-    japaneseKnotweed.oneOf[1].properties.managementPlanInPlace.customRef
-  ).toBe("JKW.7.8.2");
-  expect(japaneseKnotweed.oneOf[1].properties.attachments.customRef).toBe(
-    "JKW.7.8.3"
-  );
-  expect(japaneseKnotweed.properties.yesNo.customRef).toBe("JKW.7.8.1");
-
-  // Verify NTS specific changes are present (e.g., simplified enums)
-  const mainsElectricity =
-    propertyPack.properties.electricity.properties.mainsElectricity;
-  expect(mainsElectricity.properties.yesNo.enum).toEqual(["Yes", "No"]);
-
-  // Verify required fields from both overlays are merged
-  expect(propertyPack.required).toEqual(
-    expect.arrayContaining([
-      ...ntsSchema.properties.propertyPack.required,
-      ...customSchema.properties.propertyPack.required,
-    ])
-  );
-});
-
-test("correctly merges NTS and both custom overlays with proper required fields", () => {
-  // Load both custom overlays
-  const japaneseKnoweedOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-  const managingAgentOverlay = require("../../examples/v3/exampleCustomOverlay2.json");
-
-  // Get schema with all overlays
-  const schemaWithOverlays = getTransactionSchema(schemaId, [
-    "nts2023",
-    japaneseKnoweedOverlay,
-    managingAgentOverlay,
-  ]);
-
-  // Navigate to the leasehold section in the oneOf array
-  const leaseholdSchema =
-    schemaWithOverlays.properties.propertyPack.properties.ownership.properties.ownershipsToBeTransferred.items.oneOf.find(
-      (schema) => schema.properties.ownershipType.enum[0] === "Leasehold"
-    );
-
-  // Verify the leasehold information structure
-  const leaseholdInfo = leaseholdSchema.properties.leaseholdInformation;
-
-  // Check required fields - should include both NTS and custom overlay requirements
-  expect(leaseholdInfo.required).toContain("contactDetails");
-  expect(leaseholdInfo.required).toContain("leaseTerm"); // from NTS
-  expect(leaseholdInfo.required).toContain("groundRent"); // from NTS
-
-  // Verify managing agent contact structure and refs
-  const managingAgent =
-    leaseholdInfo.properties.contactDetails.properties.contacts.properties
-      .managingAgent;
-  expect(managingAgent.macRef).toBe("MAC.4.1c");
-
-  // Verify contact details structure
-  const contact = managingAgent.properties.contact;
-  expect(contact.properties.nameOrOrganisation.macRef).toBe("MAC.4.1c.1");
-  expect(contact.properties.address.macRef).toBe("MAC.4.1c.0");
-  expect(contact.properties.telephone.macRef).toBe("MAC.4.1c.7");
-  expect(contact.properties.emailAddress.macRef).toBe("MAC.4.1c.8");
-
-  // Verify Japanese Knotweed section is still present and correct
-  const japaneseKnotweed =
-    schemaWithOverlays.properties.propertyPack.properties.specialistIssues
-      .properties.japaneseKnotweed;
-  expect(japaneseKnotweed.customRef).toBe("JKW.7.8");
-
-  // Verify NTS changes are still present
-  const mainsElectricity =
-    schemaWithOverlays.properties.propertyPack.properties.electricity.properties
-      .mainsElectricity;
-  expect(mainsElectricity.properties.yesNo.enum).toEqual(["Yes", "No"]);
-});
-
-test("ta7 overlay as key and as object produce identical results at leasehold info level", () => {
-  // Get the TA7 overlay object directly from the overlays map
-  const ta7OverlayObject = { ...overlaysMap[schemaId]["ta7ed3"] };
-  // Remove the $id to prevent schema registration conflicts
-  ta7OverlayObject.$id =
-    "https://trust.propdata.org.uk/schemas/v3/overlays/ta7ed3-copy.json";
-
-  // Get schemas using both methods
-  const schemaWithKey = getTransactionSchema(schemaId, ["ta7ed3"]);
-  const schemaWithObject = getTransactionSchema(schemaId, [ta7OverlayObject]);
-
-  // Navigate to the leasehold information section in both schemas
-  const getLeaseholdInfo = (schema) => {
-    const ownershipsToBeTransferred =
-      schema.properties.propertyPack.properties.ownership.properties
-        .ownershipsToBeTransferred;
-    const leaseholdSchema = ownershipsToBeTransferred.items.oneOf.find(
-      (schema) => schema.properties.ownershipType.enum[0] === "Leasehold"
-    );
-    return leaseholdSchema.properties.leaseholdInformation;
-  };
-
-  const leaseholdInfoWithKey = getLeaseholdInfo(schemaWithKey);
-  const leaseholdInfoWithObject = getLeaseholdInfo(schemaWithObject);
-
-  // Deep compare the leasehold information sections
-  expect(leaseholdInfoWithObject).toEqual(leaseholdInfoWithKey);
-
-  // Verify specific TA7 requirements are present in both
-  expect(leaseholdInfoWithKey.required).toContain("contactDetails");
-  expect(leaseholdInfoWithObject.required).toContain("contactDetails");
-
-  // Verify TA7 refs are present and identical
-  const contactDetails = leaseholdInfoWithKey.properties.contactDetails;
-  expect(contactDetails.ta7Ref).toBe("4.1");
-  expect(leaseholdInfoWithObject.properties.contactDetails.ta7Ref).toBe("4.1");
-});

package/src/utils/extractExtensionOverlays.js

@@ -184,7 +184,7 @@ function hasNts2Ref(obj) {
 }
 
 // Extract only NTS2-specific properties (with nts2Ref)
-function extractNts2Properties(obj) {
+function extractNts2Properties(obj, parentKey) {
   const result = {};
 
   // Copy nts2-specific metadata at current level
@@ -205,7 +205,7 @@ function extractNts2Properties(obj) {
     Object.keys(obj.properties).forEach((key) => {
       const prop = obj.properties[key];
       if (hasNts2Ref(prop)) {
-        result.properties[key] = extractNts2Properties(prop);
+        result.properties[key] = extractNts2Properties(prop, key);
       }
     });
     // Only keep properties if we found some with nts2Ref
@@ -223,8 +223,8 @@ function extractNts2Properties(obj) {
 
   // Handle oneOf
   if (obj.oneOf) {
-    const processedOneOf = [];
-    obj.oneOf.forEach((schema, index) => {
+    // Always preserve the full array structure and order
+    const processedOneOf = obj.oneOf.map((schema, index) => {
       if (hasNts2Ref(schema)) {
         const extracted = extractNts2Properties(schema);
         // For oneOf schemas, we need to preserve discriminator enum values
@@ -239,11 +239,55 @@ function extractNts2Properties(obj) {
             };
           }
         }
-        processedOneOf.push(extracted);
+        // Also preserve base enum values for all other properties in the extension
+        if (schema.properties) {
+          if (!extracted.properties) extracted.properties = {};
+          Object.keys(schema.properties).forEach((propName) => {
+            const prop = schema.properties[propName];
+            if (prop.enum) {
+              if (!extracted.properties[propName]) {
+                extracted.properties[propName] = {
+                  enum: prop.enum,
+                };
+              } else if (!extracted.properties[propName].enum) {
+                // If the property exists but doesn't have enum, add it
+                extracted.properties[propName].enum = prop.enum;
+              }
+            }
+          });
+        }
+        return extracted;
+      } else {
+        // If this branch doesn't have nts2Ref, preserve the base discriminator enum
+        if (obj.discriminator && schema.properties) {
+          const propName = obj.discriminator.propertyName;
+          if (schema.properties[propName]) {
+            return {
+              properties: {
+                [propName]: {
+                  enum: schema.properties[propName].enum,
+                },
+              },
+            };
+          }
+        }
+        // If no discriminator, return empty object to preserve structure
+        return {};
       }
     });
-    if (processedOneOf.length > 0) {
-      result.oneOf = processedOneOf;
+    result.oneOf = processedOneOf;
+
+    // --- NEW: If this is an extension property inside a oneOf, promote it to the parent overlay ---
+    // If parentKey is set, and this object has extension metadata, return a stub for the parent
+    if (
+      parentKey &&
+      (result.ntsRef || 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
+      const parentStub = {};
+      Object.assign(parentStub, result);
+      return parentStub;
     }
   }