@pdtf/schemas 2.3.0 → 3.0.0-10

package/src/tests/{v2 → v3}/transactionSchema.test.js

@@ -10,24 +10,25 @@ const {
   getTitleAtPath,
 } = require("../../../index.js");
 
-const exampleTransaction = require("../../examples/v2/exampleTransaction.json");
+const exampleTransaction = require("../../examples/v3/exampleTransaction.json");
+
 const schemaId =
-  "https://trust.propdata.org.uk/schemas/v2/pdtf-transaction.json";
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
 // const validator = getValidator(schemaId);
-const v2TransactionSchema = getTransactionSchema(schemaId);
+const v3TransactionSchema = getTransactionSchema(schemaId);
 
-test("exports a property pack schema, v2 with baspi overlay by default", () => {
-  const testSchema = getTransactionSchema();
-  expect(testSchema.$id).toEqual(
-    "https://trust.propdata.org.uk/schemas/v2/pdtf-transaction.json"
-  );
+test("exports a property pack schema, v3 with no overlay by default", () => {
+  const testSchema = getTransactionSchema(schemaId);
+  // expect(testSchema.$id).toEqual(
+  //   "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json"
+  // );
   expect(
     testSchema.properties.propertyPack.properties.materialFacts.baspiRef
-  ).toEqual("A");
+  ).toEqual(undefined);
 });
 
 test("sample is valid BASPI", () => {
-  const testSchema = getTransactionSchema();
+  const testSchema = getTransactionSchema(schemaId, ["baspiV4"]);
   expect(
     testSchema.properties.propertyPack.properties.materialFacts.baspiRef
   ).toEqual("A");
@@ -37,12 +38,19 @@ test("sample is valid BASPI", () => {
   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);
+});
+
 test("invalid sample is invalid", () => {
   const clonedExampleTransaction = JSON.parse(
     JSON.stringify(exampleTransaction)
   );
   delete clonedExampleTransaction.propertyPack.materialFacts.notices;
-  const validator = getValidator(schemaId);
+  const validator = getValidator(schemaId, ["baspiV4"]);
   const isValid = validator(clonedExampleTransaction);
   expect(isValid).toBe(false);
 });
@@ -138,19 +146,11 @@ test("correctly gets yet, yet another subschema through a dependency", () => {
   expect(subschema.enum).toStrictEqual(["Yes", "No", "Not known"]);
 });
 
-test("correctly gets yet, yet, yet another subschema through a dependency", () => {
-  const subschema = getSubschema(
-    "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding/other/yesNo"
-  );
-  expect(subschema.type).toBe("string");
-  expect(subschema.enum).toStrictEqual(["Yes", "No"]);
-});
-
 test("correctly gets yet, yet, yet another subschema through a second item dependency", () => {
   const subschema = getSubschema(
     "/propertyPack/materialFacts/environmentalIssues/flooding/typeOfFlooding"
   );
-  expect(subschema.type).toBe("object");
+  expect(subschema.type).toBe("array");
 });
 
 test("correctly gets yes another subschema but through a non-baspi oneOf structure", () => {
@@ -167,6 +167,15 @@ test("correctly gets yes another subschema but through a non-baspi oneOf structu
   expect(subschema).toEqual({ type: "string" });
 });
 
+test("correctly gets an overlaid enum in a subschema", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/connectedUtilities/mainsElectricity/yesNo",
+    schemaId,
+    ["nts2023"]
+  );
+  expect(subschema.enum).toEqual(["Yes", "No"]);
+});
+
 test("correctly gets a subschema with multiple overlays", () => {
   const subschema = getSubschema(
     "/propertyPack/materialFacts/parking/parkingArrangements",
@@ -268,14 +277,14 @@ test("correctly gets a subschema validator for an NTS overlay", () => {
   expect(isValid).toBe(true);
 });
 
-test("correctly gets a subschema validator for an LPE1 overlay", () => {
+test("correctly gets a subschema validator for an TA7 overlay", () => {
   const path = "/propertyPack";
   const clonedExampleTransaction = JSON.parse(
     JSON.stringify(exampleTransaction)
   );
   const data = jp.get(clonedExampleTransaction, path);
   const validator = getSubschemaValidator(path, exampleTransaction.$schema, [
-    "lpe1ed4",
+    "ta7ed3",
   ]);
   let isValid = validator(data);
   expect(isValid).toBe(false);
@@ -296,55 +305,56 @@ test("correctly gets a subschema validator which validates", () => {
 test("correctly gets titles across schemas, arrays and non-existient title properties", () => {
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/ownershipType"
     )
   ).toBe("What type of ownership is the property?");
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/leaseTerm/lengthOfLeaseInYears"
     )
   ).toBe("Length of lease (years)");
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
-      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/serviceCharge/annualServiceCharge"
-    )
-  ).toBe("Amount of current annual service charge (£)");
-  expect(
-    getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/materialFacts/invalidPath"
     )
   ).toBe(undefined);
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/titlesToBeSold/0/registerExtract"
     )
   ).toBe("HMLR Official Copy Register Extract");
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/PropertyAddress"
     )
   ).toBe("Property address");
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/InvalidProp"
     )
   ).toBe(undefined);
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/materialFacts/energyEfficiency/certificate/currentEnergyRating"
     )
   ).toBe("Current energy efficiency rating");
