Generating JSON Paths from a JSON Schema structure

Question

Generating JSON Paths from a JSON Schema structure

Can anyone recommend a Javascript library that can generate a list of possible Json Paths based on a given Json Schema?

Imagine having a json schema structured like the one below, I am interested in a tool that can provide me with all potential json paths.

{
  "$id": "https://example.com/person.schema.json",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Customer",
  "type": "object",
  "properties": {
    "firstName": {
      "type": "string",
      "description": "The person's first name."
    },
    "lastName": {
      "type": "string",
      "description": "The person's last name."
    },
    "age": {
      "description": "Age in years which must be equal to or greater than zero.",
      "type": "integer",
      "minimum": 0
    },
    "address": {
        "type": "object",
        "city": {
            "type": "string",
        },
        "country": {
            "type": "string",
        }
    }
  }
}

The expected Json Paths would include: firstName, lastName, age, address.city, and address.country

javascript json jsonschema jsonpath

Answer 1

Answer №1

Referencing @customcommander's response

Integrate $ref support to avoid recursion
Include hierarchy parent paths (e.g. a.b.c -> a + a.b + a.b.c)
Incorporate array items support (using [] as a generic indexer)

const _derivePathsFromSchema = (schema, properties, defined) => {
  let paths = [];
  if (!properties) return paths;
  return Object.keys(properties).reduce((paths, childKey) => {
    let child = properties[childKey];
    const { $ref, ...childProperties } = child;
    if ($ref?.startsWith('#/definitions/')) {
      const definition = $ref.substr($ref.lastIndexOf('/') + 1);
      if (!defined.includes(definition)) // prevent recursion of definitions
      {
        defined.push(definition);
        child = {
          ...schema.definitions[definition], // load $ref properties
          ...childProperties, // child properties override those of the $ref
        };
      }
    }
    if (child.type === 'object') {
      return paths.concat(childKey, _derivePathsFromSchema(schema, child.properties, defined.slice()).map(p => `${childKey}.${p}`));
    }
    if (child.type === 'array' && child.items?.properties) {
      return paths.concat(childKey, `${childKey}[]`, _derivePathsFromSchema(schema, child.items.properties, defined.slice()).map(p => `${childKey}[].${p}`));
    }

    return paths.concat(childKey);
  }, paths);
};
const derivePathsFromSchema = schema => _derivePathsFromSchema(schema, schema.properties, []);


console.log(derivePathsFromSchema({
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "BType": {
      "type": "object",
      "properties": {
        "a": {
          "$ref": "#/definitions/AType"
        }
      }
    },
    "AType": {
      "type": "object",
      "properties": {
        "b": {
          "$ref": "#/definitions/BType"
        }    
      }
    }
  },
  "type": "object",
  "properties": {
    "a": {
      "$ref": "#/definitions/AType"
    },
    "b": {
      "$ref": "#/definitions/BType"
    },
    "id": {
      "type": "string"
    },
    "array": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "item": { "type": "string" }
        }
      }
    },
    "obj": {
      "type": "object",
      "properties": {
        "nested": { "type": "string" }
      }
    }
  }
}));

Answer 2

Referencing @customcommander's response

Integrate $ref support to avoid recursion
Include hierarchy parent paths (e.g. a.b.c -> a + a.b + a.b.c)
Incorporate array items support (using [] as a generic indexer)

const _derivePathsFromSchema = (schema, properties, defined) => {
  let paths = [];
  if (!properties) return paths;
  return Object.keys(properties).reduce((paths, childKey) => {
    let child = properties[childKey];
    const { $ref, ...childProperties } = child;
    if ($ref?.startsWith('#/definitions/')) {
      const definition = $ref.substr($ref.lastIndexOf('/') + 1);
      if (!defined.includes(definition)) // prevent recursion of definitions
      {
        defined.push(definition);
        child = {
          ...schema.definitions[definition], // load $ref properties
          ...childProperties, // child properties override those of the $ref
        };
      }
    }
    if (child.type === 'object') {
      return paths.concat(childKey, _derivePathsFromSchema(schema, child.properties, defined.slice()).map(p => `${childKey}.${p}`));
    }
    if (child.type === 'array' && child.items?.properties) {
      return paths.concat(childKey, `${childKey}[]`, _derivePathsFromSchema(schema, child.items.properties, defined.slice()).map(p => `${childKey}[].${p}`));
    }

    return paths.concat(childKey);
  }, paths);
};
const derivePathsFromSchema = schema => _derivePathsFromSchema(schema, schema.properties, []);


