@pdtf/schemas 3.4.1-1 → 3.4.1-3

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

@@ -8,7 +8,6 @@ const {
   getValidator,
   getSubschemaValidator,
   getTitleAtPath,
-  overlaysMap,
 } = require("../../../index.js");
 
 const exampleTransaction = require("../../examples/v3/exampleTransaction.json");
@@ -33,14 +32,12 @@ test("sample is valid BASPI", () => {
   expect(testSchema.properties.propertyPack.baspi4Ref).toEqual("0");
   const validator = getValidator(schemaId, ["baspiV4"]);
   const isValid = validator(exampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
 test("sample is valid NTS", () => {
   const validator = getValidator(schemaId, ["nts2023"]);
   const isValid = validator(exampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
@@ -102,7 +99,6 @@ test("sample is valid NTSL if we change it accordingly", () => {
   delete clonedExampleTransaction.propertyPack.priceInformation;
   delete clonedExampleTransaction.propertyPack.ownership;
   const isValid = validator(clonedExampleTransaction);
-  if (!isValid) console.log(validator.errors);
   expect(isValid).toBe(true);
 });
 
@@ -452,227 +448,3 @@ test("validates a valid contract", () => {
   const isValid = validator(data);
   expect(isValid).toBe(true);
 });
-
-test("overlay as key and as object produce identical results", () => {
-  // Get the NTS overlay object directly from the overlays map
-  const ntsOverlayObject = { ...overlaysMap[schemaId]["nts2023"] };
-  // Remove the $id to prevent schema registration conflicts
-  ntsOverlayObject.$id =
-    "https://trust.propdata.org.uk/schemas/v3/overlays/nts2024.json";
-
-  // Get schema using the key
-  const schemaWithKey = getTransactionSchema(schemaId, ["nts2023"]);
-
-  // Get schema using the object
-  const schemaWithObject = getTransactionSchema(schemaId, [ntsOverlayObject]);
-
-  // Create copies without $id for comparison
-  const schemaWithKeyNoId = { ...schemaWithKey };
-  const schemaWithObjectNoId = { ...schemaWithObject };
-  delete schemaWithKeyNoId.$id;
-  delete schemaWithObjectNoId.$id;
-
-  // Deep compare the results (excluding $id)
-  expect(schemaWithObjectNoId).toEqual(schemaWithKeyNoId);
-
-  // Test that validation produces the same errors
-  const validatorWithKey = getValidator(schemaId, ["nts2023"]);
-  const validatorWithObject = getValidator(schemaId, [ntsOverlayObject]);
-
-  validatorWithKey(exampleTransaction);
-  validatorWithObject(exampleTransaction);
-
-  // Compare validation errors
-  expect(validatorWithObject.errors).toEqual(validatorWithKey.errors);
-});
-
-test("correctly merges custom Japanese Knotweed overlay with base schema", () => {
-  // Load the custom overlay
-  const customOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-
-  // Get base schema and schema with overlay
-  const baseSchema = getTransactionSchema(schemaId);
-  const schemaWithOverlay = getTransactionSchema(schemaId, [customOverlay]);
-
-  // Verify that other properties in propertyPack are preserved
-  expect(
-    Object.keys(schemaWithOverlay.properties.propertyPack.properties)
-  ).toEqual(Object.keys(baseSchema.properties.propertyPack.properties));
-
-  // Verify that other properties in specialistIssues are preserved
-  const baseSpecialistIssues =
-    baseSchema.properties.propertyPack.properties.specialistIssues;
-  const overlaidSpecialistIssues =
-    schemaWithOverlay.properties.propertyPack.properties.specialistIssues;
-  expect(Object.keys(overlaidSpecialistIssues.properties)).toEqual(
-    Object.keys(baseSpecialistIssues.properties)
-  );
-
-  // Verify that Japanese Knotweed section is updated
-  const japaneseKnotweed = overlaidSpecialistIssues.properties.japaneseKnotweed;
-  expect(japaneseKnotweed.title).toBe(
-    "Is the property affected by Japanese knotweed?"
-  );
-  expect(japaneseKnotweed.required).toEqual(["yesNo"]);
-
-  // Verify the oneOf conditions are updated
-  expect(japaneseKnotweed.oneOf).toHaveLength(2);
-  expect(japaneseKnotweed.oneOf[0].properties.yesNo.enum).toEqual([
-    "No",
-    "Not known",
-  ]);
-  expect(japaneseKnotweed.oneOf[1].properties.yesNo.enum).toEqual(["Yes"]);
-  expect(japaneseKnotweed.oneOf[1].required).toEqual([
-    "managementPlanInPlace",
-    "attachments",
-  ]);
-});
-
-test("correctly merges multiple overlays using both key and object references", () => {
-  // Load the custom overlay
-  const customOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-
-  // Get schema with both overlays
-  const schemaWithOverlays = getTransactionSchema(schemaId, [
-    "nts2023",
-    customOverlay,
-  ]);
-
-  // Get individual overlay schemas for comparison
-  const ntsSchema = getTransactionSchema(schemaId, ["nts2023"]);
-  const customSchema = getTransactionSchema(schemaId, [customOverlay]);
-
-  // Verify propertyPack structure is preserved
-  const propertyPack = schemaWithOverlays.properties.propertyPack;
-  expect(Object.keys(propertyPack.properties)).toEqual(
-    expect.arrayContaining(
-      Object.keys(ntsSchema.properties.propertyPack.properties)
-    )
-  );
-
-  // Verify Japanese Knotweed changes from custom overlay are present
-  const japaneseKnotweed =
-    propertyPack.properties.specialistIssues.properties.japaneseKnotweed;
-  expect(japaneseKnotweed.title).toBe(
-    "Is the property affected by Japanese knotweed?"
-  );
-  expect(japaneseKnotweed.oneOf[1].required).toEqual([
-    "managementPlanInPlace",
-    "attachments",
-  ]);
-
-  // Verify customRef properties are correctly merged
-  expect(propertyPack.customRef).toBe("JKW");
-  expect(propertyPack.properties.specialistIssues.customRef).toBe("JKW.7");
-  expect(japaneseKnotweed.customRef).toBe("JKW.7.8");
-  expect(
-    japaneseKnotweed.oneOf[1].properties.managementPlanInPlace.customRef
-  ).toBe("JKW.7.8.2");
-  expect(japaneseKnotweed.oneOf[1].properties.attachments.customRef).toBe(
-    "JKW.7.8.3"
-  );
-  expect(japaneseKnotweed.properties.yesNo.customRef).toBe("JKW.7.8.1");
-
-  // Verify NTS specific changes are present (e.g., simplified enums)
-  const mainsElectricity =
-    propertyPack.properties.electricity.properties.mainsElectricity;
-  expect(mainsElectricity.properties.yesNo.enum).toEqual(["Yes", "No"]);
-
-  // Verify required fields from both overlays are merged
-  expect(propertyPack.required).toEqual(
-    expect.arrayContaining([
-      ...ntsSchema.properties.propertyPack.required,
-      ...customSchema.properties.propertyPack.required,
-    ])
-  );
-});
-
-test("correctly merges NTS and both custom overlays with proper required fields", () => {
-  // Load both custom overlays
-  const japaneseKnoweedOverlay = require("../../examples/v3/exampleCustomOverlay.json");
-  const managingAgentOverlay = require("../../examples/v3/exampleCustomOverlay2.json");
-
-  // Get schema with all overlays
-  const schemaWithOverlays = getTransactionSchema(schemaId, [
-    "nts2023",
-    japaneseKnoweedOverlay,
-    managingAgentOverlay,
-  ]);
-
-  // Navigate to the leasehold section in the oneOf array
-  const leaseholdSchema =
-    schemaWithOverlays.properties.propertyPack.properties.ownership.properties.ownershipsToBeTransferred.items.oneOf.find(
-      (schema) => schema.properties.ownershipType.enum[0] === "Leasehold"
-    );
-
-  // Verify the leasehold information structure
-  const leaseholdInfo = leaseholdSchema.properties.leaseholdInformation;
-
-  // Check required fields - should include both NTS and custom overlay requirements
-  expect(leaseholdInfo.required).toContain("contactDetails");
-  expect(leaseholdInfo.required).toContain("leaseTerm"); // from NTS
-  expect(leaseholdInfo.required).toContain("groundRent"); // from NTS
-
-  // Verify managing agent contact structure and refs
-  const managingAgent =
-    leaseholdInfo.properties.contactDetails.properties.contacts.properties
-      .managingAgent;
-  expect(managingAgent.macRef).toBe("MAC.4.1c");
-
-  // Verify contact details structure
-  const contact = managingAgent.properties.contact;
-  expect(contact.properties.nameOrOrganisation.macRef).toBe("MAC.4.1c.1");
-  expect(contact.properties.address.macRef).toBe("MAC.4.1c.0");
-  expect(contact.properties.telephone.macRef).toBe("MAC.4.1c.7");
-  expect(contact.properties.emailAddress.macRef).toBe("MAC.4.1c.8");
-
-  // Verify Japanese Knotweed section is still present and correct
-  const japaneseKnotweed =
-    schemaWithOverlays.properties.propertyPack.properties.specialistIssues
-      .properties.japaneseKnotweed;
-  expect(japaneseKnotweed.customRef).toBe("JKW.7.8");
-
-  // Verify NTS changes are still present
-  const mainsElectricity =
-    schemaWithOverlays.properties.propertyPack.properties.electricity.properties
-      .mainsElectricity;
-  expect(mainsElectricity.properties.yesNo.enum).toEqual(["Yes", "No"]);
-});
-
-test("ta7 overlay as key and as object produce identical results at leasehold info level", () => {
-  // Get the TA7 overlay object directly from the overlays map
-  const ta7OverlayObject = { ...overlaysMap[schemaId]["ta7ed3"] };
-  // Remove the $id to prevent schema registration conflicts
-  ta7OverlayObject.$id =
-    "https://trust.propdata.org.uk/schemas/v3/overlays/ta7ed3-copy.json";
-
-  // Get schemas using both methods
-  const schemaWithKey = getTransactionSchema(schemaId, ["ta7ed3"]);
-  const schemaWithObject = getTransactionSchema(schemaId, [ta7OverlayObject]);
-
-  // Navigate to the leasehold information section in both schemas
-  const getLeaseholdInfo = (schema) => {
-    const ownershipsToBeTransferred =
-      schema.properties.propertyPack.properties.ownership.properties
-        .ownershipsToBeTransferred;
-    const leaseholdSchema = ownershipsToBeTransferred.items.oneOf.find(
-      (schema) => schema.properties.ownershipType.enum[0] === "Leasehold"
-    );
-    return leaseholdSchema.properties.leaseholdInformation;
-  };
-
-  const leaseholdInfoWithKey = getLeaseholdInfo(schemaWithKey);
-  const leaseholdInfoWithObject = getLeaseholdInfo(schemaWithObject);
-
-  // Deep compare the leasehold information sections
-  expect(leaseholdInfoWithObject).toEqual(leaseholdInfoWithKey);
-
-  // Verify specific TA7 requirements are present in both
-  expect(leaseholdInfoWithKey.required).toContain("contactDetails");
-  expect(leaseholdInfoWithObject.required).toContain("contactDetails");
-
-  // Verify TA7 refs are present and identical
-  const contactDetails = leaseholdInfoWithKey.properties.contactDetails;
-  expect(contactDetails.ta7Ref).toBe("4.1");
-  expect(leaseholdInfoWithObject.properties.contactDetails.ta7Ref).toBe("4.1");
-});

package/src/utils/extractExtensionOverlays.js

@@ -11,120 +11,152 @@ const extensionMappings = {
   oa: {
     name: "outsideAreas",
     description: "Outside areas extension for NTS",
-    paths: ["/properties/propertyPack/properties/residentialPropertyFeatures/properties/outsideAreas"]
+    paths: [
+      "/properties/propertyPack/properties/residentialPropertyFeatures/properties/outsideAreas",
+    ],
   },
-  
+
   // Estate rentcharges for freehold
   er: {
     name: "estateRentcharges",
     description: "Estate rentcharges for freehold properties",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/0/properties/estateRentcharges"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/0/properties/estateRentcharges",
+    ],
   },
-  
+
   // Managing agent contact details for leasehold
   ma: {
     name: "managingAgent",
     description: "Managing agent contact details for leasehold",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/contactDetails"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/contactDetails",
+    ],
   },
-  
+
   // Transfer fees for leasehold
   tf: {
     name: "transferFees",
     description: "Transfer fees for leasehold",
-    paths: ["/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/serviceCharge/oneOf/1/properties/transferFees"]
+    paths: [
+      "/properties/propertyPack/properties/ownership/properties/ownershipsToBeTransferred/items/oneOf/2/properties/leaseholdInformation/properties/serviceCharge/oneOf/1/properties/transferFees",
+    ],
   },
-  
+
   // Main construction type if standard
   mc: {
     name: "mainConstruction",
     description: "Main construction type if standard form",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/isStandardForm/oneOf/0/properties/constructionType"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/isStandardForm/oneOf/0/properties/constructionType",
+    ],
   },
-  
+
   // Loft access and details
   la: {
     name: "loftAccess",
     description: "Loft access and details",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/loft"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/loft",
+    ],
   },
-  
+
   // Spray foam insulation
   sf: {
     name: "sprayFoam",
     description: "Spray foam insulation",
-    paths: ["/properties/propertyPack/properties/typeOfConstruction/properties/sprayFoamInsulation"]
+    paths: [
+      "/properties/propertyPack/properties/typeOfConstruction/properties/sprayFoamInsulation",
+    ],
   },
-  
+
   // Specialist issues - dry rot
   dr: {
     name: "dryRot",
     description: "Dry rot treatment specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/dryRotEtcTreatment"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/dryRotEtcTreatment",
+    ],
   },
-  
+
   // Specialist issues - asbestos
   as: {
     name: "asbestos",
     description: "Asbestos specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/containsAsbestos"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/containsAsbestos",
+    ],
   },
-  
+
   // Specialist issues - Japanese knotweed
   jk: {
     name: "japaneseKnotweed",
     description: "Japanese knotweed specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/japaneseKnotweed"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/japaneseKnotweed",
+    ],
   },
