python - online - quicktipe

¿Cómo usar un esquema GraphQL para la validación de datos de tipo esquema JSON?

Question

Estamos estudiando el uso de GraphQL para la versión 2 de un CMS sin cabeza que estamos desarrollando.

En la versión 1 de este CMS, utilizamos el esquema JSON para validar cada documento con un esquema antes de guardarlo en la base de datos; por ejemplo, si es un artículo de blog, se validaría con el esquema de Article y si se trata de un resumen ( la lista "lo mejor de") sería validada en comparación con el esquema Roundup .

Para la versión 2, estamos contemplando el uso de GraphQL para la API. Y luego se nos ocurrió que el esquema GraphQL es básicamente paralelo al esquema JSON: describe la estructura del documento, los tipos de campo, etc.

Así que podríamos simplemente tener "una fuente de verdad de esquema", el esquema de GraphQL, y usar esto para consultar documentos y para validar nuevos documentos cuando se guarda una nueva revisión. (Tenga en cuenta que estoy hablando de validar los datos JSON con un esquema GraphQL, no validando una consulta GraphQL contra un esquema).

Me imagino que los datos se validarán contra todos los campos en el esquema, excepto los campos en desuso, porque solo quiere validar contra la "última versión" de los campos.

Podríamos hacer una de estas tres cosas:

1. Use GraphQL AST directamente para validar un documento, es decir, escriba un validador de datos nosotros mismos.
2. Utilice GraphQL AST para generar un esquema JSON y utilice un validador de esquema JSON estándar para validarlo realmente.
3. Simplemente acepte que GraphQL no es el más adecuado para la validación, y defina el esquema dos veces: una en GraphQL para consultas y otra en JSON Schema para validación (molesta y propensa a errores para mantenerlas sincronizadas).

Preguntas: ¿Son las ideas tontas n. ° 1 y n. ° 2. ¿Hay alguna herramienta GraphQL que haga este tipo de validación de datos? ¿Hay otras maneras de lograr esto sin definir el esquema dos veces?

Como referencia, nuestro backend estará escrito en Python, pero la interfaz de usuario del administrador será React y JavaScript del lado del cliente. Esta es una versión reducida del tipo de esquema GraphQL del que estamos hablando (admite tipos de documento "Artículo" y "Roundup"):

schema {
    query: Query
}

type Query {
    documents: [Document!]!
    document(id: Int): Document!
}

interface Document {
    id: Int!
    title: String!
}

type Article implements Document {
    id: Int!
    title: String!
    featured: Boolean!
    sections: [ArticleSection!]!
}

union ArticleSection = TextSection | PhotoSection | VideoSection

type TextSection {
    content: String!
    heading: String
}

type PhotoSection {
    sourceUrl: String!
    linkUrl: String
    caption: String
    content: String
}

type VideoSection {
    url: String!
}

type Roundup implements Document {
    id: Int!
    title: String!
    isAward: Boolean!
    intro: String
    hotels: [RoundupHotel!]!
}

type RoundupHotel {
    url: String!
    photoUrl: String @deprecated(reason: "photoUrl is deprecated; use photos")
    photos: [RoundupPhoto!]!
    blurb: String!
    title: String
}

type RoundupPhoto {
    url: String!
    caption: String
}

Answer 1

Nivel de certeza en la situación en evolución

GraphQL sigue siendo una tecnología en evolución ( como se dice en la parte superior del documento de especificaciones ) por lo que es seguro decir que no hay respuestas verdaderamente "correctas" para esto.

Generalidades

Los tipos InputObject ("entrada" en los términos del lenguaje de definición de interfaz) junto con las listas ("[]" en términos IDL) junto con los diversos escalares parecen cubrir completamente lo que puede hacer en JSON.

Si la implementación Python de GraphQL cumple con la especificación, el suministro de datos como literales de GraphQL o (mejor) como "variables" debería proporcionar todo lo que una validación personalizada podría: la validación de GraphQL hará lo correcto.

Recomendación para su situación

Basado en mi trabajo con GraphQL hasta ahora, mi sugerencia es "ir con el grano". Si su esquema de GraphQL cumple con lo que su arquitectura de datos requiere, simplemente use la validación de GraphQL normal. Si realiza su propia validación, debe venir después de que GraphQL haya realizado su comprobación normal de forma de datos.

Para resumir los puntos anteriores, y para responder a su pregunta con una pregunta: ¿qué hay de malo en permitir que GraphQL en su funcionamiento normal haga la validación de levantamiento de objetos pesados?