[tidy-go-common] - Protobuf como SSOT en Go: Estandarizando Tipos Compartidos en un Ecosistema Modular

Introducción

tidy-go-common es un proyecto diseñado para proporcionar tipos y funciones globales reutilizables en Go, asegurando que múltiples aplicaciones dentro del ecosistema puedan compartir estructuras de datos consistentes. Para garantizar coherencia y sincronización, se ha establecido Protocol Buffers (Protobuf) como la fuente única de verdad (SSOT) para definir estos tipos de datos.

La arquitectura de este ecosistema se basa en la separación de responsabilidades entre distintos proyectos:

• tidy-proto-common: Contiene las definiciones .proto centrales, utilizadas como base común para generar tipos en Go y TypeScript.

• tidy-go-common: Consume tidy-proto-common para generar tipos en Go (types.pb.go), los cuales son utilizados por múltiples aplicaciones en Go.

• tidy-ts-common: Consume tidy-proto-common para generar los equivalentes en TypeScript, utilizados por los frontends.

• proto-business-app1: Define estructuras .proto específicas para business-app1.

• go-business-app1: Backend en Go para business-app1, que genera sus propios tipos a partir de proto-business-app1.

• ts-business-app1: Frontend en TypeScript que genera sus tipos desde proto-business-app1.

• Otros proyectos (business-appN): Siguen el mismo esquema, generando sus estructuras en Go y TypeScript a partir de sus propios .proto.

De este modo, tidy-go-common y cada business-appN generan sus propios archivos .pb.go, mientras que tidy-proto-common y proto-business-appN quedan disponibles para ser utilizados tanto por Go como por TypeScript.

Justificación del Uso de Protobuf

1. Unificación de Tipos: Los .proto en tidy-proto-common y proto-business-appN aseguran que los modelos en Go y TypeScript sean consistentes y sin duplicaciones.

2. Sincronización Garantizada: Tanto tidy-go-common como go-business-appN generan sus tipos a partir de archivos .proto, asegurando estructuras idénticas en todas las aplicaciones.

3. Automatización del Mantenimiento: Las modificaciones en un .proto se propagan automáticamente a los modelos generados en Go y TypeScript sin necesidad de ajustes manuales.

4. Interoperabilidad Multilenguaje: Protobuf permite generar código para múltiples lenguajes sin reescribir estructuras manualmente.

Implementación en tidy-go-common

La estructura de tidy-go-common refleja su función como repositorio de tipos compartidos en Go. A diferencia de otros proyectos, tidy-go-common no contiene archivos .proto propios, sino que consume los de tidy-proto-common:

tidy-go-common/
 ├── types/                 # Tipos generados para Go
 │    ├── types.pb.go
 │    ├── pagination.pb.go
 │    ├── queryparams.pb.go
 ├── codegen/               # Generadores
 ├── go.mod
 ├── README.md

1. Consumo de tidy-proto-common como SSOT: tidy-go-common no define .proto, sino que genera sus tipos en Go (.pb.go) a partir de tidy-proto-common.

2. Generación Automática de Código en Go: Se utiliza protoc para convertir los .proto de tidy-proto-common en archivos .pb.go, evitando errores manuales en la definición de estructuras.

3. Paquete types/: Los archivos generados se agrupan en types/, permitiendo importaciones claras y concisas dentro de los proyectos Go:

    import "github.com/mi-org/tidy-go-common/types"
   
    var p types.Pagination = types.Pagination{Page: 1, Limit: 10}
   

4. Generación Independiente para Frontend: Los frontends generan sus propios tipos en TypeScript directamente desde tidy-proto-common y proto-business-appN, sin depender de tidy-go-common.

5. Facilitación del Consumo en Backend: Los servicios de negocio (go-business-appN) generan sus propios archivos .pb.go desde proto-business-appN, permitiendo una estructura modular sin dependencias innecesarias entre proyectos.

Beneficios Esperados

• Menos errores en la comunicación entre sistemas.

• Desarrollo más eficiente al evitar definiciones manuales de tipos.

• Escalabilidad hacia nuevos lenguajes sin modificar la lógica existente.

• Mantenimiento más simple con un único punto de actualización en tidy-proto-common y proto-business-appN.

Conclusión

El uso de Protobuf como SSOT en tidy-go-common permite mantener tipos reutilizables en Go, garantizando coherencia en todo el ecosistema. Al separar tidy-proto-common de las implementaciones de negocio (proto-business-appN), se logra una estructura flexible donde cada equipo puede generar sus modelos sin acoplamientos innecesarios.

Este esquema facilita la expansión de la arquitectura, permitiendo que tanto nuevos proyectos de backend como de frontend consuman los mismos tipos de manera eficiente y sincronizada, asegurando una integración robusta sin redundancias innecesarias.