FSET

Structure Editor Series

FModel JSON Schema Editor

No more writing raw schema by hand, no programming tooling required

editor overview
  • Currently in closed beta
  • Log in

Example data from https://vega.github.io

  • Currently in closed beta
  • Log in
Documentation Pricing

Algebraic Data Type to JSON Schema

Think in terms of algebraic data type, export sane subset of json schema ( see all types )

      • type Record = {   }
        • field_a : string
        • field_b : int_32 
    {
  "properties": {
    "field_a": {
      "type": "string"
    },
    "field_b": {
      "maximum": 2147483647,
      "minimum": -2147483648,
      "type": "integer"
    }
  },
  "required": [
    "field_a"
  ],
  "type": "object"
}
      • type Tuple = (   )
        • 0 : "ok"
        • 1 : ExportDocs::Record
        • 2 : { any } 
    {
  "maxItems": 3,
  "minItems": 3,
  "prefixItems": [
    {
      "const": "ok"
    },
    {
      "$ref": "https://localhost/ExportDocs#/$defs/Record"
    },
    {
      "properties": {},
      "type": "object"
    }
  ],
  "type": "array"
}
      • type Dict = dict
        • k string
        • v ExportDocs::Record 
    {
  "additionalProperties": {
    "$ref": "https://localhost/ExportDocs#/$defs/Record"
  },
  "minProperties": 4,
  "propertyNames": {
    "pattern": "^x-",
    "type": "string"
  },
  "type": "object"
}
     
    {
  "items": {
    "$ref": "https://localhost/ExportDocs#/$defs/Record"
  },
  "type": "array"
}
      • type TaggedUnion = || _mytag
        • | tag_a · {   }
          • field_x : uint_8
        • | tag_b · {   }
          • field_z : string 
    {
  "oneOf": [
    {
      "properties": {
        "_mytag": {
          "const": "tag_a"
        },
        "field_x": {
          "maximum": 255,
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "_mytag",
        "field_x"
      ],
      "type": "object"
    },
    {
      "properties": {
        "_mytag": {
          "const": "tag_b"
        },
        "field_z": {
          "type": "string"
        }
      },
      "required": [
        "_mytag"
      ],
      "type": "object"
    }
  ],
  "unevaluatedProperties": false
}
      • type UnionOfVal = ||
        • | "a"
        • | 10
        • | true
        • | null 
    {
  "enum": [
    "a",
    10,
    true,
    null
  ]
}

Constructing schema as productive as working in text editor

With essential keyboard commands ( see all commands )

Add

Add random schema to container types
Shift + +

Move

Cut selected schemas
Cmd + x
Copy selected schemas
Cmd + c
Paste
Cmd + v
Cancel copy or cut
Escape

Clone

Clone selected schemas
Shift + Alt + ArrowUp

Shift + Alt + ArrowDown

Reorder

Reorder selected schemas up or down
Alt + ArrowUp

Alt + ArrowDown

Collapse / Expand

Collapse selected schemas
ArrowLeft
Expand selected schemas
ArrowRight

Delete

Delete selected schemas
Delete

Select

Select a schema
ArrowUp
ArrowDown
Select a sibling schema
i
j
Select mutiple schemas
Shift + ArrowUp
Shift + ArrowDown
Select mutiple schema all the way
Shift + Cmd + ArrowUp

Shift + Cmd + ArrowDown
Select the first child
Cmd + ArrowUp
Select the last child
Cmd + ArrowDown
Select the root element of tree
Home
Select the last element of tree
End

Rename key

Enable key editing on a selected schema
Enter
Submit a changed key with current text input value
Enter
Cancel editing
Escape

Change type

Enable type editing on a selected schema
Shift + Enter
Submit a changed type with current text input value
Enter
Cancel editing
Escape
For Windows, use Ctrl in place of Cmd

Reference tracking and integrity

Once a type is referenced, name and namespace updates automatically reflects on referrers

When there exists at least one referrer, the referenced type cannot be deleted, enforced at db-level

reference tracking

Export as a bundle

All modules are bundled as a single JSON Schema file based on Compound Documents Specification

Bundled schema is also a usable schema. Validator can validate the file without decomposing schema definitions into separate files.

exported bundle
AJV validator

Currently AJV needs one step of decomposing files

const Ajv2020 = require("ajv/dist/2020")
let ajv = new Ajv2020()

let programSch = require("./sch.json")

for (modu of Object.keys(programSch.$defs)) {
  ajv.addSchema(programSch.$defs[modu])
  delete programSch.$defs[modu]
}

const data = { data: { values: ["a", "b"] }, mark: "arc" }
let result = ajv.validate(programSch, data)

console.log(result)
console.log(ajv.errors)
Hyperjump validator
const hpj = require("@hyperjump/json-schema")
hpj
  .get("file://./sch.json")
  .then(schema => hpj.validate(schema, { data: { values: ["a", "b"] }, mark: "arc" }))
  .then(output => console.log(output))

Simply think each $id is a module and each of $defs is a type,

for more information see Export documentation