@pdtf/schemas 3.6.0-dev.3 → 3.6.0-dev.32

package/src/utils/checkTa6OmissionCompatibility.js

@@ -0,0 +1,146 @@
+// Run against an unpacked published npm package, not a git approximation:
+// node src/utils/checkTa6OmissionCompatibility.js /path/to/baseline/package
+const assert = require("assert");
+const path = require("path");
+const current = require("../../index.js");
+const baseline = require(path.resolve(process.argv[2]));
+const schemaId =
+  "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json";
+const electricalPath = "/propertyPack/electricalWorks/electricalWorkSince2005";
+const drainagePath =
+  "/propertyPack/waterAndDrainage/drainage/mainsFoulDrainage/offMainsDrainageSystem";
+const jp = require("jsonpointer");
+const clone = (v) => JSON.parse(JSON.stringify(v));
+const results = {
+  baseline: require(path.resolve(process.argv[2], "package.json")).version,
+  candidate: require("../../package.json").version,
+  comparisons: 0,
+  legacy: {
+    validToValid: 0,
+    invalidToValid: 0,
+    invalidToInvalid: 0,
+    validToInvalid: [],
+  },
+  newAnswer: {
+    validToValid: 0,
+    invalidToValid: 0,
+    invalidToInvalid: 0,
+    validToInvalid: [],
+  },
+};
+for (const overlay of ["ta6ed6", "ta6ed6v2"]) {
+  const fixture = require(`../tests/fixtures/ta6/${overlay}.json`);
+  assert(
+    baseline.getValidator(schemaId, [overlay])(clone(fixture)),
+    `${overlay} whole fixture must be baseline-valid`,
+  );
+  const compare = (target, value, group) => {
+    for (const whole of [false, true]) {
+      const record = whole ? clone(fixture) : value;
+      if (whole) {
+        jp.set(record, target, value);
+        if (target === drainagePath)
+          jp.set(
+            record,
+            "/propertyPack/waterAndDrainage/drainage/mainsFoulDrainage/yesNo",
+            "No",
+          );
+      }
+      const get = (pkg) =>
+        whole
+          ? pkg.getValidator(schemaId, [overlay])
+          : pkg.getSubschemaValidator(target, schemaId, [overlay]);
+      const before = get(baseline)(clone(record));
+      const after = get(current)(clone(record));
+      results.comparisons++;
+      if (before && !after)
+        results[group].validToInvalid.push({ overlay, whole, target, value });
+      else
+        results[group][
+          before
+            ? "validToValid"
+            : after
+              ? "invalidToValid"
+              : "invalidToInvalid"
+        ]++;
+    }
+  };
+  for (const answer of [undefined, "Yes", "No", "Maybe", "", null]) {
+    for (const attachments of [
+      undefined,
+      "Attached",
+      "To follow",
+      "Not available",
+      "Invalid",
+    ]) {
+      for (const certificateType of [
+        undefined,
+        "Electrical Safety Certificate (BS7671)",
+      ]) {
+        const suppliedCertificate = {};
+        if (answer !== undefined) suppliedCertificate.yesNo = answer;
+        if (attachments !== undefined)
+          suppliedCertificate.attachments = attachments;
+        if (certificateType !== undefined)
+          suppliedCertificate.certificateType = certificateType;
+        compare(
+          electricalPath,
+          { yesNo: "Yes", details: "Electrical work", suppliedCertificate },
+          answer === undefined ? "legacy" : "newAnswer",
+        );
+      }
+    }
+  }
+  for (const type of [
+    "Septic tank",
+    "Cesspit",
+    "Sewerage treatment plant",
+    "Other",
+  ]) {
+    for (const permitDocuments of [
+      undefined,
+      "Attached",
+      "To follow",
+      "Not applicable",
+      "Invalid",
+      "",
+      null,
+    ]) {
+      compare(
+        drainagePath,
+        {
+          offMainsDrainageSystemType: type,
+          otherConnectedProperties: { yesNo: "No" },
+          plantOnOtherLand: { yesNo: "No" },
+          plantDrainsIntoWaterway: { yesNo: "Yes" },
+          dateDischargeCommenced: "2020-01-01",
+          dateInstalled: "2020-01-01",
+          dateLastEmptied: "2025-01-01",
+          dateLastServiced: "2025-01-01",
+          supplier: "Provider",
+          makeModel: "Model",
+          serviceProviderName: "Servicer",
+          ...(permitDocuments === undefined ? {} : { permitDocuments }),
+        },
+        "legacy",
+      );
+    }
+  }
+  // An unrelated question must remain byte-for-byte identical.
+  assert.deepStrictEqual(
+    current.getSubschema("/propertyPack/heating", schemaId, [overlay]),
+    baseline.getSubschema("/propertyPack/heating", schemaId, [overlay]),
+  );
+}
+assert.strictEqual(
+  results.legacy.validToInvalid.length,
+  0,
+  "Existing answer shapes regressed",
+);
+// Previously unconstrained values at the NEW property are the only expected tightening.
+assert(
+  results.newAnswer.validToInvalid.every(
+    ({ value }) => !["Yes", "No"].includes(value.suppliedCertificate.yesNo),
+  ),
+);
+console.log(JSON.stringify(results, null, 2));

