¿Cuál es la mejor manera de realizar un seguimiento de los formatos de solicitud y respuesta JSON en un proyecto de aplicación web grande?

Parece que tiene dos problemas aquí: un problema de lectura (“¿Cómo pueden los desarrolladores buscar fácilmente el formato de una solicitud dada?”) Y un problema de escritura (“¿Cómo puedo asegurarme de que la documentación siempre refleje la realidad?”)

Actualmente, por lo que parece, está haciendo su análisis JSON y la composición de resultados ad-hoc en su código de aplicación. Además, supongo que está haciendo lo mismo ad-hoc en la dirección opuesta en su código del lado del cliente. Y también está actualizando manualmente su documentación. Eso significa que actualmente tiene tres fuentes de verdad, que generalmente es una receta para la inconsistencia.

Una buena respuesta aquí es la metaprogramación. En este contexto, eso significa que especifica su API JSON en un solo lugar y escribe código que genera bibliotecas del lado del cliente para componer solicitudes y decodificar respuestas, bibliotecas del lado del servidor para decodificar solicitudes y componer respuestas, y (posiblemente) documentación, que puedes usar una bonita interfaz de usuario web si quieres. Digo “posiblemente” en el caso de la documentación porque un enfoque es usar la documentación como entrada para su herramienta de generación de código, lo que significa que las personas pueden referirse directamente a eso según sea necesario y estar 100% seguros de que es preciso.

En términos prácticos, esto significa que el código de aplicación que mantiene a mano nunca se ocupará directamente de las solicitudes o respuestas JSON; en su lugar, tratará con estructuras de datos que son consumidas o producidas por funciones de biblioteca generadas, y esas funciones de biblioteca asignarán las estructuras de datos a las representaciones JSON apropiadas.

Un beneficio adicional de este enfoque es que, una vez que lo haga funcionar, es probable que produzca código con menos errores que sea más fácil de probar, en virtud de darle un solo lugar para aplicar correcciones a nivel mundial o para insertar globalmente datos ficticios o verificadores de sanidad de respuesta .

En cuanto al problema de lectura, un enfoque a considerar, si todos sus desarrolladores están acostumbrados a trabajar en una línea de comando UNIXish, es hacer que su generador de código escupe páginas de manual. Luego, un desarrollador puede usar el comando “man” para ver la documentación de la API para un punto final en particular. Pero probablemente también sea adecuado simplemente poner las especificaciones de cada punto final en un archivo separado con el mismo nombre que el punto final.

TL; DR: Genere su código a partir de su documentación, no al revés.

La solución que terminé usando es el proceso de validación de blobs JSON usando el esquema JSON ( http://json-schema.org/ ). Le permite definir explícitamente la estructura JSON (con mecanografía, campos obligatorios, alguna validación de formato de campo, etc.).
Ejemplo de esquema:

  {
 "title": "Esquema de ejemplo",
 "type": "objeto",
 "propiedades": {
     "firstName": {"type": "string"},
     "lastName": {"type": "string"},
     "años": {
         "descripción": "Edad en años",
         "type": "entero",
         "mínimo": 0
     }
 },
 "obligatorio": ["nombre", "apellido"]
 } 

Estoy usando json-schema-validator para validar los blobs que creo en Java y jsonschema 2.0.0 para validarlos en Python.

Lo único que me falta es la capacidad de generar estructuras / clases de Python / Java a partir del esquema.

¿Son sus funciones generalizaciones de algunos comportamientos comunes o todos bastante distintos? Si es lo primero, podría obtener la ayuda del código base generando información de formato.

De cualquier manera, probablemente debería tener pruebas unitarias para sus funciones (y su front-end) si aún no lo hace. No menos desagradable que lo que tiene actualmente, pero pueden servir como una mejor forma (verificable) de documentación que las cadenas de documentos. Un primer paso en esa dirección podría ser la conversión de sus cadenas de documentos al formato doctest.

Otra opción que podría ser relevante es una biblioteca API como tastypie, que proporciona información de esquema para los recursos como parte de su arquitectura. YMMV

Si usa javascript en el lado del servidor y del lado del cliente, considere usar TypeScript para crear interfaces para sus jsons (funciona bien para mí).

También puede hacerlo para un back-end de Django, pero deberá realizar la conversión de alguna manera (no demasiado difícil)

Otra buena manera es hacer una URL de esquema para cada modelo (json), y el código de front-end debería buscarlo primero y, de acuerdo con eso, seguir analizando el JSON real.