@pdtf/schemas 1.1.2 → 2.0.0-0

package/src/tests/{pdtfVerifiedClaims.test.js → v1/pdtfVerifiedClaims.test.js}

@@ -1,10 +1,10 @@
 const Ajv = require("ajv");
 const addFormats = require("ajv-formats");
 
-const verifiedClaimsSchema = require("../schemas/v1/pdtf-verified-claims.json");
-const exampleElectronicRecord = require("../examples/exampleElectronicRecord.json");
-const exampleVouch = require("../examples/exampleVouch.json");
-const exampleDocumentedVouch = require("../examples/exampleDocumentedVouch.json");
+const verifiedClaimsSchema = require("../../schemas/v1/pdtf-verified-claims.json");
+const exampleElectronicRecord = require("../../examples/v1/exampleElectronicRecord.json");
+const exampleVouch = require("../../examples/v1/exampleVouch.json");
+const exampleDocumentedVouch = require("../../examples/v1/exampleDocumentedVouch.json");
 
 const ajv = new Ajv({
   allErrors: true,

package/src/tests/{transactionSchema.test.js → v1/transactionSchema.test.js}

@@ -7,8 +7,8 @@ const {
   isPathValid,
   getSubschemaValidator,
   getTitleAtPath,
-} = require("../../index.js");
-const exampleTransaction = require("../examples/exampleTransaction.json");
+} = require("../../../index.js");
+const exampleTransaction = require("../../examples/v1/exampleTransaction.json");
 
 test("exports a property pack schema", () => {
   expect(transactionSchema).not.toBeNull();
@@ -34,7 +34,7 @@ test("sample with missing dependent required fields is invalid", () => {
     JSON.stringify(exampleTransaction)
   );
   clonedExampleTransaction.propertyPack.materialFacts.ownership.ownershipsToBeTransferred[0].ownershipType =
-    "leashold";
+    "leasehold";
   const isValid = validator(clonedExampleTransaction);
   expect(isValid).toBe(false);
 });

package/src/tests/{verifiedClaimsValidator.test.js → v1/verifiedClaimsValidator.test.js}

@@ -1,7 +1,7 @@
-const { validateVerifiedClaims } = require("../../index.js");
+const { validateVerifiedClaims } = require("../../../index.js");
 
-const exampleVouch = require("../examples/exampleVouch.json");
-const exampleDocumentedVouch = require("../examples/exampleDocumentedVouch.json");
+const exampleVouch = require("../../examples/v1/exampleVouch.json");
+const exampleDocumentedVouch = require("../../examples/v1/exampleDocumentedVouch.json");
 
 test("returns an empty array for a valid claim", () => {
   expect(validateVerifiedClaims([exampleVouch])).toEqual([]);

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

@@ -0,0 +1,255 @@
+const jp = require("jsonpointer");
+const fs = require("fs");
+
+const {
+  getTransactionSchema,
+  getSubschema,
+  isPathValid,
+  getValidator,
+  getSubschemaValidator,
+  getTitleAtPath,
+} = require("../../../index.js");
+
+const exampleTransaction = require("../../examples/v2/exampleTransaction.json");
+const schemaId =
+  "https://trust.propdata.org.uk/schemas/v2/pdtf-transaction.json";
+// const validator = getValidator(schemaId);
+const v2TransactionSchema = 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"
+  );
+  expect(
+    testSchema.properties.propertyPack.properties.materialFacts.baspiRef
+  ).toEqual("A");
+});
+
+test("sample is valid", () => {
+  const testSchema = getTransactionSchema();
+  expect(
+    testSchema.properties.propertyPack.properties.materialFacts.baspiRef
+  ).toEqual("A");
+  const validator = getValidator(schemaId);
+  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 isValid = validator(clonedExampleTransaction);
+  expect(isValid).toBe(false);
+});
+
+test("sample with missing dependent required fields is invalid", () => {
+  const clonedExampleTransaction = JSON.parse(
+    JSON.stringify(exampleTransaction)
+  );
+  clonedExampleTransaction.propertyPack.materialFacts.ownership.ownershipsToBeTransferred[0].ownershipType =
+    "leasehold";
+  const validator = getValidator(schemaId);
+  const isValid = validator(clonedExampleTransaction);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a top level subschema", () => {
+  const subschema = getSubschema("/propertyPack", v2TransactionSchema);
+  expect(subschema.title).toBe("Property Pack");
+});
+
+test("correctly identifies a valid path", () => {
+  const isValid = isPathValid(
+    "/propertyPack/materialFacts",
+    v2TransactionSchema
+  );
+  expect(isValid).toBe(true);
+});
+
+test("correctly identifies an undefined invalid path", () => {
+  const isValid = isPathValid(
+    "/propertyPack/materialItems",
+    v2TransactionSchema
+  );
+  expect(isValid).toBe(false);
+});
+
+test("correctly identifies an error generating invalid path", () => {
+  const isValid = isPathValid(
+    "/propertyPack/materialItems/someProperty/item",
+    v2TransactionSchema
+  );
+  expect(isValid).toBe(false);
+});
+
+test("correctly identifies an array invalid path", () => {
+  const isValid = isPathValid(
+    "/propertyPack/materialFacts/1/item",
+    v2TransactionSchema
+  );
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets a subschema", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/notices",
+    v2TransactionSchema
+  );
+  expect(subschema.title).toBe("Notices which Affect the Property");
+});
+
+test("correctly gets a subschema through an arrays element", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract",
+    v2TransactionSchema
+  );
+  expect(Object.keys(subschema.properties)).toEqual([
+    "OCSummaryData",
+    "OCRegisterData",
+  ]);
+});
+
+test("correctly gets a subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/delayFactors/hasDelayFactors/details",
+    v2TransactionSchema
+  );
+  expect(subschema.title).toBe("Details");
+});
+
+test("correctly gets another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/general/leaseTerm/lengthOfLeaseInYears",
+    v2TransactionSchema
+  );
+  expect(subschema.title).toBe("Length of lease (years)");
+});
+
+test("correctly gets yet another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/rentIncrease/details"
+  );
+  expect(subschema.title).toBe("Details");
+});
+
+test("correctly gets yet, yet another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/listingAndConservation/isConservationArea/yesNo"
+  );
+  expect(subschema.type).toBe("string");
+  expect(subschema.enum).toStrictEqual(["Yes", "No"]);
+});
+
+test("correctly gets yet, yet, yet another subschema through a dependency", () => {
+  const subschema = getSubschema(
+    "/propertyPack/materialFacts/otherIssues/flooding/typeOfFlooding/groundWater/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/otherIssues/flooding/typeOfFlooding"
+  );
+  expect(subschema.type).toBe("object");
+});
+
+test("correctly gets yes another subschema but through a non-baspi oneOf structure", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/ChargeRestriction/EntryDetails/EntryText"
+  );
+  expect(subschema).toEqual({ type: "string" });
+});
+
+test("correctly gets yes another subschema but through a non-baspi oneOf structure with array option", () => {
+  const subschema = getSubschema(
+    "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/RestrictionDetails/RestrictionEntry/0/ChargeRestriction/EntryDetails/EntryText"
+  );
+  expect(subschema).toEqual({ type: "string" });
+});
+
+test("correctly gets a subschema validator which is already cached", () => {
+  const validator = getSubschemaValidator(
+    "/propertyPack/energyPerformanceCertificate"
+  );
+  expect(validator).not.toBeNull();
+  const anotherValidator = getSubschemaValidator(
+    "/propertyPack/energyPerformanceCertificate"
+  );
+  expect(anotherValidator).not.toBeNull();
+});
+
+test("correctly gets a subschema validator which validates", () => {
+  const path = "/propertyPack/materialFacts/notices";
+  const validator = getSubschemaValidator(path);
+  const data = jp.get(exampleTransaction, path);
+  expect(data.neighbourDevelopment.yesNo).toBe("No");
+  let isValid = validator(data);
+  expect(isValid).toBe(true);
+  data.neighbourDevelopment.yesNo = "Invalid string";
+  isValid = validator(data);
+  expect(isValid).toBe(false);
+});
+
+test("correctly gets titles across schemas, arrays and non-existient title properties", () => {
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/ownershipType"
+    )
+  ).toBe("What type of ownership is the property?");
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/materialFacts/ownership/ownershipsToBeTransferred/0/leaseholdInformation/general/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,
+      "/propertyPack/materialFacts/invalidPath"
+    )
+  ).toBe(undefined);
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract"
+    )
+  ).toBe("HMLR Official Copy Register Extract");
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/PropertyAddress"
+    )
+  ).toBe("Property address");
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/titlesToBeSold/0/registerExtract/OCSummaryData/InvalidProp"
+    )
+  ).toBe(undefined);
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/materialFacts/energyEfficiency/certificate/currentEnergyRating"
+    )
+  ).toBe("Current energy efficiency rating");
+  expect(
+    getTitleAtPath(
+      v2TransactionSchema,
+      "/propertyPack/additionalLegalInfo/occupiers/othersAged17OrOver/aged17OrOverNames"
+    )
+  ).toBe("Please provide their full names and ages.");
+});

