@pdtf/schemas 3.4.1-1 → 3.4.1-3

package/index.js

@@ -22,23 +22,23 @@ const extensionOverlays = {
   jk: require("./src/schemas/v3/overlays/extensions/jk.json"),
   sb: require("./src/schemas/v3/overlays/extensions/sb.json"),
   hs: require("./src/schemas/v3/overlays/extensions/hs.json"),
-  
+
   // Property Features Extensions
   oa: require("./src/schemas/v3/overlays/extensions/oa.json"),
   la: require("./src/schemas/v3/overlays/extensions/la.json"),
   sf: require("./src/schemas/v3/overlays/extensions/sf.json"),
   mc: require("./src/schemas/v3/overlays/extensions/mc.json"),
-  
+
   // Ownership & Financial Extensions
   er: require("./src/schemas/v3/overlays/extensions/er.json"),
   ma: require("./src/schemas/v3/overlays/extensions/ma.json"),
   tf: require("./src/schemas/v3/overlays/extensions/tf.json"),
-  
+
   // Utilities & Services Extensions
   sl: require("./src/schemas/v3/overlays/extensions/sl.json"),
   hi: require("./src/schemas/v3/overlays/extensions/hi.json"),
   fd: require("./src/schemas/v3/overlays/extensions/fd.json"),
-  
+
   // Transaction Extensions
   oc: require("./src/schemas/v3/overlays/extensions/oc.json"),
 };
@@ -92,98 +92,92 @@ const transactionSchemas = {
     v3CoreSchema,
 };
 
