@pdtf/schemas 3.2.1-9 → 3.4.0-1

package/src/schemas/v3/skeleton.json

@@ -30,6 +30,7 @@
     "organisationReference": {},
     "role": {},
     "externalIds": {},
+    "participantStatus": {},
     "sellersCapacity": {
       "capacity": {},
       "sellersCapacityDetails": {},
@@ -214,6 +215,11 @@
         "titleNumber": {},
         "titlePropertyDescription": {},
         "ownershipType": {},
+        "estateRentcharges": {
+          "yesNo": {},
+          "details": {},
+          "amount": {}
+        },
         "wholeFreeholdForSale": {
           "yesNo": {},
           "details": {}
@@ -1066,6 +1072,7 @@
     "typeOfConstruction": {
       "isStandardForm": {
         "yesNo": {},
+        "constructionType": {},
         "details": {}
       },
       "buildingSafety": {
@@ -2337,6 +2344,10 @@
           "hasBeenFlooded": {},
           "typeOfFlooding": {},
           "details": {}
+        },
+        "floodDefences": {
+          "hasFloodDefences": {},
+          "details": {}
         }
       },
       "radon": {
@@ -2816,7 +2827,12 @@
     },
     "saleReadyDeclarations": {
       "authorisedToActOnBehalfOfAllSellers": {},
-      "authorisationToShare": {}
+      "authorisationToShare": {},
+      "sellerSignatures": {
+        "name": {},
+        "signedOn": {},
+        "externalIds": {}
+      }
     },
     "localSearches": {
       "localLandCharges": {
@@ -3181,7 +3197,7 @@
               "yesNo": {},
               "details": {}
             },
-            "floodAndCostalErosionRiskManagement": {
+            "floodAndCoastalErosionRiskManagement": {
               "yesNo": {},
               "details": {}
             }
@@ -4089,5 +4105,44 @@
         "pricingMethodology": {}
       }
     }
+  },
+  "contracts": {
+    "contract": {
+      "template": {
+        "name": {},
+        "url": {},
+        "externalIds": {},
+        "requiredSignatories": {
+          "role": {},
+          "requiresAll": {}
+        }
+      },
+      "terms": {}
+    },
+    "signatures": {
+      "name": {},
+      "signedOn": {},
+      "externalIds": {}
+    }
+  },
+  "chain": {
+    "onwardPurchase": {
+      "transactionId": {},
+      "externalIds": {},
+      "address": {
+        "buildingNumber": {},
+        "buildingName": {},
+        "subBuilding": {},
+        "street": {},
+        "line1": {},
+        "line2": {},
+        "line 3": {},
+        "town": {},
+        "postcode": {},
+        "homeNation": {}
+      },
+      "uprn": {},
+      "sellingAgent": {}
+    }
   }
-}
+}

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

@@ -8,6 +8,7 @@ const {
   getValidator,
   getSubschemaValidator,
   getTitleAtPath,
+  overlaysMap,
 } = require("../../../index.js");
 
 const exampleTransaction = require("../../examples/v3/exampleTransaction.json");
@@ -90,6 +91,18 @@ test("sample with missing dependent required fields is invalid", () => {
   expect(isValid).toBe(false);
 });
 
+test("sample with missing dependent required fields with NTS overlay is invalid", () => {
+  // Previously a required field was missing from the NTS overlay
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  clonedExampleTransaction.propertyPack.ownership.ownershipsToBeTransferred[0].leaseholdInformation =
+    undefined;
+  const validator = getValidator(schemaId, ["nts2023"]);
+  const isValid = validator(clonedExampleTransaction);
+  expect(isValid).toBe(false);
+});
+
 test("correctly gets a top level subschema", () => {
   const subschema = getSubschema("/propertyPack");
   expect(subschema.title).toBe("Property Pack");
@@ -396,3 +409,234 @@ test("correctly gets titles across schemas, arrays and non-existient title prope
     )
   ).toBe("Please provide their full names and ages.");
 });
+test("validates a valid contract", () => {
+  const path = "/contracts";
+  const data = jp.get(exampleTransaction, path);
+  const validator = getSubschemaValidator(path, exampleTransaction.$schema);
+  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/extractOverlay.js

@@ -10,8 +10,9 @@ const extractFields = [
   "baspi4",
   "baspi5",
   "nts",
-  "nts-sef",
+  "nts2",
   "ntsl",
+  "ntsl2",
   "ta6",
   "ta7",
   "ta10",