objeto - mostrar datos json javascript

¿Cómo puedo definir un esquema de Json que contenga definiciones, en código?

Question

Estoy intentando replicar el siguiente ejemplo de Json Schema , definiendo el esquema en código usando Newtonsoft.Json.Schema :

{
  "$schema": "http://json-schema.org/draft-04/schema#",

  "definitions": {
    "address": {
      "type": "object",
      "properties": {
        "street_address": { "type": "string" },
        "city":           { "type": "string" },
        "state":          { "type": "string" }
      },
      "required": ["street_address", "city", "state"]
    }
  },

  "type": "object",

  "properties": {
    "billing_address": { "$ref": "#/definitions/address" },
    "shipping_address": { "$ref": "#/definitions/address" }
  }

Esto es lo más cercano que tengo hasta ahora. (El ejemplo está en F # pero podría estar en C #).

Código:

open Newtonsoft.Json.Schema
open Newtonsoft.Json.Linq

let makeSchema = 
    let addressSchema = JSchema()
    addressSchema.Properties.Add("street_address", JSchema(Type = Nullable(JSchemaType.String)))
    addressSchema.Properties.Add("city", JSchema(Type = Nullable(JSchemaType.String)))
    addressSchema.Properties.Add("state", JSchema(Type = Nullable(JSchemaType.String)))
    addressSchema.Required.Add "street_address"
    addressSchema.Required.Add "city"
    addressSchema.Required.Add "state"

    let schema = JSchema()
    schema.Properties.Add("billing_address", addressSchema)
    schema.Properties.Add("shipping_address", addressSchema)
    schema

Salida:

{
  "properties": {
    "billing_address": {
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    },
    "shipping_address": {
      "$ref": "#/properties/billing_address"
    }
  }
}

Como puede ver, solo una de las dos direcciones se define utilizando una referencia a otro esquema, y ​​el esquema de la dirección está en "propiedades" en lugar de "definiciones". ¿Cuál es el truco para definir un esquema en "definiciones" y hacer referencia a él en otro lugar?

Answer 1

Hackfest! :-)

De acuerdo con el código fuente , JSON.NET Schema simplemente no escribe una propiedad de definitions , al final de la historia. Entonces todo es inútil ... Casi.

Sin embargo, usa la propiedad de definitions en otro lugar. A saber: cuando se genera un esquema a partir de un tipo . Durante ese proceso, crea un JObject , JObject todos los esquemas en él y luego agrega ese objeto a JSchema.ExtensionData bajo la clave de definitions . Y al hacer referencia a un esquema desde otro lugar, el escritor de esquemas respetará ese objeto de definitions , si está presente, haciendo que todo funcione conjuntamente.

Entonces, armados con este conocimiento, podemos hackear nuestro camino hacia él:

let makeSchema = 
    let addressSchema = JSchema()
    ...

    let definitions = JObject() :> JToken
    definitions.["address"] <- addressSchema |> JSchema.op_Implicit

    let schema = JSchema()
    schema.ExtensionData.["definitions"] <- definitions
    schema.Properties.Add("billing_address", addressSchema)
    schema.Properties.Add("shipping_address", addressSchema)
    schema

¡Y voilá! El esquema resultante ahora tiene un objeto de definitions , tal como los textos sagrados nos dicen que debería:

{
  "definitions": {
    "address": {
      "properties": {
        "street_address": {
          "type": "string"
        },
        "city": {
          "type": "string"
        },
        "state": {
          "type": "string"
        }
      },
      "required": [
        "street_address",
        "city",
        "state"
      ]
    }
  },
  "properties": {
    "billing_address": {
      "$ref": "#/definitions/address"
    },
    "shipping_address": {
      "$ref": "#/definitions/address"
    }
  }
}

Algunas notas:

1. El nombre de las definitions no es especial desde el punto de vista de JSON.NET. Si cambia la línea schema.ExtensionData.["definitions"] a algo diferente, diga schema.ExtensionData.["xyz"] , seguirá funcionando, y todas las referencias apuntan a "#/xyz/address" .
2. Todo este mecanismo, obviamente, es un hack Aparentemente no, según James Netwon-King . La idea clave parece ser que el JsonSchemaWriter podrá buscar cualquier mención previa de esquemas y usar referencias a ellos en otros lugares. Esto permite empujar los esquemas donde quiera y esperar que se haga referencia a ellos.
3. Esa llamada op_Implicit allí es necesaria. JSchema no es un subtipo de JToken , por lo que no puedes JToken a definitions.["address"] JToken definitions.["address"] así, primero JToken convertirlo a JToken . Afortunadamente, hay un operador de conversión implícito definido para eso. Desafortunadamente, no es sencillo, parece que hay algo de magia sucediendo. Esto ocurre de manera transparente en C # (porque, ya sabes, no hay suficiente confusión), pero en F # tienes que llamarlo de manera explícita.