1. Introducción a Neo4j y suscripciones de GraphQL
Soy Thomas Wiese, un ingeniero de software en Neo4j en el equipo de GraphQL. Hoy hablaré sobre las actualizaciones de datos en tiempo real para Neo4j utilizando suscripciones de GraphQL. Neo4j es una base de datos altamente escalable sin un esquema, basada en nodos y relaciones que forman un grafo. El lenguaje de consulta para Neo4j se llama Cipher, que es fácil de aprender y tiene poderosas capacidades de coincidencia de patrones de gráficos. Hemos construido una biblioteca de código abierto en TypeScript que integra Neo4j y GraphQL, lo que permite a los clientes enviar consultas que se traducen a Cypher y se manejan automáticamente en segundo plano.
Hola a todos, soy Thomas Wiese, soy un ingeniero de software en Neo4j en el equipo de GraphQL. Y hoy hablaré sobre las actualizaciones de datos en tiempo real para Neo4j utilizando suscripciones de GraphQL.
Lo primero es lo primero, tenemos que hablar sobre la base de datos que usamos, y es Neo4j. Y Neo4j también es una empresa, pero principalmente conocida por su base de datos, una base de datos que en realidad puede escalar mucho y no tiene ningún esquema. Todo lo que necesitas son nodos y relaciones que forman un grafo. Como puedes ver aquí, un grafo de películas con relaciones y nodos. Y los nodos son las burbujas y las relaciones son las flechas. Y lo más importante aquí es que tanto los nodos como las relaciones pueden contener propiedades. Así que son ciudadanos de primera clase.
Y por supuesto, si tenemos una base de datos, necesitamos una forma de consultar esa base de datos o un lenguaje de consulta. Y eso es lo que Neo4j también construyó. Se llama Cipher. Y Cipher obtuvo mucha inspiración de SQL. Pero agregó algunas cosas más porque tenemos que consultar gráficos. Así que tenemos que hacer cosas como coincidencia de patrones de gráficos. Y un ejemplo, un ejemplo simple aquí en la fila superior donde puedes ver una coincidencia donde coincidimos con una persona que actuó en una película. Y tenemos las flechas que indican una relación. Y de esta manera, podemos leerlo de manera bastante intuitiva. Y créeme, lo creas o no, es muy fácil de aprender. Y tiene mucho del poder que ya tiene SQL incorporado aquí. Entonces, las cláusulas WHERE coinciden, etcétera, etcétera. Y llamamos a esto ASCII o casi arte ASCII, lo que hacemos aquí. Así que ahora tenemos una base de datos, una base de datos realmente increíble. Y por supuesto, el tema de esta conferencia, GrowthQL. ¿Y no sería genial si pudiéramos juntar esas dos cosas, verdad? ¿Podríamos hacer algo como esto aquí? Sí, por supuesto, podemos hacer eso. De hecho, ya lo construimos para ti. Y comenzamos hace dos años a construir una biblioteca de código abierto escrita en TypeScript para tu comodidad y el centro de atención de la biblioteca, como puedes ver aquí en la imagen. Proporciona una API o es la base para una API de GrowthQL, donde los clientes de GrowthQL pueden enviar sus consultas de GrowthQL a la API. Luego, la biblioteca traduce en tiempo real esta consulta a una consulta de Cypher y la envía a la base de datos y la respuesta vuelve a la API y luego al cliente. Y todo esto se maneja en segundo plano.
2. Generación automática de esquemas
Aquí no tienes que hacer nada, ¿verdad? Necesitamos una API, ¿verdad? Tenemos que definir la API de alguna manera. Por lo general, crearías tus tipos, escribirías consultas de lectura, mutaciones y resolutores. Pero eso es doloroso. Quiero generación automática de esquemas.
La generación de esquemas se hace automáticamente en segundo plano. Aquí no tienes que hacer nada, ¿verdad? Pero necesitamos una API, ¿verdad? Tenemos que definir la API de alguna manera. Y por lo general, seguirías esto o algo similar, ¿verdad? Crearías tus tipos, tu tipo de película aquí con un campo de título. Y luego tendrías que hacer todas estas cosas engorrosas aquí. Tendrías que escribir consultas de lectura. Tendrías que escribir todas estas mutaciones. Agregar, cambiar, eliminar, etcétera, etcétera. Incluso tendrías que escribir los resolutores para todo eso. Quiero decir, ¿qué tan doloroso es eso? De ninguna manera. No voy a hacer eso.
3. Generación automática y traducción de consultas GraphQL
Quiero generación automática de esquemas, ¿verdad? Eso es exactamente lo que hicimos con la biblioteca Neo4j GraphQL. Solo necesitas definir tus tipos y la biblioteca se encargará del resto. Proporciona consultas de lectura, agregados, conexiones como la conexión de relay e incluso paginación basada en cursor. La mejor parte es que los resolutores ya están escritos y las mutaciones también están incluidas. Veamos cómo funciona con una consulta de ejemplo para obtener películas lanzadas en 1999 y sus actores.
Quiero generación automática de esquemas, ¿verdad? Quiero decir, tú haces el trabajo básico, yo hago la generación automática de esquemas. Y eso es exactamente lo que hicimos con la biblioteca Neo4j GraphQL. Así que lo único que tienes que proporcionar para que tu API de GraphQL esté lista para ser utilizada es definir tus tipos o las definiciones de tipo, aquí tienes un ejemplo muy simple para comenzar. Una película con un título, eso es todo lo que necesitas. Y luego la biblioteca en segundo plano lo creará por ti. Obtendrás las consultas de lectura listas para usar. No has hecho nada, pero todo está disponible para ti. Así que puedes hacer lecturas de películas, filtrar, por ejemplo. Ya tenemos agregados listos para ti, nuevamente con filtrado incorporado. Tenemos conexiones, como la conexión de relay, la especificación está implementada aquí. Y puedes hacer cosas geniales como paginación basada en cursor, todo eso listo para usar.
¿Y sabes cuál es la mejor parte? Los resolutores ya están escritos. Ni siquiera tienes que escribir eso también. Y mejora aún más. Wow. Las mutaciones también están incluidas. Puedes crear, eliminar, actualizar películas, todas esas cosas agradables. Nuevamente, el filtrado donde lo necesites ya está incluido. Y nuevamente, los resolutores ya están integrados. No tienes que hacer nada. Pero eso es bastante interesante. Así que veamos cómo funciona todo esto a nivel de consulta. Algo con lo que estás familiarizado para comenzar. Tenemos una consulta de GraphQL donde queremos obtener todas las películas que se lanzaron en 1999. Queremos obtener el título y el nombre de todos los actores que participaron en ella. Hasta ahora, todo bien. La biblioteca Neo4j GraphQL, lo siento, la biblioteca GraphQL, automáticamente traducirá esto cuando vea esta solicitud de GraphQL a esta consulta Cypher. Y te lo explicaré rápidamente.
4. Suscripciones de GraphQL y Biblioteca Neo4j GraphQL
Una consulta de GraphQL coincide con una consulta Cypher. El problema N más uno no existe. Utilizamos WebSockets para actualizaciones de datos en tiempo real. La biblioteca Neo4j GraphQL maneja las suscripciones. Es completamente agnóstica y se puede construir sobre ella. Vamos a ver el código y definir las definiciones de tipo.
Así que en la parte superior, coincidimos con todas las películas. Luego obtenemos o filtramos solo las películas con una fecha de lanzamiento específica, en este caso 1999. Y luego en esta subconsulta, entre corchetes, lo que hacemos es realizar un recorrido de relaciones desde el actor o la película hasta el actor. Y obtenemos todos los nombres para ello. Y luego lo empaquetamos todo, todos los nombres de los actores y todo en una forma que el cliente de
GraphQL puede consumir o que realmente espera. ¿Sabes cuál es la mejor parte de esto? Una consulta de
GraphQL coincide con una consulta Cypher. ¿Ves lo que falta? El problema N más uno, simplemente no existe. Nos ocupamos de eso. No tienes ese problema. Necesitamos un recurso de consulta en una llamada a la base de datos y ya está. ¿No es genial? Ahora que conoces todos los conceptos básicos, pasemos a las cosas interesantes, las suscripciones. Solo a un nivel muy alto, ¿qué son las suscripciones de
GraphQL? Participan dos entidades, el cliente y el servidor, donde el cliente se suscribe en el servidor para un evento en particular, y al hacerlo, abre una conexión permanente. En la especificación de
GraphQL, no hay una definición clara de cuál es el protocolo, como en la capa de transporte, cuál es el protocolo que se supone que debe ser aquí. En realidad, depende del servidor. Lo que hemos visto es que la mayoría utiliza WebSockets o el protocolo WebSocket para hacer precisamente eso y en la demostración que voy a mostrar en un momento, hacemos exactamente eso. Utilizamos WebSockets. Una vez que se establece la conexión, el servidor tiene la posibilidad de enviar o enviar eventos al cliente sin que el cliente tenga que hacer nada, ¿verdad? Sin ocuparse de la espera ocupada, nada de eso, y podemos enviar tantos eventos como queramos, lo cual es bastante genial. Así que tenemos nuestras actualizaciones de datos en tiempo real. Exactamente lo que prometía el título. Vamos un nivel más profundo y veamos cómo se implementa utilizando la biblioteca Neo4j
GraphQL, donde la biblioteca es la instancia en el centro y habrá un par de imágenes más de esas, así que siempre será la misma, la instancia en el centro. Entonces, en esta configuración aquí tenemos un cliente en el lado derecho que se suscribió a un evento y luego otro cliente, el de la izquierda, envió una mutación. Piensa en crear una película, ¿verdad? Envió una mutación, se traduce a una consulta, sobre la marcha, en la biblioteca gráfica de Neo4j. Se ejecuta contra la base de datos y luego vuelve a la biblioteca gráfica de Neo4j, que luego informa a todos los clientes suscritos que ocurrió este evento, ¿verdad? Hasta este punto, bastante sencillo. Hay una cosa que debemos tener en cuenta aquí, si alguien hiciera un cambio en la base de datos de Neo4j allí en la parte inferior de la imagen desde el exterior, sin usar la API gráfica de Neo4j, no lo detectaríamos. Esa es una limitación en este momento, somos conscientes de ello, pero estamos trabajando en ello, así que mantente atento. Es posible que se solucione en el futuro cercano. La otra cosa es que esto es completamente agnóstico, no hay absolutamente nada que te impida construir sobre esto. Pero creo que ahora te he dado suficiente contexto para ver todo esto en acción. Puedes ver esta demo o el código de la demo más tarde de mi colega Andrés, él construyó estas increíbles demostraciones, no solo la que te muestro ahora, sino varias de ellas. Pero vamos a echar un vistazo, así que vamos al código y veamos algo de código. Como viste antes, lo primero que tenemos que hacer es definir las definiciones de tipo.
5. Definiciones de Tipos y Relaciones
Definimos dos tipos, película y persona, y especificamos sus campos. Utilizamos una directiva de relación para formar la relación entre la película y la persona, especificando el tipo de relación, dirección y propiedades. Las relaciones en Neo4j pueden contener datos, y lo especificamos en GraphQL agregando una interfaz y proporcionando roles para la película.
Y vamos a utilizar una definición de tipo un poco más grande que solo el tipo película. Lo primero que hacemos es definir dos tipos, tipo película y tipo persona, y darles algunos campos, como especificamos aquí. Y luego ves una relación o una directiva que no has visto antes, que se llama relación. Y eso es exactamente lo que hace. Forma o especifica la relación entre la película y la persona. En la directiva, podemos especificar qué tipo de relación es, actuó en este caso, la dirección y las propiedades. Porque recuerda, en Neo4j, las relaciones, son ciudadanos de primera clase, pueden contener datos. Y así es como lo especificamos en GraphQL. Especificamos una interfaz. Y luego podemos agregar cualquier dato que queramos aquí, que proporciona algunos roles, porque tienes que tener un rol en una película, ¿verdad? Como persona.
6. Código del Servidor y Suscripciones
Echemos un vistazo breve al código del servidor. La suscripción es un complemento que puede ser desarrollado por la comunidad. Para la demostración, utilizamos emisores de eventos de Node.js. Define un complemento, obtén tus definiciones de tipo, crea un controlador de Neo4j, pásalos a la clase Neo4j GraphQL e incluye el complemento. Luego configura el servidor con un servidor express y un servidor WebSocket. Crea un esquema con resolvers y pásalo a un servidor Apollo. Los tipos raíz incluyen consulta y mutación, pero estamos interesados en las suscripciones.
Eso forma nuestra base. Así que echemos un vistazo breve al código del servidor, porque eso puede ser bastante interesante para mucha gente también. Y lo primero que hay que tener en cuenta aquí es que la suscripción es un complemento. Así que permitimos que las personas desarrollen su propio complemento. Si la
community, alguien en la
community, tal vez quieras desarrollar tu propio complemento, eres libre de hacerlo. Ya hemos proporcionado un montón de ellos para ti, pero más sobre eso más adelante. Para la demostración, utilizamos algo muy sencillo. Utilizamos emisores de eventos de
Node.js para hacerlo de manera rápida y sencilla para esta demostración. Así que defines un complemento, tenemos algunos para ti, así que no necesitas escribirlos tú mismo. Pero aquí, esto es una demostración, quiero señalar un par de cosas. Luego lo que tienes que hacer es obtener tus definiciones de tipo, por supuesto. Tienes que crear un controlador, un controlador de Neo4j, para acceder a tu
database. Ya lo inicié en segundo plano para la demostración, así que está todo funcionando. No te preocupes aquí. Luego, como primer punto importante, tenemos que pasar eso a la clase Neo4j
GraphQL, que luego instanciamos más adelante. Y también incluir el complemento para asegurarnos de que el API de
GraphQL, o la instancia de
GraphQL de Neo4j que se está ejecutando, muestre que las suscripciones están activas, estamos aquí. Y luego tenemos que configurar todo el servidor. Tenemos que obtener un servidor express, un servidor WebSocket encima de eso. Solo estoy omitiendo algunos detalles, que puedes revisar a tu conveniencia. No están realmente añadiendo a la demostración en este momento, pero no es realmente difícil. No te preocupes. Luego tenemos que crear un esquema que incluya todos los resolvers. Y simplemente pasamos ese esquema a un servidor
Apollo, porque es una forma conveniente de hacerlo, usar
Apollo. Luego podemos iniciarlo. Ya lo hice. Así que no estamos perdiendo tiempo valioso.
Así que si nos dirigimos al código, lo primero que probablemente notarás es aquí, los tipos raíz. Mencioné eso antes. Tenemos consulta y mutación donde el contenido generado automáticamente está listo, crear, actualizar. Pero no estamos interesados en eso ahora mismo. Queremos echar un vistazo a las suscripciones, ¿verdad? Así que las suscripciones vienen con mucho de esto generado automáticamente
7. Soporte Incorporado para Eventos y Relaciones
Tenemos soporte incorporado para crear, eliminar y actualizar películas y personas. También tenemos soporte incorporado para relaciones. Por ejemplo, si creas una conexión entre una película y un actor, se maneja automáticamente. Comencemos con un caso simple: crear una suscripción para un evento de creación de película. Podemos especificar qué información queremos recibir del evento. Luego, creamos una película usando una mutación y recibimos el evento de suscripción junto con la respuesta regular de la mutación. Podemos ver los detalles del evento y los datos de la película. El mismo concepto se aplica a los eventos de relaciones, donde podemos ver los detalles del evento, la película y el actor involucrados, y los roles del actor.
Tenemos funcionalidades incorporadas para ti. Por ejemplo, tenemos eventos de creación, eliminación y actualización de películas y personas. Lo mismo para una persona. Y nuevamente, tenemos cláusulas WHERE o filtrado ya incorporado para ti. Lo mismo también lo tenemos para las relaciones, ¿verdad? Porque son ciudadanos de primera clase. Entonces, si creas una película y luego una conexión con un actor, esto está incorporado para ti. Simplemente puedes usarlo. Y eso es lo que vamos a hacer ahora. Pero comencemos con un caso simple, para que todos lo entendamos fácilmente. Podemos crear una suscripción, una película creada con un evento y una marca de tiempo. Y luego queremos saber qué información exactamente queremos recibir de ese evento en particular que recibimos de la película. Entonces, lo que ha sido. Y esto es solo
GraphQL estándar, así que puedo agregar lo que quiera aquí. Y sé que hay un eslogan. Así que lo agregaré. Luego presiono suscribir. Y veo que está escuchando. ¿Qué tenemos que hacer ahora? Crear una película, ¿verdad? Hagámoslo. Así que creamos una película. Y tenemos una mutación para crear una película llamada `Story of Toys`. Y si la ejecutamos, vemos que ya tenemos una suscripción activa. Pero también tenemos la respuesta regular de la mutación que regresa. Y aquí tenemos eventos de suscripción como crear. Vimos el evento que es crear, la marca de tiempo y la película en exactamente la forma que solicitamos. Y esto es una suscripción, ¿verdad? Queremos ver múltiples de esas. Mira también eso. Y, por supuesto, si agrego otra, todo vendrá en un flujo natural. Y no tuve que hacer nada, ¿verdad? Excepto escucharlo. Entonces, detengamos este ejemplo y pasemos al de relaciones. Entonces, si hay un evento de creación de relación de película, hacemos lo mismo nuevamente. Queremos ver qué evento es, el nombre del campo, luego qué película se creó, qué nodo de actor se creó.
8. Actualizaciones de Datos en Tiempo Real y Más Detalles
Vamos a suscribirnos y crear una película y un actor. Es sorprendente lo rápido que funciona. Podemos ver la película y el actor creados y conectados en tiempo real. Eso concluye nuestra demostración, y ahora pasemos a más detalles.
o qué actor, y los roles que ese actor tenía. Y nuevamente, aquí podemos hacer lo que
GraphQL nos ofrece en este punto. Vamos a suscribirnos. Nuevamente, está escuchando. Es sorprendente. Y ahora vamos a crear una película y un actor, ¿verdad? Entonces, creamos 'gum forest' con un actor llamado Kevin Bacon. Y aparentemente él era un corredor en esa película. Tenemos que ver eso, ¿verdad? Así que, vamos a guardarlo. Y nuevamente, está aquí, ¿verdad? Tenemos 'connect' como un tipo de evento de relación el campo 'gum forest' está aquí. Y por supuesto, si simplemente creo otro Kevin Bacon, E, mira eso, él también está aquí. Así que todo funciona de manera automática. Y es extremadamente rápido, como puedes ver, ya está aquí. Eso concluye nuestra parte de demostración. Y voy a mostrarte algunos detalles más en el fondo. Así que, vamos
9. Suscripciones y Escalabilidad con Neo4j GraphQL
Si creas una película con una consulta GraphQL, la biblioteca de Neo4j generará la consulta cipher por ti. Cuando las suscripciones están habilitadas, se agrega información adicional a la consulta cipher para mantener la consistencia de los datos. La escalabilidad se maneja enviando eventos a un intermediario, que los transmite a todas las instancias en ejecución. Hemos creado un complemento que simplifica la implementación y configuración.
volvamos a las diapositivas. Y ahora están cargadas. Entonces, antes de... Entonces, si no tienes la suscripción activada, solo
GraphQL regular, hace las consultas. Si creas una película en el lado izquierdo con una consulta
GraphQL, la biblioteca de Neo4j creará esta consulta cipher por ti. Así que, una llamada a subconsulta nuevamente entre corchetes, crea la película, agrega el título o establece el título y lo devuelve de una manera que un cliente
GraphQL pueda entender. Pero luego, como antes en la demostración, si activamos las suscripciones, tenemos que agregar algunos datos adicionales. Lo bueno es... Y así es como se supone que debe ser. La mutación en el lado izquierdo para la consulta
GraphQL no cambió en absoluto. Pero tenemos que agregar información adicional a la consulta cipher, que es este metadato aquí con un evento para crear. Como hemos visto antes, el nombre del tipo, la marca de tiempo, todas las cosas que has visto en acción antes, las agregamos a la consulta cipher. Porque luego, en la parte inferior, ves que en la declaración de retorno, lo devolvemos después de que ha impactado en la base de datos. ¿Por qué hacemos eso? Esto significa que podemos mantener la consistencia en la base de datos sin cambiar nada en realidad. Tenemos una mutación que cambia la base de datos, pero luego podemos tener una multitud de suscriptores en el otro extremo que están consumiendo este evento. Entonces, tenemos una consistencia absoluta de datos en la base de datos, y podemos suscribirnos o enviar el evento a tantos suscriptores como sea posible o como estén suscritos sin tener un impacto en los datos o la base de datos. Pero ese es realmente el punto. ¿Funcionará con tantos miles de suscriptores? ¿No necesitamos escalar horizontalmente todo eso? En este caso, tu biblioteca de
GraphQL en algún momento, no puede manejar todo. Entonces, tenemos que escalar horizontalmente. Lo que significa que terminaremos con situaciones como esta aquí, donde un cliente se suscribe a una instancia donde ni siquiera ocurrió la mutación en el lado izquierdo. ¿No hay un enlace increíble aquí? Quiero decir, ¿cómo funciona esto? Pero obviamente, ten la seguridad, de lo contrario no hablaría de ello. Esto está solucionado. Ya hemos construido todo eso para ti. Así que esto funcionará, lo que significa que tu caso de uso se escalará. Tanto tu base de datos de Neo4j como tu API de Neo4j
GraphQL se escalarán con tu caso de uso. Y hacemos eso, como puedes ver aquí, después de hacer la mutación, la consulta Cypher y volver a la biblioteca
GraphQL, enviaremos un evento allí, número tres, a un intermediario, que puede ser Kafka, Redis o RabbitMQ. Y ese intermediario luego, a su vez, transmitirá o distribuirá el evento a todas las instancias en ejecución. Y esas luego enviarán el evento a sus suscriptores. Entonces, la escalabilidad está resuelta, ¿verdad? Y ahora puedes decir, bueno, Thomas, genial, es una buena promesa, pero esto debe ser muy difícil de implementar y configurar y todo eso. En realidad no, es súper fácil. Mira eso. ¿Recuerdas el sistema de complementos de antes? Bueno,
10. Suscripciones AMQP y Neo Place
Las suscripciones AMQP te permiten definir fácilmente los detalles de conexión y las credenciales de tu intermediario AMQP. Actualmente en versión beta, pronto estará disponible de forma general. Hemos creado neo place, inspirado en rplace de Reddit, para mostrar nuestras suscripciones GraphQL. Construido con las bases de datos Neo4j y Oracle, un intermediario y nuestra biblioteca Neo4j GraphQL, neo place ofrece actualizaciones en tiempo real. Visita la biblioteca de código abierto en GitHub y únete a nuestra comunidad en Discord. ¡Gracias por tu apoyo!
ya hemos creado un complemento para manejar exactamente ese caso. Se llama Suscripciones AMQP, y todo lo que tienes que hacer es definir los detalles de conexión y las credenciales de tu intermediario AMQP. Y sí, lo siento, aún tienes que configurar eso. Hay muchas formas de hacerlo. Así que solo tienes que proporcionarnos las credenciales o el complemento de nosotros. Y pasas ese complemento a la instancia o clase de Neo4j
GraphQL como lo hiciste antes y como viste en la demostración. Y listo, eso es todo lo que necesitas hacer. Actualmente, las suscripciones aún están en versión beta, pero pronto estarán disponibles de forma general y podrás comenzar con esto. Pero para terminar, quiero hablar de algo realmente genial. Esto es algo que quizás hayas visto antes. Sucedió en Reddit y fue en 2017 el Día de los Santos Inocentes. Es rplace y esto permitía a los usuarios establecer un píxel o un color. Luego tenían que esperar 15 minutos y establecer otro píxel, y así sucesivamente para muchos usuarios. Hemos creado esta increíble obra de arte de la comunidad y pensamos que esto es lo más genial para mostrar o exhibir nuestras suscripciones
GraphQL. Y eso es exactamente lo que hicimos, creamos neo place para ti. Puedes acceder a él ahora mismo a través de este enlace, bajo este enlace de bit.ly o el código QR aquí visible. Y tomamos las mismas ideas pero las construimos con las cosas que acabo de resaltar antes con la base de datos Neo4j en la nube y la base de datos Oracle. Y usamos un intermediario para lograr la escalabilidad horizontal y Breeze. Por supuesto, utilizamos nuestra biblioteca Neo4j
GraphQL y la API
GraphQL. Y, por supuesto, las suscripciones
GraphQL para una actualización en tiempo real cuando las personas establecen los píxeles también. Así que ve allí, pruébalo y diviértete, dibuja algo increíble, y disfruta del poder de
GraphQL, las suscripciones
GraphQL y Neo4j. Y eso es todo lo que tengo para ti hoy. Puedes dirigirte a la biblioteca de código abierto en GitHub. Puedes ver aquí en el enlace dónde puedes encontrarnos. Tenemos todos los complementos allí, muchas cosas para tener en cuenta. Código abierto para ti, disponible todo el tiempo. Y esta también es una gran oportunidad para agradecer a nuestra comunidad. Siempre puedes comunicarte con nosotros en Discord a través de este enlace. Realmente hemos tenido mucho tiempo e
inspiration de nuestra
community y nos ayudaron a construir el producto que está aquí ahora. Y si no te tuviéramos como comunidad, no estaríamos aquí ahora mismo presentando este maravilloso producto. Así que muchas gracias y nos vemos la próxima vez. ¡Adiós!
GraphQL Galaxy 2021
Comments