package/src/utils/extractExtensionOverlays.js

@@ -274,7 +274,7 @@ const extensionMappings = {
     description: "Insurance claims upfront for SEF25",
     refType: "sef25Ref",
     paths: [
-      "/properties/propertyPack/properties/insurance/oneOf/1/properties/insuranceClaims",
+      "/properties/propertyPack/properties/insurance",
     ],
   },
 
@@ -575,7 +575,16 @@ function addIntermediateRefs(overlay, schema, refConfig) {
       const schemaPath = "/" + this.path.join("/");
       try {
         const schemaNode = jp.get(schema, schemaPath);
-        if (schemaNode && schemaNode[refConfig.ref]) {
+        if (!schemaNode) return;
+        // When the output key differs from the source key (e.g. sef25Ref -> ntsRef),
+        // prefer the schema's existing outputRef on intermediate parents so we
+        // don't clobber legitimate NTS refs when the extension is later merged.
+        if (
+          refConfig.ref !== refConfig.outputRef &&
+          schemaNode[refConfig.outputRef]
+        ) {
+          node[refConfig.outputRef] = schemaNode[refConfig.outputRef];
+        } else if (schemaNode[refConfig.ref]) {
           node[refConfig.outputRef] = schemaNode[refConfig.ref];
         }
       } catch (err) {

package/src/utils/extractOverlay.js

@@ -30,6 +30,7 @@ const extractFields = [
   "ntsl2",
   "ta6",
   "ta6ed6",
+  "ta6ed6v2",
   "ta7",
   "ta7ed5",
   "ta10",
@@ -220,6 +221,25 @@ const extractOverlay = (sourceSchema, ref) => {
       jp.set(returnSchema, `${path}/enum`, element[refEnum]);
     }
 
+    // Per-overlay display labels for enum values. The underlying enum (the
+    // stored value) is left untouched — we only emit positional `enumNames`
+    // aligned to the effective enum, so a form-facing overlay can present the
+    // form's own wording (e.g. "Ground"/"Surface water") while the data keeps
+    // its canonical value. Invisible to the core/base schema (stripped below).
+    const refEnumNames = `${ref}EnumNames`;
+    if (element[refEnumNames]) {
+      const labelMap = element[refEnumNames];
+      const effectiveEnum = element[refEnum] || element.enum;
+      if (Array.isArray(effectiveEnum)) {
+        const enumNames = effectiveEnum.map((value) =>
+          Object.prototype.hasOwnProperty.call(labelMap, value)
+            ? labelMap[value]
+            : value
+        );
+        jp.set(returnSchema, `${path}/enumNames`, enumNames);
+      }
+    }
+
     const refConst = `${ref}Const`;
     if (Object.prototype.hasOwnProperty.call(element, refConst)) {
       jp.set(returnSchema, `${path}/const`, element[refConst]);
@@ -265,6 +285,7 @@ const coreSchema = deleteProperties(combinedSchema, [
   ...metadataFields.map((item) => `${item}Title`),
   ...metadataFields.map((item) => `${item}Description`),
   ...metadataFields.map((item) => `${item}Enum`),
+  ...metadataFields.map((item) => `${item}EnumNames`),
   ...metadataFields.map((item) => `${item}Type`),
   ...metadataFields.map((item) => `${item}MinLength`),
   ...metadataFields.map((item) => `${item}MaxLength`),