-  
+
   // Specialist issues - subsidence
   sb: {
     name: "subsidence",
     description: "Subsidence or structural fault specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/subsidenceOrStructuralFault"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/subsidenceOrStructuralFault",
+    ],
   },
-  
+
   // Specialist issues - health and safety
   hs: {
     name: "healthSafety",
     description: "Health and safety specialist issue",
-    paths: ["/properties/propertyPack/properties/specialistIssues/properties/ongoingHealthOrSafetyIssue"]
+    paths: [
+      "/properties/propertyPack/properties/specialistIssues/properties/ongoingHealthOrSafetyIssue",
+    ],
   },
-  
+
   // Solar panels leased
   sl: {
     name: "solarPanelsLeased",
     description: "Solar panels ownership details",
-    paths: ["/properties/propertyPack/properties/electricity/properties/solarPanels/oneOf/1/properties/panelsOwnedOutright"]
+    paths: [
+      "/properties/propertyPack/properties/electricity/properties/solarPanels/oneOf/1/properties/panelsOwnedOutright",
+    ],
   },
-  
+
   // Heating installation date
   hi: {
     name: "heatingInstalled",
     description: "Central heating installation date",
-    paths: ["/properties/propertyPack/properties/heating/properties/heatingSystem/oneOf/1/properties/centralHeatingDetails/properties/centralHeatingInstalled"]
+    paths: [
+      "/properties/propertyPack/properties/heating/properties/heatingSystem/oneOf/1/properties/centralHeatingDetails/properties/centralHeatingInstalled",
+    ],
   },