-const combineMerge = (target, source, options) => {
-  // Special handling for 'required' arrays - combine them uniquely
-  if (target.some((item) => typeof item === "string")) {
-    return [...new Set([...target, ...source])];
-  }
-
-  // For other arrays, concatenate while preserving uniqueness for primitive values
-  if (!options.isMergeableObject(target[0])) {
-    return [...new Set([...target, ...source])];
-  }
-
-  // Special handling for oneOf arrays - merge matching schemas based on discriminator
-  if (target[0]?.properties && source[0]?.properties) {
-    // Find a common discriminator property (a property with an enum)
-    const findDiscriminator = (schema) => {
-      const props = schema.properties;
-      return Object.keys(props).find((key) => Array.isArray(props[key]?.enum));
-    };
+// Custom array merge function for oneOf arrays
+const arrayMerge = (target, source) => {
+  // For string arrays (enum, required, etc.)
+  if (
+    target.length > 0 &&
+    source.length > 0 &&
+    target[0] &&
+    typeof target[0] === "string" &&
+    source[0] &&
+    typeof source[0] === "string"
+  ) {
+    // For required arrays, combine them (remove duplicates)
+    // Check if this looks like a required array (contains field names, not enum values)
+    const isRequiredArray = target.some(
+      (item) =>
+        typeof item === "string" &&
+        item.length > 0 &&
+        !item.includes("Yes") &&
+        !item.includes("No") &&
+        !item.includes("Not known") &&
+        !item.includes("To be connected")
+    );
 
-    const discriminator = findDiscriminator(target[0]);
-    if (discriminator) {
-      return target.map((targetSchema) => {
-        const targetEnum = targetSchema.properties?.[discriminator]?.enum || [];
-        const matchingSourceSchema = source.find((sourceSchema) => {
-          const sourceEnum =
-            sourceSchema.properties?.[discriminator]?.enum || [];
-          // Check if there's any overlap between the enum values
-          return sourceEnum.some((value) => targetEnum.includes(value));
-        });
-        if (matchingSourceSchema) {
-          return merge(targetSchema, matchingSourceSchema, options);
+    if (isRequiredArray) {
+      // Combine required arrays
+      const combined = [...target];
+      source.forEach((item) => {
+        if (!combined.includes(item)) {
+          combined.push(item);
         }
-        return targetSchema;
       });
+      return combined;
     }
+
+    // For other string arrays (like enum), use source if it exists, otherwise use target
+    return source.length > 0 ? source : target;
   }
 
-  // For arrays of objects, merge by index and append remaining items
-  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);
+  // If target is empty but source has values, use source
+  if (target.length === 0 && source.length > 0) {
+    return source;
+  }
+
+  // Ensure we only process arrays of the same length
+  // If source is shorter, pad with nulls
+  // If source is longer, truncate to target length
+  const paddedSource = [...source];
+  while (paddedSource.length < target.length) {
+    paddedSource.push(null);
+  }
+  paddedSource.splice(target.length);
+
+  return target.map((item, index) => {
+    if (paddedSource[index] === null || paddedSource[index] === undefined) {
+      return item;
+    }
+    if (item === null || item === undefined) {
+      return paddedSource[index];
     }
+    // Recursively merge nested objects and arrays
+    return merge(item, paddedSource[index], { arrayMerge });
   });
-  return destination;
 };
 
-const mergeEnums = (target, source) => source;
-
 const getTransactionSchema = (
   schemaId = "https://trust.propdata.org.uk/schemas/v3/pdtf-transaction.json",
-  overlays // = ["baspiV4"]
+  overlays
 ) => {
   const sourceSchema = transactionSchemas[schemaId];
   if (!overlays || overlays.length < 1) return sourceSchema;
-  let mergedSchema = sourceSchema;
-  overlays.forEach((overlay) => {
-    // Handle both string keys and direct overlay objects
-    const overlaySchema =
-      typeof overlay === "string"
-        ? overlaysMap[schemaId][overlay] || {}
-        : overlay;
 
-    mergedSchema = merge(mergedSchema, overlaySchema, {
-      customMerge: (key) => {
-        if (key === "enum") {
-          return mergeEnums;
-        }
-      },
-      arrayMerge: combineMerge,
-    });
+  let mergedSchema = JSON.parse(JSON.stringify(sourceSchema)); // Deep copy
+  overlays.forEach((overlay) => {
+    const overlaySchema = JSON.parse(
+      JSON.stringify(overlaysMap[schemaId][overlay] || {})
+    ); // Deep copy
+    mergedSchema = merge(mergedSchema, overlaySchema, { arrayMerge });
   });
+
   return mergedSchema;
 };
 
 // Add helper function to generate cache key
 const generateOverlayKey = (overlays) => {
   if (!overlays) return "";
-  return overlays
-    .map((overlay) => {
-      if (typeof overlay === "string") return overlay;
-      // Generate a simple hash of the object for caching
-      return JSON.stringify(overlay)
-        .split("")
-        .reduce((hash, char) => {
-          return ((hash << 5) - hash + char.charCodeAt(0)) | 0;
-        }, 0)
-        .toString(36);
-    })
-    .join(".");
+  return overlays.join(".");
 };
 
 const getValidator = (schemaId, overlays) => {

package/package.json

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

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -34,6 +43,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -31,7 +40,11 @@
                     },
                     "attachments": {
                       "ntsRef": "A5.1.3",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     },
                     "yesNo": {
                       "enum": [

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

@@ -24,6 +24,15 @@
                           }
                         },
                         "oneOf": [
+                          {
+                            "properties": {
+                              "yesNo": {
+                                "enum": [
+                                  "No"
+                                ]
+                              }
+                            }
+                          },
                           {
                             "required": [
                               "details",

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

@@ -21,6 +21,15 @@
                     }
                   },
                   "oneOf": [
+                    {
+                      "properties": {
+                        "hasFloodDefences": {
+                          "enum": [
+                            "No"
+                          ]
+                        }
+                      }
+                    },
                     {
                       "required": [
                         "details"

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

@@ -13,6 +13,10 @@
                       "properties": {
                         "centralHeatingInstalled": {
                           "ntsRef": "B3.4.3.2",
+                          "oneOf": [
+                            {},
+                            {}
+                          ],
                           "type": "string"
                         }
                       },

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -33,6 +42,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

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

@@ -19,6 +19,16 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No",
+                        "Not known"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "managementPlanInPlace"
@@ -26,12 +36,23 @@
                   "properties": {
                     "managementPlanInPlace": {
                       "ntsRef": "A5.3.2",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No",
+                        "Not known"
+                      ]
                     },
                     "yesNo": {
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "loftAccess": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details",
@@ -33,11 +42,19 @@
                     },
                     "loftBoarded": {
                       "ntsRef": "A1.2.4.3",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No"
+                      ]
                     },
                     "loftInsulated": {
                       "ntsRef": "A1.2.4.4",
-                      "type": "string"
+                      "type": "string",
+                      "enum": [
+                        "Yes",
+                        "No"
+                      ]
                     },
                     "loftAccess": {
                       "enum": [

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

@@ -19,6 +19,26 @@
                   "type": "string"
                 }
               },
+              "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "Yes"
+                      ]
+                    }
+                  }
+                }
+              ],
               "type": "object"
             }
           },

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "yesNo": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -33,6 +42,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

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

@@ -19,6 +19,15 @@
                 }
               },
               "oneOf": [
+                {
+                  "properties": {
+                    "hasSprayFoamInstalled": {
+                      "enum": [
+                        "No"
+                      ]
+                    }
+                  }
+                },
                 {
                   "required": [
                     "details"
@@ -34,6 +43,12 @@
                       "enum": [
                         "Yes"
                       ]
+                    },
+                    "attachments": {
+                      "enum": [
+                        "Attached",
+                        "To follow"
+                      ]
                     }
                   }
                 }

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

@@ -23,6 +23,26 @@
                           "type": "string"
                         }
                       },
+                      "oneOf": [
+                        {
+                          "properties": {
+                            "yesNo": {
+                              "enum": [
+                                "Yes"
+                              ]
+                            }
+                          }
+                        },
+                        {
+                          "properties": {
+                            "yesNo": {
+                              "enum": [
+                                "No"
+                              ]
+                            }
+                          }
+                        }
+                      ],
                       "type": "object"
                     }
                   }

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

@@ -34,6 +34,15 @@
                                       }
                                     },
                                     "oneOf": [
+                                      {
+                                        "properties": {
+                                          "yesNo": {
+                                            "enum": [
+                                              "No"
+                                            ]
+                                          }
+                                        }
+                                      },
                                       {
                                         "required": [
                                           "details"

package/src/schemas/v3/property-transaction-milestones.json

@@ -0,0 +1,91 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Transaction Milestones",
+  "description": "Schema for tracking transaction milestones throughout the conveyancing process",
+  "type": "object",
+  "properties": {
+    "listed": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "legalForms": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "soldSubjectToContract": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "searches": {
+      "type": "object",
+      "properties": {
+        "ordered": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "enquiries": {
+      "type": "object",
+      "properties": {
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "exchangeOfContracts": {
+      "type": "object",
+      "properties": {
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "completion": {
+      "type": "object",
+      "properties": {
+        "started": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "expected": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "completed": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    }
+  }
+}