package/src/utils/extractOverlay.js

@@ -0,0 +1,100 @@
+const { dereference } = require("@jdw/jst");
+const traverse = require("traverse");
+const jp = require("jsonpointer");
+const fs = require("fs");
+const merge = require("deepmerge");
+
+const combinedSchema = require("../schemas/v2/combined.json");
+
+const extractFields = [
+  "baspi",
+  "nts",
+  "ta6",
+  "ta7",
+  "ta10",
+  "lpe1",
+  "fme1",
+  "con29R",
+  "con29DW",
+  "llc1",
+  "rds",
+  "oc1",
+];
+
+const overlayIncludeProperties = [
+  "title",
+  "description",
+  "enum",
+  "discriminator",
+];
+
+const extractOverlay = (sourceSchema, ref) => {
+  const refName = `${ref}Ref`;
+  const refRequired = `${ref}Required`;
+  const returnSchema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $id: `https://trust.propdata.org.uk/schemas/v2/overlays/${ref}.json`,
+  };
+  traverse(sourceSchema).forEach(function (element) {
+    let path = "/" + this.path.join("/");
+    if (path === "/") path = "";
+    if (element[refName]) {
+      jp.set(returnSchema, `${path}/${refName}`, element[refName]);
+      overlayIncludeProperties.forEach((property) => {
+        if (element[property]) {
+          jp.set(returnSchema, `${path}/${property}`, element[property]);
+        }
+      });
+      const { discriminator } = element;
+
+      if (discriminator) {
+        const { propertyName } = discriminator;
+        element.oneOf.forEach((item, index) => {
+          const discriminatorProperty = item.properties[propertyName];
+          jp.set(
+            returnSchema,
+            `${path}/oneOf/${index}/properties/${propertyName}`,
+            discriminatorProperty
+          );
+        });
+      }
+    }
+    if (element[refRequired]) {
+      jp.set(returnSchema, `${path}/required`, element[refRequired]);
+    }
+  });
+  return returnSchema;
+};
+
+const deleteProperties = (sourceSchema, propertyNames) => {
+  traverse(sourceSchema).forEach(function (element) {
+    if (propertyNames.includes(this.key)) {
+      this.delete(true); // true = stop here
+    }
+  });
+  return sourceSchema;
+};
+
+extractFields.forEach((key) => {
+  let overlay = extractOverlay(combinedSchema, key, [
+    "title",
+    "description",
+    "enum",
+    "discriminator",
+  ]);
+  const fileName = `../schemas/v2/overlays/${key}.json`;
+  fs.writeFileSync(fileName, JSON.stringify(overlay, null, 2));
+  console.log(`Overlay ${key} written to ${fileName}`);
+});
+
+const coreSchema = deleteProperties(combinedSchema, [
+  "discriminator",
+  ...extractFields.map((item) => `${item}Ref`),
+  ...extractFields.map((item) => `${item}Required`),
+]);
+
+fs.writeFileSync(
+  "../schemas/v2/core.json",
+  JSON.stringify(coreSchema, null, 2)
+);
+console.log("Core schema written to ../schemas/v2/core.json");