a6y-schema

Antology schema

Simple JSON schema definition language in pure JSON.

Helper functions

• inferSchema({object}) - creates a schema definition from the JSON object object
• checkSchema({schema}) - checks if a schema definition schema is a valid a6y schema
• verifyObject({schema, object}) - checks is an object object satisfies an a6y schema schema

Schema definition definition

We tried to develop a definition language that is as simple as possible but still allows for specifying the definition language itself:

verifyObject({object: schemaDefinition, schema: schemaDefinition}).success === true

Meta definition

The following JSON object is a valid a6y schema and specifies how an a6y schema has to look. Mixing meta layers can be quite confusing. It is like you wanted to describe how an English phrase is structured just using English words.

{
  "version": "1",
  "name": "$",
  "type": "struct",
  "struct": [
    {
      "name": "version",
      "type": "string"
    },
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "type",
      "type": "string"
    },
    {
      "name": "struct",
      "type": "list",
      "optional": true,
      "list": {
        "type": "struct",
        "struct": [
          {
            "name": "name",
            "type": "string"
          },
          {
            "name": "type",
            "type": "string"
          },
          {
            "name": "struct",
            "type": "$.struct",
            "optional": true
          },
          {
            "name": "list",
            "type": "$.list",
            "optional": true
          },
          {
            "name": "optional",
            "type": "boolean",
            "optional": true
          }
        ]
      }
    },
    {
      "name": "list",
      "type": "struct",
      "optional": true,
      "struct": [
        {
          "name": "type",
          "type": "string"
        },
        {
          "name": "struct",
          "type": "$.struct",
          "optional": true
        },
        {
          "name": "list",
          "type": "$.list",
          "optional": true
        }
      ]
    }
  ]
}

Even though it might seem complicated it is actually quite simple considering it fully specifies the a6y schema language as an a6y schema.

Examples

String

inferSchema({object: 'test'}).schema

{
    "version": "1",
    "name": "$",
    "type": "string"
}

List of integers

inferSchema({object: [1, 2, 3]}).schema

{
    "version": "1",
    "name": "$",
    "type": "list",
    "list": {
        "type": "integer"
    }
}

Recursive definition

Imagine you have a filesystem structure like this:

{
  "name": "filesystem",
  "files": [
    "text.txt",
    "image.png",
    "audio.mp3"
  ],
  "subfolders": [
    {
      "name": "logs",
      "files": [
        "logs1.txt",
        "logs2.txt",
        "logs3.txt"
      ],
      "subfolders": {
        "name": "archive",
        "files": [
          "oldlogs1.txt",
          "oldlogs2.txt",
          "oldlogs3.txt"
        ]
      }
    },
    {
      "name": "empty_folder"
    }
  ]
}

In this case you have a potentially infinitely deeply nested structure which needs recursive definition:

{
  "version": "1",
  "name": "$",
  "type": "struct",
  "struct": [
    {
      "name": "name",
      "type": "string"
    },
    {
      "name": "files",
      "type": "list",
      "optional": true,
      "list": {
        "type": "string"
      }
    },
    {
      "name": "subfolders",
      "type": "list",
      "optional": true,
      "list": {
        "type": "$"
      }
    }
  ]
}

Note the dollar sign $ at the end which refers to the root element and allows for recursive nesting.