-  
+
   // Flood defences
   fd: {
     name: "floodDefences",
     description: "Flood defence information",
-    paths: ["/properties/propertyPack/properties/environmentalIssues/properties/flooding/properties/floodDefences"]
+    paths: [
+      "/properties/propertyPack/properties/environmentalIssues/properties/flooding/properties/floodDefences",
+    ],
   },
-  
+
   // Other property in chain
   oc: {
     name: "otherPropertyChain",
     description: "Other property in chain dependency",
-    paths: ["/properties/propertyPack/properties/completionAndMoving/properties/otherPropertyInChain"]
-  }
+    paths: [
+      "/properties/propertyPack/properties/completionAndMoving/properties/otherPropertyInChain",
+    ],
+  },
 };
 
 // Function to extract properties at specific paths with nts2Ref
 function extractPathsWithNts2Ref(schema, paths) {
   const result = {};
-  
-  paths.forEach(path => {
+
+  paths.forEach((path) => {
     try {
       const value = jp.get(schema, path);
       if (value && hasNts2Ref(value)) {
@@ -135,14 +167,14 @@ function extractPathsWithNts2Ref(schema, paths) {
       console.warn(`Path not found: ${path}`);
     }
   });
-  
+
   return result;
 }
 
 // Check if an object or its descendants have nts2Ref
 function hasNts2Ref(obj) {
   let found = false;
-  traverse(obj).forEach(function(element) {
+  traverse(obj).forEach(function (element) {
     if (element && element.nts2Ref) {
       found = true;
       this.stop();
@@ -152,28 +184,28 @@ function hasNts2Ref(obj) {
 }
 
 // Extract only NTS2-specific properties (with nts2Ref)
-function extractNts2Properties(obj) {
+function extractNts2Properties(obj, parentKey) {
   const result = {};
-  
+
   // Copy nts2-specific metadata at current level
   if (obj.nts2Ref) result.ntsRef = obj.nts2Ref;
   if (obj.nts2Required) result.required = obj.nts2Required;
   if (obj.nts2Title) result.title = obj.nts2Title;
   if (obj.nts2Description) result.description = obj.nts2Description;
   if (obj.nts2Enum) result.enum = obj.nts2Enum;
-  
+
   // Handle discriminator
   if (obj.discriminator) {
     result.discriminator = obj.discriminator;
   }
-  
+
   // Recursively process properties
   if (obj.properties) {
     result.properties = {};
-    Object.keys(obj.properties).forEach(key => {
+    Object.keys(obj.properties).forEach((key) => {
       const prop = obj.properties[key];
       if (hasNts2Ref(prop)) {
-        result.properties[key] = extractNts2Properties(prop);
+        result.properties[key] = extractNts2Properties(prop, key);
       }
     });
     // Only keep properties if we found some with nts2Ref
@@ -181,18 +213,18 @@ function extractNts2Properties(obj) {
       delete result.properties;
     }
   }
-  
+
   // Handle arrays
   if (obj.items) {
     if (hasNts2Ref(obj.items)) {
       result.items = extractNts2Properties(obj.items);
     }
   }
-  
+
   // Handle oneOf
   if (obj.oneOf) {
-    const processedOneOf = [];
-    obj.oneOf.forEach((schema, index) => {
+    // Always preserve the full array structure and order
+    const processedOneOf = obj.oneOf.map((schema, index) => {
       if (hasNts2Ref(schema)) {
         const extracted = extractNts2Properties(schema);
         // For oneOf schemas, we need to preserve discriminator enum values
@@ -201,31 +233,86 @@ function extractNts2Properties(obj) {
           if (schema.properties[propName]) {
             if (!extracted.properties) extracted.properties = {};
             extracted.properties[propName] = {
-              enum: schema.properties[propName].nts2Enum || schema.properties[propName].enum
+              enum:
+                schema.properties[propName].nts2Enum ||
+                schema.properties[propName].enum,
             };
           }
         }
-        processedOneOf.push(extracted);
+        // Also preserve base enum values for all other properties in the extension
+        if (schema.properties) {
+          if (!extracted.properties) extracted.properties = {};
+          Object.keys(schema.properties).forEach((propName) => {
+            const prop = schema.properties[propName];
+            if (prop.enum) {
+              if (!extracted.properties[propName]) {
+                extracted.properties[propName] = {
+                  enum: prop.enum,
+                };
+              } else if (!extracted.properties[propName].enum) {
+                // If the property exists but doesn't have enum, add it
+                extracted.properties[propName].enum = prop.enum;
+              }
+            }
+          });
+        }
+        return extracted;
+      } else {
+        // If this branch doesn't have nts2Ref, preserve the base discriminator enum
+        if (obj.discriminator && schema.properties) {
+          const propName = obj.discriminator.propertyName;
+          if (schema.properties[propName]) {
+            return {
+              properties: {
+                [propName]: {
+                  enum: schema.properties[propName].enum,
+                },
+              },
+            };
+          }
+        }
+        // If no discriminator, return empty object to preserve structure
+        return {};
       }
     });
-    if (processedOneOf.length > 0) {
-      result.oneOf = processedOneOf;
+    result.oneOf = processedOneOf;
+
+    // --- NEW: If this is an extension property inside a oneOf, promote it to the parent overlay ---
+    // If parentKey is set, and this object has extension metadata, return a stub for the parent
+    if (
+      parentKey &&
+      (result.ntsRef || result.required || result.discriminator)
+    ) {
+      // This is an extension property inside a oneOf branch
+      // Return a stub for the parent property with metadata and oneOf structure
+      const parentStub = {};
+      Object.assign(parentStub, result);
+      return parentStub;
     }
   }
-  
+
   // Copy other JSON Schema keywords that might be present
-  ['type', 'format', 'minimum', 'maximum', 'minLength', 'maxLength', 'minItems', 'maxItems'].forEach(keyword => {
+  [
+    "type",
+    "format",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+  ].forEach((keyword) => {
     if (obj[keyword] !== undefined) {
       result[keyword] = obj[keyword];
     }
   });
-  
+
   return result;
 }
 
 // Add required array at parent levels if needed
 function addRequiredArrays(overlay, schema) {
-  traverse(overlay).forEach(function(node) {
+  traverse(overlay).forEach(function (node) {
     if (node && node.properties) {
       const schemaPath = "/" + this.path.join("/");
       try {
@@ -233,7 +320,9 @@ function addRequiredArrays(overlay, schema) {
         if (schemaNode && schemaNode.nts2Required) {
           // Filter to only include properties that exist in this overlay
           const overlayProps = Object.keys(node.properties);
-          const requiredProps = schemaNode.nts2Required.filter(prop => overlayProps.includes(prop));
+          const requiredProps = schemaNode.nts2Required.filter((prop) =>
+            overlayProps.includes(prop)
+          );
           if (requiredProps.length > 0) {
             node.required = requiredProps;
           }
@@ -249,23 +338,25 @@ function addRequiredArrays(overlay, schema) {
 // Generate extension overlays
 Object.entries(extensionMappings).forEach(([code, config]) => {
   console.log(`\nGenerating extension overlay: ${code} (${config.name})`);
-  
+
   // Extract the specific paths
   let overlay = extractPathsWithNts2Ref(combinedSchema, config.paths);
-  
+
   // Add required arrays where needed
   overlay = addRequiredArrays(overlay, combinedSchema);
-  
+
   // Add schema metadata
   overlay.$schema = "http://json-schema.org/draft-07/schema#";
   overlay.$id = `https://trust.propdata.org.uk/schemas/v3/overlays/extensions/${code}.json`;
   overlay.$comment = config.description;
-  
+
   // Write the overlay file
-  const fileName = path.join(__dirname, `../schemas/v3/overlays/extensions/${code}.json`);
+  const fileName = path.join(
+    __dirname,
+    `../schemas/v3/overlays/extensions/${code}.json`
+  );
   fs.writeFileSync(fileName, JSON.stringify(overlay, null, 2));
   console.log(`Extension overlay ${code} written to ${fileName}`);
 });
 
-
-console.log("\nExtension overlay extraction complete!");
+console.log("\nExtension overlay extraction complete!");