console.log(derivePathsFromSchema({
  "$schema": "http://json-schema.org/draft-07/schema#",
  "definitions": {
    "BType": {
      "type": "object",
      "properties": {
        "a": {
          "$ref": "#/definitions/AType"
        }
      }
    },
    "AType": {
      "type": "object",
      "properties": {
        "b": {
          "$ref": "#/definitions/BType"
        }    
      }
    }
  },
  "type": "object",
  "properties": {
    "a": {
      "$ref": "#/definitions/AType"
    },
    "b": {
      "$ref": "#/definitions/BType"
    },
    "id": {
      "type": "string"
    },
    "array": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "item": { "type": "string" }
        }
      }
    },
    "obj": {
      "type": "object",
      "properties": {
        "nested": { "type": "string" }
      }
    }
  }
}));

Answer 3

Answer №2

You don't have to rely on a library for this task. A simple recursive function can get the job done:

var data = {
  "name": "John",
  "age": 30,
  "pets": {
    "dog": {
      "name": "Buddy",
      "breed": "Golden Retriever"
    },
    "cat": {
      "name": "Whiskers",
      "breed": "Siamese"
    }
  }
};

var extractKeys = ({}) =>
  Object.keys(data).reduce((acc, key) =>
    acc.concat(typeof data[key] !== 'object' ? key :
      extractKeys(data[key]).map(p => `${key}.${p}`)), []);

console.log(
  extractKeys(data)
);

Answer 4

You don't have to rely on a library for this task. A simple recursive function can get the job done:

var data = {
  "name": "John",
  "age": 30,
  "pets": {
    "dog": {
      "name": "Buddy",
      "breed": "Golden Retriever"
    },
    "cat": {
      "name": "Whiskers",
      "breed": "Siamese"
    }
  }
};

var extractKeys = ({}) =>
  Object.keys(data).reduce((acc, key) =>
    acc.concat(typeof data[key] !== 'object' ? key :
      extractKeys(data[key]).map(p => `${key}.${p}`)), []);

console.log(
  extractKeys(data)
);

Generating JSON Paths from a JSON Schema structure

Answer №1

Answer №2

Similar questions

Why do my messages from BehaviorSubject get duplicated every time a new message is received?

The error message "Failed to load the default credentials in Firebase" occurs sporadically. Approximately 50% of the time, the app functions properly, while the other 50% of the time, this specific

Converting milliseconds to a valid date object using Angular form validation

Utilizing Javascript / jQuery to eliminate specific CSS styles

Decoding JSON data retrieved from the Pokeapi

Sweetalert fails to display following a successful execution of the function

Dealing with React Native: Navigating App Store Rejections and Embracing IPv6

Saving a .JSON file with Java ME

Why does the text in a div display in Safari 8.2 and Chrome 39, but not in Firefox 34?

Struggling with passing custom headers in Rails, jQuery, and Ajax interactions

NextJS 13 causes tailwind to malfunction when route group is utilized

Utilize middleware in a separate controller file to handle specific tasks within an Express application

Issue with MUI Data Grid sorting: Data Grid sortComparator function returning undefined

The worth of the scope is evident, yet it remains undefined when trying to access it

How can I automatically add a specific word that I've highlighted within a <text area> situated within an iframe?

When attempting to process a JSON file within my application, everything appears to be error-free. However, upon trying to run the app on the emulator, it fails to execute

whenever I execute my `node file.js 1 23 44` command, nothing is displayed on the screen

Seeking assistance in understanding how to validate images in Javascript code with the use of Selenium WebDriver. Any t

Adding fewer components to your current Angular 5 project

Extract the year from a string formatted as 1880-01-01T00:00:00.000