@pdtf/schemas 3.6.0-9 → 3.6.0-dev.10

package/src/utils/extractOverlay.js

@@ -2,9 +2,24 @@ const { dereference } = require("@jdw/jst");
 const traverse = require("traverse");
 const jp = require("jsonpointer");
 const fs = require("fs");
+const path = require("path");
 const merge = require("deepmerge");
 
-const combinedSchema = require("../schemas/v3/combined.json");
+const combinedPath =
+  process.env.COMBINED_PATH ||
+  path.resolve(__dirname, "../schemas/v3/combined.json");
+const outputDir =
+  process.env.OUTPUT_DIR ||
+  path.resolve(__dirname, "../schemas/v3");
+
+if (!fs.existsSync(combinedPath)) {
+  throw new Error(`Combined schema not found: ${combinedPath}`);
+}
+if (!fs.existsSync(outputDir)) {
+  fs.mkdirSync(outputDir, { recursive: true });
+}
+
+const combinedSchema = JSON.parse(fs.readFileSync(combinedPath, "utf8"));
 
 const extractFields = [
   "baspi4",
@@ -14,7 +29,9 @@ const extractFields = [
   "ntsl",
   "ntsl2",
   "ta6",
+  "ta6ed6",
   "ta7",
+  "ta7ed5",
   "ta10",
   "lpe1",
   "fme1",
@@ -25,8 +42,11 @@ const extractFields = [
   "rds",
   "oc1",
   "sr24",
+  "sef25",
 ];
 
+const metadataFields = [...extractFields, "ta6ed6Compat"];
+
 const flattenSkeleton = (schema) => {
   if (!schema) return undefined;
 
@@ -68,23 +88,21 @@ const flattenSkeleton = (schema) => {
     });
   }
 
-  // Handle oneOf - merge all possible properties
+  // Handle oneOf - merge all possible properties (recursively handles nested oneOf)
   if (schema.oneOf) {
     schema.oneOf.forEach((aOneOf) => {
-      if (aOneOf.properties) {
-        Object.entries(aOneOf.properties).forEach(([key, value]) => {
-          // If property already exists and differs, mark as variant
-          const newValue = flattenSkeleton(value);
-          if (returnStructure[key] && JSON.stringify(returnStructure[key]) !== JSON.stringify(newValue)) {
-            // For primitive types, just mark as variant type
-            if (typeof returnStructure[key] === "string" || typeof newValue === "string") {
+      const variantResult = flattenSkeleton(aOneOf);
+      if (variantResult && typeof variantResult === "object" && !Array.isArray(variantResult)) {
+        Object.entries(variantResult).forEach(([key, value]) => {
+          if (key === "_variants") return;
+          if (returnStructure[key] && JSON.stringify(returnStructure[key]) !== JSON.stringify(value)) {
+            if (typeof returnStructure[key] === "string" || typeof value === "string") {
               returnStructure[key] = "variant";
             } else {
-              // For complex types, merge properties
-              returnStructure[key] = { ...returnStructure[key], ...newValue, _variants: true };
+              returnStructure[key] = { ...returnStructure[key], ...value, _variants: true };
             }
           } else {
-            returnStructure[key] = newValue;
+            returnStructure[key] = value;
           }
         });
       }
@@ -97,6 +115,23 @@ const flattenSkeleton = (schema) => {
 
 const extractOverlay = (sourceSchema, ref) => {
   const refName = `${ref}Ref`;
+  const extendedTagMap = {
+    Type: "type",
+    MinLength: "minLength",
+    MaxLength: "maxLength",
+    Pattern: "pattern",
+    Minimum: "minimum",
+    Maximum: "maximum",
+    MinItems: "minItems",
+    MaxItems: "maxItems",
+    UniqueItems: "uniqueItems",
+    AdditionalProperties: "additionalProperties",
+    Format: "format",
+    MinProperties: "minProperties",
+    MaxProperties: "maxProperties",
+    MultipleOf: "multipleOf",
+    Const: "const",
+  };
   const returnSchema = {
     $schema: "http://json-schema.org/draft-07/schema#",
     $id: `https://trust.propdata.org.uk/schemas/v3/overlays/${ref}.json`,
@@ -107,7 +142,7 @@ const extractOverlay = (sourceSchema, ref) => {
     if (element[refName]) {
       jp.set(returnSchema, `${path}/${refName}`, element[refName]);
 
-      if (element.discriminator) {
+      if (element.discriminator && Array.isArray(element.oneOf)) {
         jp.set(returnSchema, `${path}/discriminator`, element.discriminator);
         const { propertyName } = element.discriminator;
         element.oneOf.forEach((oneOf, index) => {
@@ -134,7 +169,7 @@ const extractOverlay = (sourceSchema, ref) => {
       }
 
       // also handle discriminator properties nested in items
-      if (element.items?.discriminator) {
+      if (element.items?.discriminator && Array.isArray(element.items.oneOf)) {
         jp.set(
           returnSchema,
           `${path}/items/discriminator`,
@@ -184,6 +219,37 @@ const extractOverlay = (sourceSchema, ref) => {
     if (element[refEnum]) {
       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]);
+    }
+
+    Object.entries(extendedTagMap).forEach(([suffix, schemaKey]) => {
+      const tagKey = `${ref}${suffix}`;
+      if (Object.prototype.hasOwnProperty.call(element, tagKey)) {
+        jp.set(returnSchema, `${path}/${schemaKey}`, element[tagKey]);
+      }
+    });
   });
   return returnSchema;
 };
@@ -198,28 +264,49 @@ const deleteProperties = (sourceSchema, propertyNames) => {
 };
 
 const overlays = {};
+const overlaysDir = path.join(outputDir, "overlays");
+if (!fs.existsSync(overlaysDir)) {
+  fs.mkdirSync(overlaysDir, { recursive: true });
+}
 
 extractFields.forEach((key) => {
   let overlay = extractOverlay(combinedSchema, key);
   overlays[key] = overlay;
-  const fileName = `../schemas/v3/overlays/${key}.json`;
+  const fileName = path.join(overlaysDir, `${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`),
-  ...extractFields.map((item) => `${item}Title`),
-  ...extractFields.map((item) => `${item}Enum`),
+  ...metadataFields.map((item) => `${item}Ref`),
+  ...metadataFields.map((item) => `${item}Required`),
+  ...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`),
+  ...metadataFields.map((item) => `${item}Pattern`),
+  ...metadataFields.map((item) => `${item}Minimum`),
+  ...metadataFields.map((item) => `${item}Maximum`),
+  ...metadataFields.map((item) => `${item}MinItems`),
+  ...metadataFields.map((item) => `${item}MaxItems`),
+  ...metadataFields.map((item) => `${item}UniqueItems`),
+  ...metadataFields.map((item) => `${item}AdditionalProperties`),
+  ...metadataFields.map((item) => `${item}Format`),
+  ...metadataFields.map((item) => `${item}MinProperties`),
+  ...metadataFields.map((item) => `${item}MaxProperties`),
+  ...metadataFields.map((item) => `${item}MultipleOf`),
+  ...metadataFields.map((item) => `${item}Const`),
 ]);
 
 fs.writeFileSync(
-  "../schemas/v3/pdtf-transaction.json",
+  path.join(outputDir, "pdtf-transaction.json"),
   JSON.stringify(coreSchema, null, 2)
 );
-console.log("Core schema written to ../schemas/v3/pdtf-transaction.json");
+console.log(`Core schema written to ${path.join(outputDir, "pdtf-transaction.json")}`);
 
 const skeletonSchema = deleteProperties(coreSchema, [
   "$schema",
@@ -238,10 +325,10 @@ const skeletonSchema = deleteProperties(coreSchema, [
 const skeletonSchemaFlattened = flattenSkeleton(skeletonSchema);
 
 fs.writeFileSync(
-  "../schemas/v3/skeleton.json",
+  path.join(outputDir, "skeleton.json"),
   JSON.stringify(skeletonSchemaFlattened, null, 2)
 );
-console.log("Flat Skeleton schema written to ../schemas/v3/skeleton.json");
+console.log(`Flat Skeleton schema written to ${path.join(outputDir, "skeleton.json")}`);
 
 // Generate compact skeleton format for better token efficiency
 const toCompact = (obj, indent = "") => {
@@ -267,8 +354,8 @@ const toCompact = (obj, indent = "") => {
     // Check if this is a keyed object (has "*" key)
     if (keys.length === 1 && keys[0] === "*") {
       const inner = toCompact(obj["*"], indent);
-      if (inner === "") {
-        return "{*}"; // Keyed object of primitives
+      if (inner === "" || inner === "{*}") {
+        return "{*}"; // Keyed object of primitives (or nested keyed objects with no structure)
       }
       return `{*}\n${inner}`;
     }
@@ -308,7 +395,7 @@ const innerContent = toCompact(skeletonSchemaFlattened, "");
 const compactSkeleton = innerContent ? innerContent : "";
 
 fs.writeFileSync(
-  "../schemas/v3/compactSkeleton.txt",
+  path.join(outputDir, "compactSkeleton.txt"),
   compactSkeleton
 );
-console.log("Compact Skeleton written to ../schemas/v3/compactSkeleton.txt");
+console.log(`Compact Skeleton written to ${path.join(outputDir, "compactSkeleton.txt")}`);

package/src/utils/pathSkeleton.js

@@ -6,7 +6,7 @@ const combinedSchema = require("../schemas/v3/combined.json");
 // Extract fields that have overlay-specific properties
 const extractFields = [
   "baspi4", "baspi5", "nts", "nts2", "ntsl", "ntsl2",
-  "ta6", "ta7", "ta10", "lpe1", "fme1", "piq",
+  "ta6", "ta7", "ta7ed5", "ta10", "lpe1", "fme1", "piq",
   "con29R", "con29DW", "llc1", "rds", "oc1", "sr24",
 ];
 

package/.claude/settings.local.json

@@ -1,42 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(rg:*)",
-      "Bash(mkdir:*)",
-      "Bash(node:*)",
-      "Bash(ls:*)",
-      "Bash(jq:*)",
-      "Bash(grep:*)",
-      "Bash(rm:*)",
-      "Bash(npm test:*)",
-      "Bash(npm install:*)",
-      "Bash(git merge:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(git push:*)",
-      "Bash(git fetch:*)",
-      "Bash(git checkout:*)",
-      "Bash(gh pr view:*)",
-      "WebFetch(domain:github.com)",
-      "Bash(tree:*)",
-      "Bash(sed:*)",
-      "Bash(find:*)",
-      "Bash(chmod:*)",
-      "Bash(git rev-parse:*)",
-      "Bash(/dev/null)",
-      "Bash(git log:*)",
-      "Bash(for file in src/schemas/v2/overlays/*.json)",
-      "Bash(done)",
-      "Bash(while read file)",
-      "Bash(for:*)",
-      "Bash(do echo \"=== $file ===\")",
-      "Bash(do echo \"$file:\")",
-      "Bash(npm run proposal:pdf:*)",
-      "Bash(base64:*)",
-      "Bash(gh issue view:*)",
-      "Read(//Users/ed/.claude/**)",
-      "Bash(npm init:*)"
-    ],
-    "deny": []
-  }
-}

package/.github/workflows/pages.yml

@@ -1,50 +0,0 @@
-# Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll with GitHub Pages dependencies preinstalled
-
-on:
-  # Runs on pushes targeting the default branch
-  push:
-    branches: ["master"]
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# Allow one concurrent deployment
-concurrency:
-  group: "pages"
-  cancel-in-progress: true
-
-jobs:
-  # Build job
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Setup Pages
-        uses: actions/configure-pages@v2
-      - name: Build with Jekyll
-        uses: actions/jekyll-build-pages@v1
-        with:
-          source: src
-          destination: ./_site
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v1
-
-  # Deployment job
-  deploy:
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v1

package/CNAME

@@ -1 +0,0 @@
-trust.propdata.org.uk

package/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-minimal

package/src/examples/v1/exampleAddParticipantVouch.json

@@ -1,32 +0,0 @@
-{
-  "verification": {
-    "trust_framework": "uk_pdtf",
-    "time": "2022-01-25T13:05:03.108Z",
-    "evidence": [
-      {
-        "type": "vouch",
-        "attestation": {
-          "type": "digital_attestation",
-          "voucher": {
-            "name": "Martin Abode"
-          }
-        },
-        "verification_method": {
-          "type": "auth"
-        }
-      }
-    ]
-  },
-  "claims": {
-    "/participants/-": {
-      "name": {
-        "firstName": "Martin",
-        "lastName": "Abode"
-      },
-      "email": "martin@abode.co.uk",
-      "organisation": "Abode and Floggit Estate Agents",
-      "organisationReference": "MAR/12243/22",
-      "role": "Estate Agent"
-    }
-  }
-}

package/src/examples/v1/exampleDocumentedVouch.json

@@ -1,40 +0,0 @@
-{
-  "verification": {
-    "trust_framework": "uk_pdtf",
-    "time": "2022-01-25T13:16:44.527Z",
-    "evidence": [
-      {
-        "type": "vouch",
-        "attachments": [
-          {
-            "digest": {
-              "alg": "md5",
-              "value": "randomHashValue"
-            },
-            "url": "https://fakeFileStore.com/some/kind/of/file",
-            "desc": "proofOfAddress.pdf",
-            "pdtfSchemaPath": "/propertyPack/materialFacts/councilTax/councilTaxAffectingAlterations/details"
-          }
-        ],
-        "verification_method": {
-          "type": "auth"
-        },
-        "attestation": {
-          "voucher": {
-            "name": "Maria Harris"
-          },
-          "type": "digital_attestation"
-        }
-      }
-    ]
-  },
-  "claims": {
-    "/propertyPack/materialFacts/councilTax": {
-      "councilTaxBand": "D",
-      "councilTaxAffectingAlterations": {
-        "yesNo": "Yes",
-        "details": "Extension added in 2005 to add bedroom with ensuite shower room. Certificate of Compliance issued 17th Feb 2006 and council tax updated"
-      }
-    }
-  }
-}

package/src/examples/v1/exampleElectronicRecord.json

@@ -1,30 +0,0 @@
-{
-  "verification": {
-    "time": "2022-01-25T07:52:14.318Z",
-    "trust_framework": "uk_pdtf",
-    "evidence": [
-      {
-        "type": "electronic_record",
-        "verifier": {
-          "organization": "Property Pack Assembly Software Ltd"
-        },
-        "record": {
-          "source": {
-            "name": "Royal Mail Postcode Address File",
-            "rights": "(c) Royal Mail"
-          },
-          "type": "postcode_address_file"
-        }
-      }
-    ]
-  },
-  "claims": {
-    "/propertyPack/materialFacts/address": {
-      "line1": "3 The Hollys",
-      "line2": "Birtley",
-      "town": "CHESTER LE STREET",
-      "county": "County Durham",
-      "postcode": "DH3 1QN"
-    }
-  }
-}