@pdtf/schemas 3.6.0-23 → 3.6.0-24

package/index.js

@@ -254,28 +254,44 @@ const getCachedSchemaData = (path, schemaId, overlays) => {
           }
         }
 
-        // Check oneOf discriminators
+        // Check oneOf discriminators (recursively for nested oneOf)
         if (oneOf) {
-          let matchingProperty;
-          oneOf.forEach((aOneOf) => {
-            if (aOneOf.type === "array" && !Number.isNaN(pathElement)) {
-              matchingProperty = aOneOf.items;
-            } else if (aOneOf.properties?.[pathElement]) {
-              matchingProperty = aOneOf.properties?.[pathElement];
-            } else if (aOneOf.patternProperties) {
-              for (const pattern in aOneOf.patternProperties) {
-                try {
-                  const regex = new RegExp(pattern);
-                  if (regex.test(pathElement)) {
-                    matchingProperty = aOneOf.patternProperties[pattern];
-                    break;
+          const findInOneOf = (branches) => {
+            let arrayFallback;
+            for (const branch of branches) {
+              if (!branch) continue;
+              // Track array matches as fallback (prefer property matches)
+              if (
+                branch.type === "array" &&
+                !Number.isNaN(pathElement) &&
+                !arrayFallback
+              ) {
+                arrayFallback = branch.items;
+              }
+              if (branch.properties?.[pathElement]) {
+                return branch.properties[pathElement];
+              }
+              if (branch.patternProperties) {
+                for (const pattern in branch.patternProperties) {
+                  try {
+                    const regex = new RegExp(pattern);
+                    if (regex.test(pathElement)) {
+                      return branch.patternProperties[pattern];
+                    }
+                  } catch (e) {
+                    // Invalid regex pattern - skip
                   }
-                } catch (e) {
-                  // Invalid regex pattern - skip
                 }
               }
+              // Recurse into nested oneOf branches
+              if (branch.oneOf) {
+                const nested = findInOneOf(branch.oneOf);
+                if (nested) return nested;
+              }
             }
-          });
+            return arrayFallback;
+          };
+          const matchingProperty = findInOneOf(oneOf);
           if (matchingProperty) return matchingProperty;
         }
 

package/package.json

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

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

@@ -233,6 +233,37 @@ test("correctly gets yes another subschema but through a non-baspi oneOf structu
   expect(subschema).toEqual({ type: "string" });
 });
 
+test("correctly resolves properties inside nested oneOf branches", () => {
+  // attachments is at japaneseKnotweed.oneOf[1].oneOf[1].properties.attachments
+  const subschema = getSubschema(
+    "/propertyPack/specialistIssues/japaneseKnotweed/attachments"
+  );
+  expect(subschema).toBeDefined();
+  expect(subschema.type).toBe("string");
+  expect(subschema.enum).toContain("To follow");
+  expect(subschema.enum).toContain("Attached");
+});
+
+test("isPathValid returns true for nested oneOf properties", () => {
+  expect(
+    isPathValid("/propertyPack/specialistIssues/japaneseKnotweed/attachments")
+  ).toBe(true);
+  // knotweedSurveyCarriedOut.attachments is also nested in a oneOf
+  expect(
+    isPathValid(
+      "/propertyPack/specialistIssues/japaneseKnotweed/knotweedSurveyCarriedOut/attachments"
+    )
+  ).toBe(true);
+});
+
+test("isPathValid returns false for non-existent paths in nested oneOf", () => {
+  expect(
+    isPathValid(
+      "/propertyPack/specialistIssues/japaneseKnotweed/nonExistentField"
+    )
+  ).toBe(false);
+});
+
 test("correctly gets an overlaid enum in a subschema", () => {
   const subschema = getSubschema(
     "/propertyPack/electricity/mainsElectricity/yesNo",