+
   expect(
     getTitleAtPath(
-      v2TransactionSchema,
+      v3TransactionSchema,
       "/propertyPack/additionalLegalInfo/occupiers/othersAged17OrOver/aged17OrOverNames"
     )
   ).toBe("Please provide their full names and ages.");

package/src/tests/{v2 → v3}/verifiedClaimsValidator.test.js

@@ -2,8 +2,8 @@ const { validateVerifiedClaims } = require("../../../index.js");
 
 const exampleVouch = require("../../examples/v1/exampleVouch.json");
 const exampleDocumentedVouch = require("../../examples/v1/exampleDocumentedVouch.json");
-const v2SchemaId =
-  "https://trust.propdata.org.uk/schemas/v2/pdtf-transaction.json";
+const v3SchemaId =
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
 
 test("returns an empty array for a valid claim", () => {
   expect(validateVerifiedClaims([exampleVouch])).toEqual([]);
@@ -21,20 +21,20 @@ test("returns an array with an error stating if path is incorrect", () => {
   clonedVouch.claims = {
     "/propertyPack/INVALID/materialFacts/councilTax": data,
   };
-  // v2 schema, no overlay
-  expect(validateVerifiedClaims([clonedVouch], v2SchemaId, null)).toEqual([
+  // v3 schema, no overlay
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([
     "Path /propertyPack/INVALID/materialFacts/councilTax is not a valid PDTF schema path",
   ]);
 });
 
-test("returns errors if BASPI requirements are not met and BASPI overlay is specified (default)", () => {
+test("returns errors if BASPI requirements are not met and BASPI overlay is specified", () => {
   const clonedVouch = JSON.parse(JSON.stringify(exampleVouch));
   clonedVouch.claims = {
     "/propertyPack/materialFacts/delayFactors": {
       hasDelayFactors: { yesNo: "Yes" },
     },
   };
-  const errors = validateVerifiedClaims([clonedVouch], v2SchemaId);
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId, ["baspiV4"]);
   expect(errors).toEqual([
     {
       instancePath: "/hasDelayFactors",
@@ -60,7 +60,7 @@ test("returns no errors if BASPI requirements are not met and null overlay is sp
       hasDelayFactors: { yesNo: "Yes" },
     },
   };
-  const errors = validateVerifiedClaims([clonedVouch], v2SchemaId, null);
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId, null);
   expect(errors).toEqual([]);
 });
 
@@ -71,7 +71,7 @@ test("returns errors for invalid fields even if null overlay is specified", () =
       hasDelayFactors: { yesNo: "Maybe" },
     },
   };
-  const errors = validateVerifiedClaims([clonedVouch], v2SchemaId, null);
+  const errors = validateVerifiedClaims([clonedVouch], v3SchemaId, null);
   expect(errors).toHaveLength(4);
 });
 
@@ -95,7 +95,7 @@ test("returns an array of errors for verified claim with multiple paths", () =>
       },
     },
   };
-  expect(validateVerifiedClaims([clonedVouch], v2SchemaId, null)).toEqual([
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([
     "Path /propertyPack/materialFacts/cousncilTaxBad is not a valid PDTF schema path",
     "Path /propertyPack/materialFacts/councilTaxBadTwo is not a valid PDTF schema path",
   ]);
@@ -104,7 +104,7 @@ test("returns an array of errors for verified claim with multiple paths", () =>
 test("returns an empty array of errors for verified claim with multiple valid paths", () => {
   const clonedVouch = JSON.parse(
     JSON.stringify(exampleVouch),
-    v2SchemaId,
+    v3SchemaId,
     null
   );
   clonedVouch.claims = {
@@ -124,5 +124,5 @@ test("returns an empty array of errors for verified claim with multiple valid pa
       postcode: "property.postcode",
     },
   };
-  expect(validateVerifiedClaims([clonedVouch], v2SchemaId, null)).toEqual([]);
+  expect(validateVerifiedClaims([clonedVouch], v3SchemaId, null)).toEqual([]);
 });

package/src/utils/extractOverlay.js

@@ -4,7 +4,7 @@ const jp = require("jsonpointer");
 const fs = require("fs");
 const merge = require("deepmerge");
 
-const combinedSchema = require("../schemas/v2/combined.json");
+const combinedSchema = require("../schemas/v3/combined.json");
 
 const extractFields = [
   "baspi",
@@ -23,30 +23,15 @@ const extractFields = [
 ];
 
 const overlayIncludeProperties = [
-  "title",
-  "description",
-  "enum",
+  // "title",
+  // "description",
+  // "enum",
   "discriminator",
-  "minItems",
+  // "minItems",
 ];
 
-const combineMerge = (target, source, options) => {
-  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);
-    } else if (target.indexOf(item) === -1) {
-      destination.push(item);
-    }
-  });
-  return destination;
-};
-
 const flattenSkeleton = (schema) => {
   if (!schema) return undefined;
-  // console.log(schema.properties);
   let returnStructure = {};
   if (schema.properties) {
     Object.keys(schema.properties).forEach((key) => {
@@ -55,10 +40,8 @@ const flattenSkeleton = (schema) => {
   }
   if (schema.oneOf) {
     schema.oneOf.forEach((aOneOf) => {
-      // console.log(aOneOf);
       if (aOneOf.properties) {
         Object.entries(aOneOf.properties).forEach(([key, value]) => {
-          // console.log(aProperty);
           returnStructure[key] = flattenSkeleton(value);
         });
       }
@@ -74,7 +57,7 @@ const extractOverlay = (sourceSchema, ref) => {
   const refName = `${ref}Ref`;
   const returnSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
-    $id: `https://trust.propdata.org.uk/schemas/v2/overlays/${ref}.json`,
+    $id: `https://trust.propdata.org.uk/schemas/v3/overlays/${ref}.json`,
   };
   traverse(sourceSchema).forEach(function (element) {
     let path = "/" + this.path.join("/");
@@ -153,14 +136,9 @@ const deleteProperties = (sourceSchema, propertyNames) => {
 const overlays = {};
 
 extractFields.forEach((key) => {
-  let overlay = extractOverlay(combinedSchema, key, [
-    "title",
-    "description",
-    "enum",
-    "discriminator",
-  ]);
+  let overlay = extractOverlay(combinedSchema, key);
   overlays[key] = overlay;
-  const fileName = `../schemas/v2/overlays/${key}.json`;
+  const fileName = `../schemas/v3/overlays/${key}.json`;
   fs.writeFileSync(fileName, JSON.stringify(overlay, null, 2));
   console.log(`Overlay ${key} written to ${fileName}`);
 });
@@ -174,10 +152,10 @@ const coreSchema = deleteProperties(combinedSchema, [
 ]);
 
 fs.writeFileSync(
-  "../schemas/v2/pdtf-transaction.json",
+  "../schemas/v3/pdtf-transaction.json",
   JSON.stringify(coreSchema, null, 2)
 );
-console.log("Core schema written to ../schemas/v2/pdtf-transaction.json");
+console.log("Core schema written to ../schemas/v3/pdtf-transaction.json");
 
 const skeletonSchema = deleteProperties(coreSchema, [
   "$schema",
@@ -196,7 +174,7 @@ const skeletonSchema = deleteProperties(coreSchema, [
 const skeletonSchemaFlattened = flattenSkeleton(skeletonSchema);
 
 fs.writeFileSync(
-  "../schemas/v2/skeleton.json",
+  "../schemas/v3/skeleton.json",
   JSON.stringify(skeletonSchemaFlattened, null, 2)
 );
-console.log("Flat Skeleton schema written to ../schemas/v2/skeleton.json");
+console.log("Flat Skeleton schema written to ../schemas/v3/skeleton.json");

package/src/utils/hmlrLLC1.json

@@ -1,275 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft-07/schema#",
-  "$id": "http://www.landregistry.gov.uk/LLC/LLCSearchResponseV2_0#",
-  "type": "object",
-  "properties": {
-    "LocalLandCharge": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "HMLRReference",
-          "RegistrationDate",
-          "Category",
-          "Location",
-          "LocationDominantBuilding"
-        ],
-        "properties": {
-          "HMLRReference": {
-            "type": "string"
-          },
-          "OriginatingAuthority": {
-            "type": "string"
-          },
-          "AuthorityReference": {
-            "type": "string"
-          },
-          "CreationDate": {
-            "type": "object",
-            "properties": {
-              "Value": {
-                "type": "string",
-                "format": "date"
-              }
-            }
-          },
-          "RegistrationDate": {
-            "type": "object",
-            "properties": {
-              "Value": {
-                "type": "string",
-                "format": "date"
-              }
-            }
-          },
-          "Category": {
-            "type": "string"
-          },
-          "ChargeSubCategory": {
-            "type": "string"
-          },
-          "Law": {
-            "type": "string"
-          },
-          "LegalDocument": {
-            "type": "string"
-          },
-          "Location": {
-            "type": "object",
-            "required": ["AddressLine"],
-            "properties": {
-              "PostcodeZone": {
-                "type": "object",
-                "required": ["Postcode"],
-                "properties": {
-                  "Postcode": {
-                    "type": "string"
-                  }
-                }
-              },
-              "AddressLine": {
-                "type": "object",
-                "properties": {
-                  "IndexNumeric": {
-                    "type": "array",
-                    "items": {
-                      "type": "object",
-                      "properties": {
-                        "Value": {
-                          "type": "number"
-                        }
-                      }
-                    },
-                    "minItems": 0
-                  },
-                  "Line": {
-                    "type": "array",
-                    "items": {
-                      "type": "string"
-                    },
-                    "minItems": 0
-                  }
-                }
-              }
-            }
-          },
-          "LocationDominantBuilding": {
-            "type": "object",
-            "required": ["AddressLine"],
-            "properties": {
-              "PostcodeZone": {
-                "type": "object",
-                "required": ["Postcode"],
-                "properties": {
-                  "Postcode": {
-                    "type": "string"
-                  }
-                }
-              },
-              "AddressLine": {
-                "type": "object",
-                "properties": {
-                  "IndexNumeric": {
-                    "type": "array",
-                    "items": {
-                      "type": "number"
-                    },
-                    "minItems": 0
-                  },
-                  "Line": {
-                    "type": "array",
-                    "items": {
-                      "type": "string"
-                    },
-                    "minItems": 0
-                  }
-                }
-              }
-            }
-          },
-          "Description": {
-            "type": "string"
-          },
-          "SourceOfInformation": {
-            "type": "string"
-          },
-          "AvailableDocument": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "required": ["Document"],
-              "properties": {
-                "Document": {
-                  "type": "string"
-                },
-                "StartDate": {
-                  "type": "string",
-                  "format": "date"
-                },
-                "EndDate": {
-                  "type": "string",
-                  "format": "date"
-                }
-              }
-            },
-            "minItems": 0
-          },
-          "InterestInLand": {
-            "type": "string"
-          },
-          "ApplicantName": {
-            "type": "string"
-          },
-          "ApplicantAddress": {
-            "type": "object",
-            "required": ["AddressLine"],
-            "properties": {
-              "PostcodeZone": {
-                "type": "object",
-                "required": ["Postcode"],
-                "properties": {
-                  "Postcode": {
-                    "type": "string"
-                  }
-                }
-              },
-              "AddressLine": {
-                "type": "object",
-                "properties": {
-                  "IndexNumeric": {
-                    "type": "array",
-                    "items": {
-                      "type": "object",
-                      "properties": {
-                        "Value": {
-                          "type": "number"
-                        }
-                      }
-                    },
-                    "minItems": 0
-                  },
-                  "Line": {
-                    "type": "array",
-                    "items": {
-                      "type": "object",
-                      "properties": {
-                        "Value": {
-                          "type": "string"
-                        }
-                      }
-                    },
-                    "minItems": 0
-                  }
-                }
-              }
-            }
-          },
-          "ServientLandDevelopment": {
-            "type": "object",
-            "required": ["Height", "CoversAllOrPartOfExtent"],
-            "properties": {
-              "Height": {
-                "type": "string"
-              },
-              "CoversAllOrPartOfExtent": {
-                "type": "string"
-              }
-            }
-          },
-          "Amount": {
-            "type": "string"
-          },
-          "InterestRate": {
-            "type": "string"
-          },
-          "LandSold": {
-            "type": "string"
-          },
-          "WorksDone": {
-            "type": "string"
-          },
-          "AdvancePayment": {
-            "type": "string"
-          },
-          "TotalCompensation": {
-            "type": "string"
-          },
-          "AgreedOrEstimated": {
-            "type": "string"
-          },
-          "Adjoining": {
-            "type": "boolean"
-          },
-          "OtherData": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "required": ["DataLabel", "Data"],
-              "properties": {
-                "DataLabel": {
-                  "type": "string"
-                },
-                "Data": {
-                  "type": "string"
-                }
-              }
-            },
-            "minItems": 0
-          },
-          "ChargeExtent": {
-            "type": "object",
-            "properties": {
-              "Value": {
-                "type": "string"
-              },
-              "format": {
-                "type": "string"
-              }
-            }
-          }
-        }
-      },
-      "minItems": 0
-    }
-  }
-}