beautiful-dynamo-viewer: un explorador para single-table design en dynamodb

La consola de AWS no conoce tu modelo

Si has trabajado con single-table design en DynamoDB, conoces la escena: abres la consola y ves todo revuelto en la misma tabla (productos, usuarios, órdenes) detrás de claves opacas como ORDER#a1b2 / ORDER#ITEMS. Es justo lo que AWS recomienda para escalar (NoSQL Design for DynamoDB), pero para explorar el día a día es hostil: las claves no dicen nada y cada consulta te obliga a recordar y escribir las key conditions a mano.

La consola es genial para tablas simples. Para single-table design, no. De ahí nació beautiful-dynamo-viewer:

Y el fondo del asunto: en single-table design, el diseño de las claves es la documentación del sistema. Pero ese conocimiento vive disperso: en el código de acceso, en la cabeza de quien diseñó la tabla, en un diagrama desactualizado. La consola de AWS no lo captura en ninguna parte. Cada consulta es un acto de memoria.

Cómo funciona single-table

En DynamoDB cada ítem se identifica por partition key (PK), que define en qué partición vive, y sort key (SK), que define cómo se ordena dentro de ella (Core Components). El single-table design modela alrededor de tus patrones de acceso, no de entidades: metes todo en una tabla y lo distingues con claves compuestas y sobrecargadas.

PK = ORDER#<orderId>   SK = ORDER            ← metadata
PK = ORDER#<orderId>   SK = ORDER#ITEMS      ← ítems
PK = ORDER#<orderId>   SK = SHIPMENT#<fecha>#<n>
PK = ORDER#<orderId>   SK = HISTORY#<fecha>

Todos los ítems de una orden comparten PK: con una sola Query (Query API) traes metadata, ítems, envíos e historial, sin joins. Y cuando necesitas otro eje (“órdenes por usuario”, “productos por categoría”) entran los GSI (Secondary Indexes), donde cada entidad proyecta sus claves de forma distinta:

ORDER:    GSI1PK = USER#<userId>          GSI1SK = ORDER#<fecha>      ← órdenes por usuario
PRODUCT:  GSI1PK = CATEGORY#<categoria>   GSI1SK = PRODUCT#<nombre>   ← productos por categoría

Así se ve ese modelo en el sidebar de beautiful-dynamo-viewer: cada entidad (ORDER, PRODUCT, USER) con sus patrones de clave base y su proyección en cada GSI (GSI1 USER#, GSI2 ORDERS) a la vista.

Un detalle práctico del modelo: los ítems de una orden viven en un ítem separado (ORDER#ITEMS) del de la metadata, porque un ítem de DynamoDB no puede superar 400 KB (Best practices para ítems grandes). Partir los ítems aparte y agruparlos por la misma PK es lo que AWS llama vertical partitioning: se leen juntos con un único Query con SK BETWEEN 'ORDER' AND 'ORDER#ITEMS'. Ese tipo de decisión es tu aplicación, y beautiful-dynamo-viewer nace para capturar ese modelo una sola vez y volverlo consultable.

Cómo funciona la app: modela una vez, consulta llenando variables

La app, una aplicación de escritorio construida con Tauri + React y backend en Rust, gira en torno a un esquema que describe una tabla:

Schema                ← una tabla de DynamoDB, modelada
├── keys              ← atributos físicos de clave (PK / SK)
├── indexes           ← definiciones de GSI de la tabla
├── entities          ← tipos de registro, con sus patrones de clave e índice
└── queries           ← consultas guardadas

Modelas cada entidad una vez (su patrón de PK/SK y su proyección en cada GSI, con marcadores como ORDER#<orderId>) y desde ahí consultas llenando variables en lugar de escribir key conditions a mano. Eliges el índice, llenas la partition key, escoges la condición de sort key y la app traduce todo a la operación Query real contra tu tabla:

Sobre esa base:

• Consultas guardadas: marcas el estado del builder (índice, valores, condición de SK, filtros) como un bookmark reutilizable.
• Filtros estilo Postman: condiciones sobre atributos que no son clave, aplicadas como FilterExpression, que puedes activar/desactivar sin borrarlas.
• Perfiles de AWS y SSO: eliges un perfil e inicias sesión desde la barra superior; las queries corren contra tu tabla real.
• Import/export de esquemas: un esquema por archivo JSON, validado a fondo. El modelo se vuelve un artefacto versionable que puedes compartir con tu equipo.

Toda tu configuración se guarda localmente (en workspace.json, escrito de forma atómica en cada cambio); nada de tu modelo sale de tu máquina.

¿Cuándo la usarías? (operacional, no solo diseño)

Conviene ser claro sobre dónde encaja. AWS ya ofrece NoSQL Workbench, excelente para diseñar y modelar tu tabla antes de construirla. beautiful-dynamo-viewer apunta a un momento distinto: el día a día operacional sobre tablas que ya existen y ya tienen datos.

Es para cuando:

• Entra alguien nuevo al equipo y necesita entender el modelo sin leer todo el código de acceso.
• Estás depurando en producción y necesitas ver “todo lo que cae dentro de esta orden” sin escribir la Query a mano.
• Quieres guardar los 10 patrones de consulta que usas cada semana y reejecutarlos cambiando un valor.
• Quieres que el diseño de tu tabla sea un documento vivo, versionado y compartible.

En una frase: convierte el conocimiento tácito de tu single-table design en una herramienta explícita, consultable y compartible.

Instalación

Descarga el instalador para tu plataforma desde la última release: .deb / .rpm / .AppImage para Linux, .dmg para macOS y .msi / .exe para Windows.

Una salvedad: la app no está firmada con certificado de Apple ni de Microsoft (cuestan ~99 USD al año; es lo normal en software open source), así que macOS y Windows se quejan la primera vez que la abres:

• macOS: Gatekeeper bloquea la app por venir de un “desarrollador no identificado”. Quita la marca de cuarentena que macOS le pone a lo descargado:

  xattr -cr /Applications/beautiful-dynamo-viewer.app

• Windows: si SmartScreen muestra “Windows protegió su PC”, haz clic en Más información y luego en Ejecutar de todas formas.

• Linux: sin fricción; instala el .deb / .rpm, o dale permiso de ejecución al .AppImage.

TL;DR

• Qué es: beautiful-dynamo-viewer, una app de escritorio (Tauri + React + Rust) para explorar y consultar tablas de DynamoDB con single-table design.
• El problema: en single-table design las claves son opacas y cada consulta te obliga a escribir key conditions a mano; la consola de AWS no captura el modelo.
• La idea: modelas la tabla una vez (entidades, patrones de PK/SK e índices) y desde ahí consultas llenando variables.
• Dónde encaja: NoSQL Workbench es para diseñar; beautiful-dynamo-viewer es para el día a día operacional sobre tablas que ya existen.
• Estado: open source (MIT), con instaladores para Linux, macOS y Windows en la última release. Pruébalo y dime qué patrón de acceso tuyo aún no logra expresar.

Repositorio: github.com/devcastech/beautiful-dynamo-viewer · Descargas: releases/latest