@pdtf/schemas 3.6.0-dev.4 → 3.6.0-dev.5

package/{keen-dewdney-6ae15b → compassionate-easley-bafb14}/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,20 +42,35 @@ const extractFields = [
   "rds",
   "oc1",
   "sr24",
+  "sef25",
 ];
 
+const metadataFields = [...extractFields, "ta6ed6Compat"];
+
 const flattenSkeleton = (schema) => {
   if (!schema) return undefined;
-  
+
   // Handle arrays - mark with special notation
   if (schema.type === "array" && schema.items) {
     const itemSchema = flattenSkeleton(schema.items);
     // Use array notation to indicate this is an array
     return [itemSchema];
   }
-  
+
+  // Handle patternProperties (dynamic keys like in offers and enquiries)
+  if (schema.type === "object" && schema.patternProperties) {
+    // Get the schema from the first pattern (usually ".*")
+    const patternKeys = Object.keys(schema.patternProperties);
+    if (patternKeys.length > 0) {
+      const patternSchema = schema.patternProperties[patternKeys[0]];
+      const itemSchema = flattenSkeleton(patternSchema);
+      // Use {*: schema} notation to indicate this is a keyed object
+      return { "*": itemSchema };
+    }
+  }
+
   // Handle primitives - return type indicator
-  if (schema.type && !schema.properties && !schema.oneOf && !schema.items) {
+  if (schema.type && !schema.properties && !schema.oneOf && !schema.items && !schema.patternProperties) {
     // Return a type indicator for primitive types
     if (schema.type === "string") return "string";
     if (schema.type === "number") return "number";
@@ -46,45 +78,60 @@ const flattenSkeleton = (schema) => {
     if (schema.type === "boolean") return "boolean";
     if (schema.type === "null") return "null";
   }
-  
+
   let returnStructure = {};
-  
+
   // Handle object properties
   if (schema.properties) {
     Object.keys(schema.properties).forEach((key) => {
       returnStructure[key] = flattenSkeleton(schema.properties[key]);
     });
   }
-  
-  // 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;
           }
         });
       }
     });
   }
-  
+
   // Return empty object for objects without properties
   return Object.keys(returnStructure).length > 0 ? returnStructure : {};
 };
 
 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`,
@@ -95,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) => {
@@ -122,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`,
@@ -172,6 +219,18 @@ const extractOverlay = (sourceSchema, ref) => {
     if (element[refEnum]) {
       jp.set(returnSchema, `${path}/enum`, element[refEnum]);
     }
+
+    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;
 };
@@ -186,28 +245,48 @@ 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}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",
@@ -226,10 +305,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 = "") => {
@@ -237,7 +316,7 @@ const toCompact = (obj, indent = "") => {
     // Skip type indicators entirely
     return "";
   }
-  
+
   if (Array.isArray(obj)) {
     if (obj.length === 0) return "[]";
     // Array with content
@@ -247,16 +326,25 @@ const toCompact = (obj, indent = "") => {
     }
     return `[\n${inner}\n${indent}]`;
   }
-  
+
   if (obj && typeof obj === "object") {
     const keys = Object.keys(obj);
     if (keys.length === 0) return "";
-    
+
+    // Check if this is a keyed object (has "*" key)
+    if (keys.length === 1 && keys[0] === "*") {
+      const inner = toCompact(obj["*"], indent);
+      if (inner === "" || inner === "{*}") {
+        return "{*}"; // Keyed object of primitives (or nested keyed objects with no structure)
+      }
+      return `{*}\n${inner}`;
+    }
+
     // Process each key
     const lines = [];
     keys.forEach(k => {
       const val = toCompact(obj[k], indent + "  ");
-      
+
       if (val === "") {
         // Leaf node - just show the property name
         lines.push(`${indent}  ${k}`);
@@ -266,16 +354,19 @@ const toCompact = (obj, indent = "") => {
       } else if (val.startsWith("[")) {
         // Array with nested content - simple concatenation
         lines.push(`${indent}  ${k}${val}`);
+      } else if (val.startsWith("{*}")) {
+        // Keyed object property - simple concatenation
+        lines.push(`${indent}  ${k}${val}`);
       } else {
         // Object property - show name on its own line, content below
         lines.push(`${indent}  ${k}`);
         lines.push(val);
       }
     });
-    
+
     return lines.length > 0 ? lines.join("\n") : "";
   }
-  
+
   return "";
 };
 
@@ -284,7 +375,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/{keen-dewdney-6ae15b → compassionate-easley-bafb14}/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdtf/schemas",
-  "version": "3.6.0-dev.4",
+  "version": "3.6.0-dev.5",
   "description": "Property Data Trust Framework Schemas and Utilities",
   "main": "index.js",
   "directories": {

package/src/schemas/v3/combined.json

@@ -25765,6 +25765,7 @@
               "rdsRef": "Insurance/isInsured=no|yes|true|false",
               "ta6Ref": "6.1",
               "ta6ed6Ref": "7.1",
+              "sef25Ref": "I1.2",
               "piqRef": "A8.2",
               "title": "Do you currently insure the property?",
               "ta6Title": "Does the seller insure the property?",

package/src/schemas/v3/overlays/extensions/ic.json

@@ -3,9 +3,30 @@
     "propertyPack": {
       "properties": {
         "insurance": {
+          "ntsRef": "I1",
+          "discriminator": {
+            "propertyName": "isInsured"
+          },
+          "properties": {
+            "isInsured": {
+              "ntsRef": "I1.2",
+              "type": "string"
+            }
+          },
           "oneOf": [
-            null,
             {
+              "properties": {
+                "isInsured": {
+                  "enum": [
+                    "No"
+                  ]
+                }
+              }
+            },
+            {
+              "required": [
+                "insuranceClaims"
+              ],
               "properties": {
                 "insuranceClaims": {
                   "ntsRef": "I1.1",
@@ -40,15 +61,17 @@
                         }
                       }
                     }
-                  ],
-                  "type": "object"
+                  ]
+                },
+                "isInsured": {
+                  "enum": [
+                    "Yes"
+                  ]
                 }
-              },
-              "required": [
-                "insuranceClaims"
-              ]
+              }
             }
-          ]
+          ],
+          "type": "object"
         }
       },
       "ntsRef": "0"

package/src/schemas/v3/overlays/sef25.json

@@ -1150,7 +1150,12 @@
                 "insuranceClaims"
               ]
             }
-          ]
+          ],
+          "properties": {
+            "isInsured": {
+              "sef25Ref": "I1.2"
+            }
+          }
         },
         "rightsAndInformalArrangements": {
           "sef25Ref": "R1",

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",
     ],
   },