@pdtf/schemas 3.4.1-3 → 3.4.1-5

package/package.json

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

package/src/schemas/v3/combined.json

@@ -190,6 +190,65 @@
           "participantStatus": {
             "type": "string",
             "enum": ["Proposed", "Invited", "Active", "Removed"]
+          },
+          "verification": {
+            "type": "object",
+            "properties": {
+              "identity": {
+                "type": "object",
+                "properties": {
+                  "result": {
+                    "type": "string",
+                    "enum": ["pass", "fail", "consider"]
+                  },
+                  "reports": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "reportName": {
+                          "type": "string"
+                        },
+                        "result": {
+                          "type": "string",
+                          "enum": ["pass", "fail", "consider"]
+                        },
+                        "details": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              },
+              "antiMoneyLaundering": {
+                "type": "object",
+                "properties": {
+                  "result": {
+                    "type": "string",
+                    "enum": ["pass", "fail", "consider"]
+                  },
+                  "reports": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "reportName": {
+                          "type": "string"
+                        },
+                        "result": {
+                          "type": "string",
+                          "enum": ["pass", "fail", "consider"]
+                        },
+                        "details": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
           }
         },
         "discriminator": {
@@ -1862,7 +1921,8 @@
                       }
                     },
                     "baspi4Required": ["wholeFreeholdForSale"],
-                    "baspi5Required": ["wholeFreeholdForSale"]
+                    "baspi5Required": ["wholeFreeholdForSale"],
+                    "nts2Required": ["estateRentcharges"]
                   },
                   {
                     "properties": {

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

@@ -58,7 +58,10 @@
                         ],
                         "type": "object"
                       }
-                    }
+                    },
+                    "required": [
+                      "estateRentcharges"
+                    ]
                   }
                 ]
               }

package/src/schemas/v3/overlays/nts2.json

@@ -318,7 +318,10 @@
                           }
                         }
                       }
-                    }
+                    },
+                    "required": [
+                      "estateRentcharges"
+                    ]
                   },
                   {
                     "properties": {

package/src/schemas/v3/pdtf-transaction.json

@@ -191,6 +191,81 @@
               "Active",
               "Removed"
             ]
+          },
+          "verification": {
+            "type": "object",
+            "properties": {
+              "identity": {
+                "type": "object",
+                "properties": {
+                  "result": {
+                    "type": "string",
+                    "enum": [
+                      "pass",
+                      "fail",
+                      "consider"
+                    ]
+                  },
+                  "reports": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "reportName": {
+                          "type": "string"
+                        },
+                        "result": {
+                          "type": "string",
+                          "enum": [
+                            "pass",
+                            "fail",
+                            "consider"
+                          ]
+                        },
+                        "details": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              },
+              "antiMoneyLaundering": {
+                "type": "object",
+                "properties": {
+                  "result": {
+                    "type": "string",
+                    "enum": [
+                      "pass",
+                      "fail",
+                      "consider"
+                    ]
+                  },
+                  "reports": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "properties": {
+                        "reportName": {
+                          "type": "string"
+                        },
+                        "result": {
+                          "type": "string",
+                          "enum": [
+                            "pass",
+                            "fail",
+                            "consider"
+                          ]
+                        },
+                        "details": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
           }
         },
         "oneOf": [

package/src/schemas/v3/skeleton.json

@@ -31,6 +31,24 @@
     "role": {},
     "externalIds": {},
     "participantStatus": {},
+    "verification": {
+      "identity": {
+        "result": {},
+        "reports": {
+          "reportName": {},
+          "result": {},
+          "details": {}
+        }
+      },
+      "antiMoneyLaundering": {
+        "result": {},
+        "reports": {
+          "reportName": {},
+          "result": {},
+          "details": {}
+        }
+      }
+    },
     "sellersCapacity": {
       "capacity": {},
       "sellersCapacityDetails": {},

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

@@ -351,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 =