Mechanism for describing "foreign key" relationships between two schema?

[sparr]

I have two schema, call them A and B, that each describe an object with an id key, and A has a B_id key. I want to indicate that A.B_id refers to B.id, such that some tool might be able to parse the relevant json files and check/enforce that every A.B_id matches some B.id. This is analogous to a foreign key relationship in a relational database.

Is there a way to do this in JSON Schema? Are there any existing proposals to add this sort of functionality? Are there third party tools or other standards that could be used to accomplish this?

[jdesrosiers]

The main thing that's missing from JSON Schema to support something like this is that there's no concept of a database (using the term loosely) of JSON instances that defines what instances exist and what schemas they conform to. I don't think that belongs as a part of JSON Schema, but rather as a product that uses JSON Schema. I don't think we want to be in the business of specifying a database system.

Once you have a database system of some kind, you could then create a custom dialect of JSON Schema that includes a keyword that can declare something as a foreign key and validate based on that relationship.

[sparr]

I agree that the db of what instances exist and what schemas they conform to is a separate tool, as would be enforcing the foreign key relationships.

What I'm thinking of here is purely on the schema definition side.

We already have a way for one schema to say "the definition of this property is an entire other schema", e.g. "$ref": "someotherschema".

Consider if we had a way to say "the definition of this property is identical to a specific field in another schema", which might look something like "$ref_property": "someotherschema.someproperty". This would, at the very least, eliminate the duplication of the two definitions, enforcing that the two schemas stay in sync while only changing one of them. Of course, we can already accomplish this by separately defining the schema for that property and having both of the other schemas refer to it, but that is less convenient and also loses the implication that the property schema in question belongs to one of the two schema.

Once that relationship between schema contents was possible, then marking such a relationship as to be enforced based on the data in the files would be a lot less of a stretch.

Maybe if I'm going to bring this forward as a proposal, that first step of just having property refs would be a better target? It's simpler and more general purpose.

[jdesrosiers]

Oh, well that's much simpler.

It sounds like you're not aware that you reference a subschema of a remote schema using JSON Pointers. I think that solves your problem. For example: "A_id": { "$ref": "/a#/properties/id" }. But it's considered bad style to reference anything other than an definition, so I'd do it like this ...

{
  "$schema": "https://json-schema.org/draft/2020-12",
  "$id": "https://example.com/schemas/a",

  "type": "object",
  "properties": {
    "id": { "$ref": "#id" }, // <-- Reference the ID definition
    "foo": { "type": "number" },
    "bar": { "type": "string" }
  },

  "$defs": {
    "id": {
      "$anchor": "id",
      "type": "string",
      "format": "uuid"
    }
  }
}

{
  "$schema": "https://json-schema.org/draft/2020-12",
  "$id": "https://example.com/schemas/b",

  "type": "object",
  "properties": {
    "id": { "$ref": "#id" }, // <-- Reference the local ID definition
    "a_id": { "$ref": "a#id" }, // <-- Reference the A's ID definition
    "baz": { "type": "boolean" }
  },

  "$defs": {
    "id": {
      "$anchor": "id",
      "type": "number",
      "minimum": 1
    }
  }
}

Using $anchor isn't required. You could reference it directly using its JSON Pointer a#/$defs/id. I like to use anchors for things that are intended the be referenced externally and consider definitions that don't have anchors to be private to the local schema document.