Construyendo APIs GraphQL con la biblioteca Neo4j GraphQL y Neo4j AuraDB

Así que solo un poco sobre mí. Mi nombre es Will. Trabajo para una compañía de bases de datos llamada Neo4j. Neo4j es una base de datos de gráficos de código abierto. Hablaremos sobre lo que eso significa y haremos algunos ejercicios prácticos con Neo4j mientras construimos nuestra API de GraphQL. Trabajo en el equipo de relaciones con desarrolladores en Neo4j, lo que significa ayudar a las personas a construir aplicaciones con gráficos y Neo4j. También trabajo en herramientas de integración, asegurándome de que puedas usar Neo4j con diferentes herramientas en el ecosistema. GraphQL es una de ellas. También escribí recientemente un libro publicado por Manning llamado Aplicaciones de pila completa con GraphQL, que puedes descargar de forma gratuita. Este enlace dev.neo4j.com/graphql-book.

Lo que vamos a hablar hoy se centra principalmente en la parte del backend de una aplicación de pila completa, ¿verdad? Trabajaremos con la base de datos. Construiremos un servidor GraphQL y utilizaremos algunos servicios en la nube para alojarlo en la nube. Pero no hablaremos de cómo integrar GraphQL en nuestra aplicación frontend. El libro profundiza mucho más en ese tema.

Entonces, el esquema general para hoy. Tenemos algunos módulos diferentes en los que trabajaremos, así que tendré una combinación de diapositivas y ejemplos. Y luego tendremos al menos uno o dos ejercicios prácticos para cada uno de estos módulos que vamos a hacer. Comenzaremos con lo que creo que para algunas personas será un repaso de una introducción a GraphQL, pero solo para asegurarnos de que todos estemos más o menos en la misma página. Empezaremos aquí. Luego echaremos un vistazo a Neo4j. Utilizaremos una base de datos alojada como servicio llamada Neo4j Aura. Hay un nivel gratuito. Podemos hacer clic en un par de botones y configurar uno. Esa será nuestra base de datos para hoy. Luego veremos cómo usar la biblioteca Neo4j GraphQL, que es una integración de base de datos para GraphQL y Neo4j que facilita la construcción de APIs de GraphQL respaldadas por Neo4j. Veremos algunas formas diferentes de comenzar a usar la biblioteca Neo4j GraphQL. Veremos cómo agregar lógica personalizada a nuestra API de GraphQL utilizando el lenguaje de consulta Cypher. Cypher es el lenguaje de consulta de la base de datos que usamos con Neo4j. Pero hay una forma muy interesante de combinarlo con GraphQL para agregar lógica personalizada. Y luego, si tenemos tiempo, lo cual no estoy seguro de si llegaremos a esto, al menos hablaremos de cómo agregar autorización a nuestra API de GraphQL utilizando algunas de las características de la biblioteca grew up para definir reglas de autorización en el esquema de GraphQL y tokens web JSON.

No tienes que preocuparte por configurar un entorno de desarrollo local o clonar un repositorio de GitHub ni nada por el estilo. Solo vamos a utilizar servicios alojados. Mencioné que estamos usando Neo4j Aura DB, el nivel gratuito de eso. Vamos a utilizar una herramienta llamada Neo4j GraphQL Sandbox, que es una especie de herramienta en el navegador para trabajar con GraphQL y Neo4j. Y luego vamos a usar CodeSandbox para ejecutar algo de código JavaScript. Tenemos una serie de enlaces a diapositivas y varios recursos, documentación. Pero hablaré de ellos a medida que los vayamos viendo. Genial.

Entonces hablemos un poco sobre Neo4j. Creo que algunas personas dijeron que no están familiarizadas con Neo4j. Neo4j es una base de datos de gráficos. A diferencia de otras bases de datos que utilizan tablas o documentos como modelo de datos, Neo4j y otras bases de datos de gráficos utilizan lo que se llama el modelo de datos de gráficos de propiedades. Un gráfico, entidades, esos son nodos y relaciones que conectan nodos. Ese es el modelo de datos básico con el que trabajamos en una base de datos de gráficos como Neo4j. Utilizamos principalmente el lenguaje de consulta Cypher para trabajar con Neo4j. Hay otras formas de interactuar con la base de datos, que veremos hoy. Principalmente, puedes pensar en Cypher como algo similar a SQL, pero para gráficos. Aquí hay un ejemplo en la parte superior derecha que habla sobre direcciones. Algo en Nueva York, dirección registrada, conectada a oficiales y entidades. Y hay un patrón de gráfico de arte ASCII dibujado aquí.

Entonces, ¿de qué se trata esto? Bueno, la coincidencia de patrones de gráficos es una parte fundamental de Cypher. La forma en que definimos los patrones en Cypher es utilizando esta representación de arte ASCII. Los paréntesis, primero alrededor de la dirección, indican un nodo, por lo que estamos buscando nodos de dirección donde la dirección contiene Nueva York. Luego, esta flecha que hemos dibujado aquí con la dirección registrada representa una relación conectada a nodos de oficiales. Y luego tenemos la notación abreviada para una relación saliente ahora hacia estos nodos de entidad. Esto significa encontrar direcciones en Nueva York, encontrar nodos de oficiales conectados a esas direcciones a través de esta relación de dirección registrada. Y luego encontrar cualquier entidad conectada a esos oficiales con una dirección en Nueva York. He utilizado esta consulta como ejemplo porque proviene del conjunto de datos de los Papeles de Panamá, que fue una investigación periodística de datos hace unos años, donde los periodistas de datos en el ICIJ utilizaron Neo4j para dar sentido a estos documentos filtrados sobre empresas offshore, porque era un problema muy gráfico con estructuras anidadas de empresas offshore y cosas así. Hablaremos un poco más sobre Cypher después de adentrarnos un poco en GraphQL.

En esta diapositiva, se muestra claramente que hay un espectro de casos de uso para gráficos en Neo4j. Me gustaría mostrar que hay un gran ecosistema de herramientas, ¿verdad? Como base de datos, nos encontramos en el centro de la infraestructura y la arquitectura para muchos casos de uso y usuarios, y hay un espectro a la izquierda para el desarrollo de aplicaciones y a la derecha para el análisis. Cosas como ciencia de datos de gráficos, algoritmos de gráficos, esas cosas. Y dependiendo de dónde nos encontremos en ese espectro, lo que estás tratando de lograr, cuáles son tus casos de uso, las herramientas en el ecosistema con las que estás integrando son un poco diferentes. Para cosas como análisis y ciencia de datos, es posible que estemos más interesados en integrarnos con algunas herramientas de visualización, algunas tuberías de aprendizaje automático, cosas así. En el extremo izquierdo del espectro, donde hablamos de desarrollo de aplicaciones, construcción de APIs para casos de uso transaccionales, esas cosas, es más donde estamos hoy hablando de construir una API de GraphQL para nuestras bases de datos. Pero hay muchas herramientas en el ecosistema porque una base de datos es tan fundamental para tu infraestructura que necesitas poder trabajar con datos en muchas herramientas diferentes.

Genial, hablemos de GraphQL. Creo que la mayoría de las personas, suena como tienen cierto nivel de familiaridad con GraphQL, tal vez solo en el lado del cliente, tal vez solo en el lado del servidor, así que hablemos de algunos conceptos de GraphQL y luego echaremos un vistazo a una API de GraphQL en funcionamiento para escribir algunas consultas de GraphQL.

Primero que nada, ¿qué es GraphQL? GraphQL es un lenguaje de consulta para APIs. Utilizamos un sistema de tipos estricto para definir los datos con los que trabajamos en GraphQL. Se llaman definiciones de tipos. Esas definiciones de tipos definen los datos con los que trabajamos, cómo se conectan esos tipos, y ahí es donde entra la parte de gráficos de GraphQL, ¿verdad? Podemos hacer referencia a otros tipos en los campos. En el momento de la consulta, el cliente solicita exactamente los datos necesarios para construir una aplicación y renderizar esa vista, sea lo que sea, y luego la respuesta, coincide con la estructura de la consulta, por lo que sabemos exactamente qué datos estamos obteniendo de la API.

En nuestras definiciones de tipos, normalmente utilizamos el Lenguaje de Definición de Esquema, o SDL para definir nuestros tipos. Por supuesto, también podemos definir tipos programáticamente. SDL es bueno porque es independiente del lenguaje. Puedo usar SDL si estoy construyendo mi API de GraphQL en JavaScript, Python, Go. Hay algunos conceptos interesantes en las definiciones de tipos. Primero que nada, definimos tipos. Los tipos tienen campos que también tienen un tipo, ¿verdad? Aquí tenemos película, género y actor como nuestros tipos de objeto de GraphQL. Y la película tiene cosas como el título, que es una cadena, años, que es un entero, y así sucesivamente. Y luego aquí tenemos un campo de relación, géneros, que conecta el tipo película con el tipo género. Y veremos en un momento, cuando comencemos a trabajar con la biblioteca de GraphQL de Neo4j, que podemos anotar estas definiciones de tipos utilizando lo que se llaman directivas de esquema de GraphQL. Y las directivas de esquema son el mecanismo de extensión incorporado de GraphQL que nos permite decir, oye, aquí debería ocurrir alguna lógica personalizada. Y veremos qué es eso y por qué lo usamos en un momento.

Así que eso son las definiciones de tipos. Hablemos de las operaciones en GraphQL o comúnmente llamadas consultas. Entonces las operaciones pueden ser de tres tipos diferentes, una consulta, una mutación o una suscripción. Y estas se corresponden con campos en tipos especiales, el tipo de consulta, el tipo de mutación y el tipo de suscripción.

Aquí tenemos una consulta de GraphQL. Los puntos de entrada, que en este ejemplo es el punto de entrada de películas que se mapea a un campo de películas en el tipo de consulta. Y podemos pasar argumentos allí. Aquí estamos pasando un argumento 'where' para filtrar solo las películas con el título 'A River Runs Through It'. Y luego el resto de nuestra operación de GraphQL, todavía hay una consulta de GraphQL. Es un objeto anidado llamado conjunto de selección. Y el conjunto de selección especifica, supongo que especifica dos cosas realmente. Una es especificar un recorrido a través del gráfico de datos. Entonces dijimos que el gráfico y GraphQL son estos campos de relación que son tipos que hacen referencia a conexiones con otros tipos. Y ese recorrido en un conjunto de selección se expresa mediante anidamiento. Entonces aquí, por ejemplo, comenzamos con la película 'A River Runs Through It'. Luego traemos de vuelta el título de la película y luego recorremos a los actores y obtenemos el nombre de cada actor conectado a esta película que estamos buscando. Y aquí, cuando vamos a Directores, encontramos los directores de esta película y luego otras películas que esos directores han dirigido. Entonces esto es un recorrido a través de este gráfico de data simplemente anidando nuestro conjunto de selección. La respuesta coincide con la estructura de nuestro conjunto de selección. Entonces a la derecha, tenemos el objeto JSON que obtenemos como resultado de esta consulta de GraphQL. Podemos ver exactamente los campos especificados en nuestro conjunto de selección son devueltos.

Entonces eso habla de las definiciones de tipos. Hablamos de las operaciones de GraphQL, este concepto de un conjunto de selección. ¿Cómo definimos realmente la lógica para obtener datos de la capa de datos cuando estamos construyendo una API de GraphQL? Bueno, eso viene con estas funciones de resolución. Entonces, las funciones de resolución son donde reside la lógica para resolver una solicitud de GraphQL. Entonces aquí, en este ejemplo, tenemos un mapa de funciones de resolución para una aplicación de conferencia. Y tenemos un punto de entrada. Un campo en el tipo de consulta llamado sesión y en esa función de resolución, estamos accediendo a una capa ORM de base de datos y estamos buscando sesiones por una cadena de búsqueda. Así que imagina que tenemos una aplicación de conferencia y queremos permitir a los usuarios buscar como GraphQL o algo en el horario de la conferencia y luego ver las sesiones, en qué sala están, sesiones similares en las que podrían estar interesados, etc. Y tenemos resolutores para cada uno de estos campos.

Una vez que hemos encontrado las sesiones en la base de datos que coinciden con nuestra cadena de búsqueda, bueno, si el usuario lo ha seleccionado, entonces necesitamos volver a la capa de datos para averiguar en qué sala está esa sesión. Necesitamos hacer lo mismo para el tema y luego necesitamos volver a buscar cualquier sesión que se recomiende en función de la sesión que encontramos buscando en el horario. Y esto se debe a la forma anidada en que se llaman las funciones de resolución, ¿verdad? Las funciones de resolución se llaman primero comenzando en el nivel raíz, en este caso, el campo de sesión en el tipo de consulta. Y luego en este caso, tenemos tres sesiones, tres resolutores en sala de sesión, tema y recomendado. Entonces, si esos campos se solicitan en el conjunto de selección, haremos tres viajes más a la capa de datos por cada sesión que hayamos encontrado. Ahora puedes ver dónde pueden surgir problemas de rendimiento aquí. No queremos hacer consultas potencialmente costosas a la capa de datos varias veces por cada solicitud de GraphQL. Y ciertamente no queremos hacerlo en el caso de que encontremos un montón de sesiones que coincidan con nuestra cadena de búsqueda y luego hacer múltiples solicitudes para cada sesión que encontramos que podría ser potencialmente muy lento. Entonces esto señala, lo que comúnmente se llama el problema de la consulta N más uno, donde terminamos haciendo muchas solicitudes a la capa de datos para cualquier solicitud de GraphQL arbitraria. Hay algunas formas diferentes de abordar esto. Un enfoque común se llama capa de datos, o lo siento, cargador de datos, que nos permite agrupar y almacenar en caché las consultas para reducir el número de solicitudes enviadas a la capa de datos, eso puede agregar cierta complejidad adicional. Entonces, otra forma de abordar este problema es utilizar integraciones de base de datos para GraphQL que pueden generar una sola consulta a la base de datos desde el resolutor de nivel raíz. Y eso es exactamente lo que hace la biblioteca GraphQL de Neo4j. Entonces, en lugar de llamar a múltiples resolutores anidados de esta manera cuando estamos usando la biblioteca GraphQL de Neo4j, en realidad generaremos una consulta a la base de datos en el resolutor raíz, por lo que no tenemos que preocuparnos por este problema de consulta N más uno.

Entonces, algunos beneficios de GraphQL, creo que la mayoría de las personas han visto la mayoría de estas cosas antes, el beneficio más común o más comúnmente hablado de GraphQL creo que veo es esta idea de sobre-solicitud y sub-solicitud, poder hacer solo una solicitud a la capa de GraphQL para renderizar todos los datos necesarios en una vista de una aplicación en lugar de hacer múltiples solicitudes al backend, y luego reducir la respuesta de la red para que si solo estoy mostrando, no sé, como en una lista de blogs solo estoy mostrando el título y el autor del blog no necesito obtener todos estos otros metadatos o incluso el contenido completo de la publicación del blog, cosas como estas que no se están utilizando para renderizar datos en mi vista. Entonces, GraphQL aborda ambos problemas. También hay muchas mejoras importantes en la productividad del desarrollador que creo que también se pueden ver con GraphQL. Por supuesto, también hay algunos desafíos que surgen. Creo que la categoría más grande de desafío que puede surgir con GraphQL es que muchas cosas que se comprenden bien en el mundo de REST no necesariamente se aplican cuando estamos construyendo API de GraphQL. Cosas como los códigos de estado de HP no significan exactamente lo mismo, el manejo de errores y el almacenamiento en caché se pueden hacer de manera un poco diferente. Hablamos de este problema de consulta N más uno, que puede ser problemático si no lo anticipas cuando estás comenzando a construir tu API. Entonces hay mejores prácticas y herramientas. Entonces, bibliotecas de software y paquetes que abordan todas estas cosas, pero estas son algunas de las cosas más comunes que pueden surgir. Entonces, una de las cosas que es realmente agradable del ecosistema de GraphQL es la herramienta. Entonces, hay una característica de GraphQL que aún no hemos mencionado que impulsa muchas de las herramientas geniales de GraphQL que vemos, y eso es esta idea de introspección. Entonces, cuando tenemos una API de GraphQL en ejecución, podemos enviar lo que se llama una consulta de introspección a la API. La consulta de introspección básicamente dice, envíame todos los tipos que tienes disponibles en la API, envíame el esquema de la API. Y luego podemos usar eso para construir herramientas para desarrolladores realmente poderosas. Cosas como la verificación de sintaxis del lado del cliente para consultas de GraphQL, podemos tener autocompletado basado en la introspección y luego estas herramientas en el navegador. Cosas como GraphQL Playground, GraphiQL o Apollo Studio. Apollo Sandbox es la parte de Apollo Studio que tiene esta funcionalidad de consulta en el navegador donde básicamente podemos ver la documentación de la API de GraphQL generada a partir de la consulta de introspección y luego también tener estas características agradables de autocompletado y verificación de sintaxis mientras escribimos consultas de GraphQL y trabajamos con los resultados. Entonces hoy, vamos a ver GraphQL Playground en un par de ejemplos diferentes, pero la funcionalidad es similar para usar GraphQL Playground, GraphiQL o Apollo Studio se aplican conceptos similares.

De acuerdo, genial. Entonces vamos a sumergirnos y echar un vistazo a una API de GraphQL en ejecución. Entonces vamos a movies.neo4j-graphql.com, verás, en realidad, vamos a, tal vez esto sea más fácil, tal vez pueda tener las diapositivas y GraphQL Playground uno al lado del otro, podemos hacer un seguimiento de lo que estamos haciendo. Entonces veamos si podemos escribir algunas consultas de GraphQL. Así que abriremos este movies.neo4j-graphql.com y veremos, probablemente tendremos un editor de GraphQL en blanco allí a la izquierda. Y esto es GraphQL Playground, esta es una API de GraphQL que está en funcionamiento que tiene datos sobre películas. Y si vamos a la pestaña de esquema, podemos ver el esquema completo de la API, pero si vamos a docs, tenemos algo más legible para los humanos sobre los datos disponibles en nuestra API. Y así, en primer lugar, podemos ver los campos de consulta disponibles. Cosas como películas, géneros, tenemos algunas agregaciones y campos de conexión también.

Hablaremos de eso más adelante, pero tenemos cosas como películas, usuarios, actores, directores, y si profundizamos y vemos, tenemos información detallada sobre películas. Las películas están conectadas a cosas como actores y se puede ir de actores a otras películas en las que han actuado y ver todos los campos disponibles. Ahora también podemos ver los argumentos que podemos pasar para cosas como filtrar aparentemente o opciones a nivel de campo de consulta.

De acuerdo, y nuestro ejercicio aquí es explorar la pestaña Docs, aprender más sobre el esquema de la API. Bueno, eso hicimos. Y luego escribir algunas consultas GraphQL para responder algunas preguntas. Así que encontramos que el título son las primeras 10 películas ordenadas por título. ¿Quién actuó en la película Jurassic Park? ¿Cuáles son los géneros de Jurassic Park? ¿Y cuáles son otras películas en esos géneros? Así que pasemos un par de minutos viendo cómo escribimos consultas para responder esas preguntas. Y luego pasaremos a la siguiente sección donde profundizaremos en cómo se construye esta API GraphQL y echaremos un vistazo a Neo4j. Así que haré una pausa de uno o dos minutos y daré a las personas tiempo para jugar con esto. Y luego veremos las respuestas para esto.

De acuerdo, ¿todos entendieron esta primera consulta, que es encontrar los títulos de las primeras 10 películas ordenadas por título? Bueno, podemos buscar en la documentación para ver que tenemos el punto de entrada de películas. Así que comenzaremos allí. Entonces películas, y luego podemos ver con el espacio de control, los diferentes campos disponibles. Y ese es el título, sabemos que lo queremos. Pero sabemos que solo queremos las primeras 10. Así que si busco en la documentación, puedo ver para el campo de consulta de películas, hay un par de argumentos, que necesito explicar más abajo. Así que hay un argumento de filtro, que tiene cosas como funcionalidad de filtrado, parece, pero eso no es exactamente lo que necesitamos en las opciones. Tenemos ordenamiento y limitación. Así que creo que eso es lo que queremos. Así que agreguemos un argumento de campo de opciones aquí. Quieres limitar, ¿qué dijeron? Las primeras 10 películas. Probemos esto, nos da 10 películas, pero queremos que estén ordenadas por título. Así que agreguemos ordenamiento, y luego necesitamos especificar una dirección de ordenamiento. Y así en esta API, podemos comenzar por título, luego orden ascendente o descendente. Y si lo hacemos en orden ascendente, podemos ver aquí, tenemos algunos caracteres especiales que comienzan primero. Así que aquí están nuestras primeras 10 películas ordenadas por título. Genial.

¿Alguien entendió esta siguiente pregunta, que es, ¿quién actuó en la película Jurassic Park? ¿Alguien lo entendió? Bueno, echemos un vistazo. Así que vimos anteriormente, que las películas tienen un argumento de filtro. Y si miramos los campos en eso, básicamente tenemos filtrado para cada uno de los campos disponibles en el tipo de película. Puedes ver que para los campos de cadena, tenemos estos varios contains, starts with, ends with, y para los campos numéricos, tienes cosas como mayor que, menor que, y así sucesivamente. Y aquí, hagamos un título. Es Jurassic Park o este trabajo, nos va a encontrar. De acuerdo, aquí está Jurassic Park, lo encontramos, pero queremos saber los actores. Y nuevamente, simplemente buscando cosas por autocompletar con el espacio de control, nos ayuda a ver lo que está disponible, actores, eso suena a lo que estamos buscando, y los actores traen de vuelta el campo de nombre. Así que aquí están nuestros actores en Jurassic Park. Y luego, ¿cuáles son los géneros? Así que vamos a traer de vuelta los géneros, Jurassic Park aventura acción, ciencia ficción thriller. Y luego, ¿qué otras películas hay en esos géneros? Así que ahora podemos atravesar desde los géneros a otras películas, agregando este campo de películas. Sin embargo, si solo ejecuto esto, bueno, tenemos potencialmente, no sé, decenas de miles de películas en la database, tal vez miles de películas en la database. Entonces probablemente haya, no sé, miles de thrillers, miles de películas de ciencia ficción. Así que agreguemos un límite aquí. Entonces también podemos agregar argumentos a nivel de campo en nuestro conjunto de selección. Así que agreguemos simplemente un límite de diez para cada uno de estos géneros. Traigamos solo 10 películas más en cada uno de esos géneros. Genial, ¿todos entendieron eso? ¿Alguien está atascado o confundido con eso? Creo que para aquellos familiarizados con GraphQL, espero que esto haya sido una revisión de los conceptos, aunque tal vez no haya visto esta API específica antes. V-Sys, cortado, de acuerdo, genial.

Bueno, sigamos adelante entonces hablando sobre data y Neo4j. Así que eso es escribir algunas consultas de GraphQL y una descripción general de algunos conceptos de GraphQL, así que hablemos de construir nuestra propia API de GraphQL. Pero primero, vamos a configurar nuestra database. Y para esto, vamos a utilizar Neo4j AuraDB, una base de datos alojada como servicio de Neo4j que nos proporciona instancias de Neo4j alojadas. Compartiré un enlace aquí en el chat, dev.neufj.com/neo4j-aura, o simplemente puedes buscar Neo4j Aura en Google. Y vamos a seleccionar el nivel gratuito, podemos registrarnos con Google, y tal vez algunos otros servicios, o puedes crear un nombre de usuario con correo electrónico y contraseña, y luego se te pedirá que elijas el nivel gratuito. Hay algunos niveles diferentes, hay gratuito, profesional y nivel enterprise. El nivel gratuito nos permite crear bases de datos que son privadas para nosotros, por lo que obtenemos las credenciales de conexión privadas, pero la database permanece. Esto es bueno para proyectos de hobby, si queremos que la database permanezca por un tiempo. También podemos comenzar cargando un conjunto de datos existente, así que vamos a elegir el conjunto de datos de recomendaciones basadas en gráficos. Eso va a cargar en realidad los mismos datos de películas y calificaciones de usuarios con los que acabamos de trabajar. Así que veamos cómo se ve esto. Voy a ir a dev.newtra.com, new from J, dash, Aura, y vamos a hacer zoom, así que voy a hacer clic en Comenzar Gratis.

Y ya había iniciado sesión. Creo que solo inicié sesión con mi Gmail. Y al principio, creo que verán esta pantalla. Si no la ven, simplemente hagan clic en Crear Instancia, y queremos las Recomendaciones Basadas en Gráficos. Esto cargará algunos datos iniciales en nuestra base de datos. Así que le daré a Crear. Este es un paso importante, así que esta es la contraseña para mi base de datos, y puedo copiar la contraseña o puedo descargar un archivo .env que tiene las credenciales de conexión. Así que voy a copiar esto y también descargaré el archivo .env. Y sí, lo he copiado, todo bien. Bien, esto tomará unos minutos para configurarse en la nube. Así que tomemos un minuto o dos porque todos querrán crear su propia base de datos de Neo4j Aura. Luego construiremos una API de GraphQL sobre tu instancia privada de Aura. Así que sigue estos pasos, asegúrate de guardar tu contraseña generada, descarga el archivo .env, copia y pega la contraseña en algún lugar porque la necesitarás en un momento. Así que haremos una pausa por solo un minuto para que todos pasen por este proceso, y luego echaremos un vistazo a los datos que acabamos de crear. Avísanos en el chat si tienes algún problema o te quedas atascado.

Bee está preguntando, ¿puedo guardar mi contraseña aquí en el chat? No recomendaría eso en el chat. Entonces, hay una forma de enviar un chat solo a ti mismo, tal vez tenga sentido. Pero en general, no quieres que otras personas vean tu contraseña.

Nuestra instancia está en funcionamiento, genial. Echemos un vistazo a lo que tenemos entonces. Bien, una vez que tu instancia esté en funcionamiento, verás este punto verde que indica que está en funcionamiento. Así que hay algunas cosas. La capa gratuita de Aura está limitada por la cantidad de nodos y relaciones que puedes almacenar en la base de datos. Así es como se representan estos números 14 y 42%. Y luego está la URI de conexión. Esto es cómo nos conectamos a esta base de datos desde los controladores de la base de datos o algunas de las diferentes herramientas de desarrollo. Y si hago clic en este botón Abrir aquí, me llevará a Neo4j Workspace, donde me pedirá mi contraseña. Esa es la contraseña para mi instancia específica. Es posible que en lugar de Abrir, veas algo que se vea así, Explorar Consulta Importar. Esta es la vista clásica, tenemos estas tres herramientas de desarrollo divididas individualmente. Si no ves donde solo dice Abrir, si haces clic aquí en tu icono de usuario, te dirá si estás utilizando la experiencia clásica o el espacio de trabajo, que supongo que debería ser, debería ser el valor predeterminado para las personas. Esta es una forma relativamente nueva de organizar las herramientas de desarrollo, básicamente combina esas tres consultas de exploración e importaciones en una sola herramienta. Así que recomendaría usar la vista del espacio de trabajo ya que es la nueva, pero nuevamente, creo que es el valor predeterminado. De todos modos, deberías ver algo así con acercamiento un poco con explorar consulta e importar en la parte superior aquí.

Entonces, explorar, esta es una herramienta de visualización que nos permite explorar el grafo visualmente sin escribir ningún código. Solo voy a generar una perspectiva aquí. Solo va a inspeccionar los datos y permitirnos visualizar los datos. La perspectiva es básicamente lo que nos permite mapear los datos a la visualización. Tal vez no quiero que todos los datos estén disponibles en la herramienta de visualización, ese tipo de cosas. Pero lo bueno de esta pestaña de exploración, que esta es una herramienta llamada Neo4j Bloom, si la has visto antes, dice sí, las escenas están vacías. Sí, está bien. La escena vacía solo significa que aún no hemos devuelto ningún dato. Así que intentemos buscar una película. Lo bueno de esto es que tenemos esta especie de forma de búsqueda en lenguaje natural. Voy a buscar una película por título. Estábamos viendo Jurassic Park antes. Así que busquemos Jurassic Park. Y puedes ver que a medida que escribo, me da algunas opciones aquí. Así que veamos cuáles son los géneros de Jurassic Park. Oh, terminamos encontrando un par. Tenemos Jurassic Park y Jurassic Park 3 y puedes ver los géneros de esos. Podemos hacer doble clic para obtener detalles sobre los nodos. Podemos expandir para ver los actores en la película, etc. Así que esta es solo una forma de interactuar visualmente. Esto es útil si estamos construyendo algo como una herramienta para un analista que no va a escribir consultas de base de datos, pero queremos darles una herramienta visual para explorar nuestros datos, podemos configurar esta visualización. También podemos agregar lógica personalizada, configurarla para un rol más de analista. También vamos a usar esta pestaña de Consulta. Acerquémonos bastante aquí, tal vez no tanto. Entonces, la pestaña de Consulta es donde podemos escribir consultas Cypher y luego trabajar con los resultados. Antes de comenzar a escribir algunas consultas Cypher, creo que tengo un par de diapositivas para hablar un poco sobre algunos conceptos de Cypher. De acuerdo, hicimos todo esto, esto es solo una guía para configurar Neo4j Aura. Así que vimos ese ejemplo al principio en una de las primeras diapositivas cuando estábamos viendo un ejemplo de una consulta Cypher que buscaba personas con una dirección en Nueva York que estaban conectadas a entidades legales offshore. Y la base de Cypher es esta idea de coincidencia de patrones de grafo. Aquí estamos usando la palabra clave match, match significa, hey, encontrarás este patrón donde exista en un grafo. Y podemos construir estos patrones utilizando esta representación de arte ASCII de un grafo.

El patrón más fundamental que podemos definir es un nodo, y eso es un paréntesis abierto y un paréntesis cerrado, eso es dibujar un círculo, ¿verdad?, dibujar un nodo. Podemos agregar a ese patrón agregando la etiqueta del nodo. Las etiquetas son una forma de agrupar nodos, puedes pensar en ellas, si estás familiarizado con las bases de datos relacionales, como similares a una tabla de una base de datos relacional. Entonces, este patrón en la segunda línea dice encontrar nodos con la etiqueta película.

Una vez que hemos coincidido con un patrón, es útil poder referirnos a partes de ese patrón más adelante en nuestra consulta de Cypher. Y ahí es donde entra en juego la M aquí en la tercera línea antes de los dos puntos. Esto significa, vincula la variable M a cualquier parte del patrón del grafo, en este caso, el nodo de la película. Entonces, el nodo de la película que puedo usar para referirme a esta parte del patrón más adelante en la consulta. Entonces, M es ahora mi nodo de película. Puedo agregar predicados en línea, o también puedo usar esta cláusula where para definir predicados. Pero para los predicados de igualdad de propiedades en línea, lo hago dentro de llaves. Entonces, aquí, dentro de los paréntesis con llaves, dice encontrar películas con el título Jurassic Park. Esto es equivalente a hacer coincidir la película donde M.título es igual a Jurassic Park. Puedes ver aquí que estamos usando la variable M que hemos vinculado a la película M aquí en esta parte de la consulta. Estos dos, con las llaves o la cláusula where, son equivalentes, pero con la cláusula where, también podríamos, en lugar del operador de igualdad, podríamos decir donde M.título contiene Jurassic Park o comienza con Jurassic Park, cosas así. Y una vez que hemos coincidido con un patrón, podemos devolverlo, podemos devolver los resultados para ver qué datos hemos coincidido. Entonces, eso son los nodos, pero estamos trabajando con grafos. Entonces, las relaciones conectan nodos. Entonces, ¿cómo definimos relaciones en el grafo? Bueno, las relaciones son corchetes. Entonces, aquí, en esa primera línea, esa es la forma más básica de relaciones que podemos definir, que es solo una relación en blanco. Básicamente, está diciendo hacer coincidir todas las relaciones en el grafo.

Tenemos un concepto similar para las relaciones, similar a las etiquetas de los nodos, las relaciones tienen un tipo. Una diferencia entre los tipos de relaciones y las etiquetas de los nodos es que podemos tener múltiples etiquetas de nodo. Entonces, Rafael preguntaba si estamos diciendo buscar todas las tablas etiquetadas como película. Sí, estamos buscando específicamente nodos que tengan la etiqueta película. No tenemos tablas en un grafo, pero conceptualmente, podemos pensar en el concepto de etiquetas como similares a tablas. Supongo que la analogía equivalente sería que los nodos son como una fila en una tabla, si tiene sentido. Pero sí, esto básicamente dice encontrar todos los nodos que tienen la etiqueta película. Y veremos algunos ejemplos de esto en un momento. Esperemos que eso aclare un poco. Y luego, el concepto de etiquetas para relaciones con el tipo de relación es muy similar, pero tenemos un solo tipo de relación. Mientras que con los nodos, podemos tener múltiples etiquetas de nodo. Y de hecho, en nuestro conjunto de datos, lo veremos en un minuto, tenemos nodos que pueden ser tanto película, no en este caso. Tenemos, ¿qué?, actor? Tenemos actor y persona o también puedes ser actor y director en la base de datos también. De todos modos, las relaciones también tienen una dirección. Y ahí es donde entra esta flecha para indicar la dirección. Podemos tratar nuestro grafo como no dirigido. Entonces, cuando estamos buscando patrones, si no queremos incluir la dirección como parte del patrón que estamos buscando, simplemente omitimos esa flecha. Pero cuando esa relación se almacena en la base de datos, hay una dirección. Esta idea de dirección y tipo de relación, son importantes, porque volveremos a esto cuando comencemos a trabajar con GraphQL para ver cómo mapeamos esta parte del modelo de grafo de propiedades que usamos en la base de datos, cómo lo mapeamos a GraphQL. Como mencioné, la directiva de esquema de relación anteriormente, vamos a usar eso para codificar el tipo de relación y la dirección. Pero de todos modos, eso se adelanta un poco. Y así, de manera similar, podemos ver cómo estamos construyendo nuestro patrón aquí para buscar ahora relaciones que conecten a un actor y una película, podemos vincular variables a nuestras relaciones al igual que lo hicimos con los nodos. Entonces, aquí estamos usando r para referirnos a la relación que conecta la película Jurassic Park y cualquier actor. He vinculado aquí la hoja de trucos de Cypher, que es como una tarjeta de referencia para Cypher. Hay muchos ejemplos aquí. Esto es útil para ver lo que está disponible en Cypher de una manera mucho más concisa que la documentación oficial. Y luego, la otra pieza de documentación de la que queremos estar al tanto hoy es la biblioteca de Neo4j GraphQL aquí.

Drop a link to that. Esto está vinculado en el lateral, pero lo vamos a empezar a usar en un momento también.

Ok, hablamos sobre algunos conceptos básicos de Cypher. Veamos cómo lo usamos. Voy a volver al espacio de trabajo de Neo4j. Vimos la pestaña de exploración. Esto es para visualizar el grafo y explorarlo visualmente. La pestaña de consulta es donde podemos escribir nuestras consultas en Cypher y visualizar los resultados. Match m:movie title, Jurassic Park es lo que estamos buscando, y luego podemos devolver m. Esto es lo que vimos en la diapositiva hace un minuto. Y obtenemos este único nodo. Obtenemos una vista del grafo. Si hacemos doble clic en esto, podemos empezar a explorar los datos un poco, pero esto quizás no sea tan útil como queremos porque ahora también hemos agregado todas estas calificaciones de usuarios. Aquí hay un usuario y calificaron Jurassic Park con 4.5. Podemos almacenar propiedades o atributos. Eso es el dato real. Cosas como el título, podemos almacenarlos tanto en los nodos como en las relaciones. Aquí está esta relación calificada que tiene una propiedad de calificación de 4.5, que tiene una marca de tiempo de cuándo se creó esto. Podemos almacenar pares clave-valor arbitrarios, los llamamos propiedades tanto en los nodos como en las relaciones.

Ok, modifiquemos un poco nuestra consulta para incluir la parte de la relación. Actitive en actor, y luego necesito agregar la dirección. Ten en cuenta que podemos escribir nuestras consultas de diferentes maneras, solo tenemos que asegurarnos de obtener la dirección de nuestra relación correctamente. Actor acted in movie. Y quiero devolver, solo vamos a devolver estrella para devolver todo, no solo el nodo de la película. Genial, aquí vamos, aquí está Jurassic Park, tenemos los actores, y de nuevo, puedo hacer doble clic para explorar el grafo. Aquí está Jeff Goldbloom, aquí hay un montón de otras películas en las que también participó. Pero en lugar de simplemente hacer clic, puedo definir cualquier nodo de película, definir cualquier patrón de grafo arbitrariamente complejo aquí usando Cypher. Entonces, si quisiera encontrar quién actuó en Jurassic Park y en qué otras películas actuaron, simplemente agregaría a ese patrón de esta manera. Ah, y la razón por la que estamos viendo esto como desconectado es porque no vinculé nada a estas segundas relaciones de acted in. Puedo llamar a eso R2 y eso me dará Jurassic Park, los actores de Jurassic Park y luego en qué otras películas actuaron esos actores. Curiosamente, parece que al menos estos cuatro, Jeff Goldbloom, Sam Neill, Richard Attenborough y Laura Dern no estuvieron en ninguna otra película juntos, al menos no en esta base de datos. Puedo vincular partes del patrón de grafo a variables o puedo vincular todo el camino, creo, por lo que podría hacer algo como esto donde P es este camino y luego devuelvo el camino y luego no tengo que pensar en vincular todos estos o declarar variables en Cypher para todas estas partes del patrón. Puedo eliminar esos.

Ok, tomemos un par de minutos para que todos pasen por los ejercicios aquí, escribamos algunas consultas en Cypher para encontrar la película The Matrix. ¿Podemos encontrar otras películas de la serie Matrix? ¿Quiénes actuaron en las películas de Matrix? ¿En qué otras películas participaron? ¿Cuál es la calificación promedio de los usuarios para cada una de las películas de Matrix? Y luego, esta última será útil cuando comencemos a agregar lógica personalizada a nuestra API de GraphQL, qué películas recomendaríamos a alguien a quien le guste The Matrix, por lo que empezaremos a pensar un poco en si podemos escribir una consulta de recomendación. Utiliza la documentación de Cypher que vimos, la hoja de trucos, para intentar escribir algunos patrones de grafo para responder a estas preguntas. Haremos una pausa aquí durante unos minutos para darles tiempo a todos para trabajar en esto. Luego volveremos y revisaremos las soluciones juntos. Y solo para que tengas una idea de lo que viene a continuación, lo siguiente que vamos a ver son las características de la biblioteca de Neo4j GraphQL. Y ahora vamos a comenzar a construir una API de GraphQL sobre la base de datos Aura que acabamos de crear. La primera pregunta es encontrar la película The Matrix, Rafael dijo que obtuvo las dos primeras. Ok, genial, para encontrar The Matrix, vamos a decir, match en movie donde el título es específicamente matrix, coma, the, así es como creo que lo tienes en la base de datos. Sí, aquí está The Matrix. Genial. Así que hago The Matrix. No lo voy a encontrar porque estamos buscando una igualdad exacta. No obtengo cambios, no hay registros. Y luego la siguiente pregunta creo que era si puedo encontrar todas las películas de la serie Matrix. Ahí es donde puedo cambiar un poco la sintaxis para decir, donde m.título contiene matrix y devolver m, eso debería darme donde hay tres en el momento en que se creó esta base de datos o tres películas de Matrix. Aquí hay tres películas de Matrix.

Genial, okay, bien. Y luego, ¿quién actuó en las películas de Matrix? ¿En qué otras películas participaron? Okay, esto será algo similar a lo que vimos antes, donde agregamos a nuestro patrón. Así que película actuada en, o al revés, ¿verdad? Así que actor actuó en películas. Queremos la flecha que va hacia el nodo de la película, y aquí están nuestros actores. Oh, pero solo estoy devolviendo N. Vamos a devolver todo. Así que Keanu Reeves está en las tres, genial. Carrie-Anne Moss está en dos de ellas. Okay, genial, eso parece correcto. Y luego la otra pregunta fue, ¿en qué otras películas participaron? Bueno, y vimos eso de nuevo, cuando estábamos haciendo Jurassic Park. Así que simplemente agregamos al patrón de grafo que estamos creando. Ahora voy a cambiar para encontrar todo el camino y devolver todo el camino. Aquí está Matrix. Aquí están los actores en Matrix. Aquí están otras películas en las que actuaron. Así que podemos ver el grafo, genial.

¿Cuál fue la siguiente pregunta? ¿Cuál es la calificación promedio de los usuarios para cada una de las películas de Matrix? Bueno, si echamos un vistazo aquí en esto, haga clic en esta diapositiva de información de la database. Esto nos dará información sobre los data que tenemos. Tenemos actores, directores, género, película, persona, usuario. Para los tipos de nodos, tenemos actuado en, dirigido, en género, y calificado como relación. Así que queremos calcular el promedio de la calificación. Así que echemos un vistazo a estas relaciones calificadas. Acabo de hacer clic en calificado aquí en las relaciones de esta database. No sé cómo llamar a esto, un cajón, una diapositiva, al hacer clic en este ícono de database. Y acabo de ejecutar una consulta simple para encontrar 25 relaciones calificadas. Y sabemos esto porque lo vimos antes. Pero si hacemos clic en una de estas relaciones calificadas, podemos ver que estamos almacenando propiedades. Así que la calificación y luego una marca de tiempo como propiedades en la relación. Así que sabemos que eso es lo que queremos calcular el promedio, cuando calculamos el promedio de esta propiedad de calificación. De acuerdo, así que volvamos a la consulta que estamos construyendo aquí. Tal vez podamos eliminar algo de esto. Sabemos que queremos hacer esto para todas las películas de Matrix, así que vamos a, tal vez eliminemos esta parte. No estamos buscando actores y otras películas. Ahora estamos buscando las películas, pero ahora queremos esto, diremos r: calificado. Y luego es un usuario que califica una película. Así que ahora lo que queremos hacer es devolver, devolver y si miramos en la Hoja de Trucos de Cypher, y si buscamos, creo que están en las funciones de agregación. Sí, y en las secciones de funciones de agregación, tenemos cosas como contar, recopilar algunas, y también promedio, mínimo y máximo. Así es como podemos averiguar tenemos una función de promedio en Cypher, devolver el promedio de R.calificación. Y esto debería darnos, 3.543 blah blah blah, es el promedio de todas las películas, eliminé donde en ese título contiene Matrix. De acuerdo, así que ahora solo para las películas de Matrix 3.83, las películas de Matrix tienen una calificación mejor que el promedio en la database. Pero ahora este es el promedio de las tres películas de Matrix, ¿verdad? Porque teníamos tres películas de Matrix, no estamos buscando solo el título exacto. Así que sería bueno poder agrupar por los resultados de cada película. Entonces, ¿cuáles son las calificaciones para cada una de las películas de Matrix? Supongo que anticiparía mi hipótesis es que la primera película de Matrix tiene una calificación más alta que las demás. Entonces, en SQL, para hacer esto, escribiríamos lo que se llama un groupby donde estamos ejecutando funciones de agregación, en este caso, el promedio es nuestra función de agregación. Y queremos ejecutar eso en grupos de resultados intermedios. En Cypher, hay un groupby implícito que cada vez que devolvemos resultados de una función de agregación junto con algún valor, implícitamente agrupamos por ese valor. Entonces, si devuelvo el título de la película, como esta palabra clave, esto es nuevo, esto simplemente da un alias al resultado a una nueva variable llamada película. Y luego el promedio r.calificación agrupado por los valores distintos de título, y llamémoslo calificación promedio o algo así. Y podemos ver que supongo que mi hipótesis era correcta la matriz tiene un promedio de 4.18 y las demás son 3.2 y 3.0. Así que, observe que, anteriormente estábamos obteniendo esta representación gráfica de los resultados. Ahora estamos obteniendo una vista de tabla y eso se debe a que estamos devolviendo datos tabulares o estamos devolviendo, solo filas aquí. A menudo, la respuesta a nuestra pregunta es una tabla, aunque estemos recorriendo el grafo para obtener esos resultados. Entonces, dependiendo de qué data estemos devolviendo, si son datos de grafo, tendremos una pequeña visualización de grafo y si estamos devolviendo datos tabulares, trabajaremos con tablas.

Bien, ahora esta última pregunta, ¿qué películas recomendarías a alguien a quien le guste Matrix? Bueno, esta pregunta se refiere a un caso de uso común que tenemos para las bases de datos de grafos, que son las recomendaciones o la personalización. Y vemos esto en sitios de comercio electrónico. Por ejemplo, usuarios que compraron este libro también han comprado estos otros libros. Entonces vamos a agregar, dar esos como un producto recomendado que al usuario le pueda interesar. Y al generar estas recomendaciones, hay un par de formas diferentes de abordar esto. Está la categoría de lo que se llama filtrado colaborativo, donde estamos mirando las interacciones de los usuarios en nuestros conjuntos de datos. En este caso, tenemos calificaciones de los usuarios. Entonces estamos mirando las calificaciones de los usuarios para ayudarnos a determinar qué sería una buena recomendación. Básicamente, el enfoque aquí es encontrar usuarios similares basados en mi historial de calificaciones y qué usuarios similares a mí están comprando. Otra opción sería, sería mirar opciones basadas en contenido. Y en este caso, tenemos cosas como el género de la película, el director, los actores. Entonces, si me gustan las películas de cierto género, recomiéndame más películas de esos géneros. Así que veamos cómo podríamos modificar esta consulta para... Veamos el enfoque basado en contenido. Entonces, me gustan las películas de Matrix. ¿Qué otras películas podrían ser una buena recomendación para mí? Así que podemos eliminar nuestra calificación del usuario aquí. Y haremos una consulta bastante simple aquí. Entonces, en-género. Esto básicamente va a devolver eso. Esto está diciendo, encontrar los géneros de las películas de Matrix y cosas como ciencia ficción, acción, thriller, aventura. Bueno, para recomendar otras películas, simplemente recorremos. Recorremos. Ahora, siguiendo esa relación entrante en-género, y llamaremos a estas nuestras recomendaciones. Entonces... Rec.title será nuestra recomendación. Y podemos usar otra función de agregación aquí llamada count para contar la cantidad de géneros superpuestos. Diremos count star como score, y se ordena por score en orden descendente. Genial, aquí están nuestras recomendaciones. Entonces, si nos gustan las películas de Matrix, la principal recomendación es Los Tres Mosqueteros, seguida de King Kong, Desafío Total, Godzilla, y así sucesivamente. No sé. No estoy seguro de qué tan buenas son esas recomendaciones. ¿Qué opinan ustedes? Ese es un enfoque basado en contenido simple. Vamos a utilizar esta idea. Tal vez probemos el filtrado colaborativo cuando agreguemos lógica personalizada a nuestra API de GraphQL. Entonces, lo que vamos a hacer ahora es construir una API de GraphQL que exponga los datos en esta base de datos de recomendaciones. Y veremos cómo hacer eso utilizando la biblioteca Neo4j GraphQL. Y luego agregaremos lógica personalizada a eso para poder mostrar recomendaciones personalizadas para que si me gusta una cierta película, me muestre otras películas similares basadas en las calificaciones de los usuarios en la base de datos. Y hablemos un poco sobre la biblioteca Neo4j GraphQL. Entonces hablamos un poco sobre el enfoque de construir APIs de GraphQL mediante la definición previa de nuestras definiciones de tipo de GraphQL que define los datos con los que trabajamos en nuestra API de GraphQL. Y luego escribimos funciones de resolución que definen la lógica para acceder a nuestra capa de datos para buscar datos en la base de datos o crear datos para estas mutaciones. Vimos algunos problemas que surgieron. Uno de ellos fue esta idea del problema de la consulta N más uno donde debido a la forma anidada en que se llaman a las funciones de resolución hacemos múltiples solicitudes a la capa de datos o, honestamente, hay mucho código repetitivo, mucho código repetitivo para obtener datos de la capa de datos que puede ser un poco tedioso para la productividad del desarrollador si quiero poner algo en funcionamiento rápidamente. Quiero centrarme en áreas de mi aplicación pero tengo más ventaja competitiva como agregar lógica personalizada, este tipo de cosas. Y para abordar esos problemas, diría que el código repetitivo y los aspectos de rendimiento específicamente hay una serie de herramientas. Entonces, integraciones de GraphQL de bases de datos y una de ellas es la biblioteca Neo4j GraphQL que facilita la construcción de APIs de JavaScript. Específicamente APIs de GraphQL en Node.js respaldadas por Neo4j. Entonces, no estamos hablando de consultar la base de datos directamente con GraphQL, estamos hablando de una biblioteca que usamos junto con nuestro código de servidor GraphQL para construir esa capa de API que se encuentra entre la base de datos y el cliente. Entonces, hablemos un poco sobre los objetivos generales de la biblioteca Neo4j GraphQL. El primero es admitir esta idea de desarrollo basado en GraphQL primero, donde comenzamos con las definiciones de tipo de GraphQL, y esas definiciones de tipo pueden impulsar nuestros modelos de datos de la base de datos. Entonces, no necesitamos mantener dos esquemas separados, uno para nuestra API, uno para nuestra base de datos.

En cambio, estamos permitiendo que GraphQL, las definiciones de tipo, definan tanto el esquema para la API como la base de datos. Ahora veremos dónde podemos configurar el modelo de datos para la base de datos utilizando directivas de esquema. Por lo tanto, no es el caso en el que queremos tener una correspondencia exacta uno a uno todo el tiempo. A veces queremos tener algunas opciones de configuración o algunos nodos que no queremos exponer en la base de datos y así sucesivamente. Así que veremos cómo podemos configurar eso utilizando directivas de esquema.

El siguiente objetivo principal de la biblioteca Neo4j GraphQL es tomar esas definiciones de tipo donde hemos descrito solo los tipos, los campos en esos tipos, cómo se conectan esos tipos, donde hemos descrito ese gráfico básico, y luego generar automáticamente todas las operaciones comunes de API de GraphQL que necesitaríamos para trabajar con esos datos. Estas son las operaciones CRUD, crear, leer, actualizar, eliminar operaciones, por lo que los campos de consulta y mutación, pero también todas las pequeñas piezas que van junto con eso. Por ejemplo, los argumentos de campo para admitir el ordenamiento y la paginación y el filtrado complejo, y también agregar los tipos para cosas como fecha y hora o los tipos de datos geoespaciales, agregar funcionalidad para agregaciones, este tipo de cosas se generan a partir de esas definiciones básicas de tipo y se agregan al esquema de la API.

Luego, en el momento de la consulta, la biblioteca Neo4j GraphQL es capaz de tomar cualquier solicitud arbitraria de GraphQL y traducirla en una sola consulta de base de datos en este caso Cypher, y eso es importante por un par de razones. Una es que podemos evitar el problema de la consulta N más uno. Básicamente, hacemos una solicitud a la base de datos y una base de datos de gráficos como Neo4j está optimizada para recorrer el gráfico desde un nodo a cualquier otro al que estemos conectados, que es equivalente al anidamiento en nuestro conjunto de selección. Entonces, a menudo nuestras consultas de GraphQL, porque estamos obteniendo todos los datos para, por ejemplo, renderizar una vista en nuestra aplicación, a menudo podemos tener muchas estructuras anidadas en nuestro conjunto de selección que serían equivalentes a muchas uniones en una base de datos relacional, lo que puede tener algunos problemas de rendimiento cuando tengo muchos datos y muchas uniones, las cosas comienzan a desmoronarse. Pero una base de datos de gráficos, eso es exactamente para lo que están optimizadas las bases de datos de gráficos, estas travesías a través del gráfico de datos. Entonces, ese es un beneficio es abordar este problema de la consulta N más uno, permitiendo que la base de datos optimice esa travesía a través del gráfico de datos. Pero la otra gran ventaja aquí es que esto significa que no necesitamos escribir estas funciones de resolución porque las consultas de la base de datos se generan en el momento de la consulta, eso se encarga por nosotros. Así que aquí hay un gran impulso en la productividad del desarrollador que para comenzar, básicamente solo necesitamos definir las definiciones de tipo de GraphQL y apuntar el paquete a nuestra base de datos.

Ahora mencionamos varias veces esta idea de que queremos poder agregar lógica personalizada a nuestra API de GraphQL hasta ahora, solo hemos visto una lógica CRUD básica. Pero aquí hay un ejemplo donde hemos tomado una declaración Cypher. Entonces esto proviene de reseñas de negocios. En realidad, creo que este es un ejemplo del libro de GraphQL de pila completa, donde tenemos un sitio sobre negocios y reseñas de usuarios de negocios. Y hemos agregado un campo recomendado en el tipo de negocio que va a devolver una lista de negocios. Y aquí estamos recorriendo las reseñas de usuarios para encontrar negocios similares. Entonces una consulta de recomendación, algo similar a la de las películas de Matrix que escribimos hace un momento. Ahora, esta directiva de esquema cypher, por lo que puedes ver aquí, la sintaxis es at cypher y luego un argumento de declaración y esa es nuestra declaración cypher que tiene la lógica para esa consulta. Entonces dijimos anteriormente que las directivas de esquema son el mecanismo de extensión incorporado de GraphQL. Y así estamos extendiendo las definiciones de tipo para nuestra API de GraphQL para usar esta directiva de esquema cypher para adjuntar lógica personalizada a nuestras definiciones de tipo de GraphQL. Y luego, en el momento de la consulta, esta consulta, la consulta cypher que hemos adjuntado aquí al campo recomendado, se recoge en la consulta general generada de la base de datos. Por lo tanto, todavía podemos generar solo una consulta de base de datos en el momento de la consulta, agregamos esto como una especie de subconsulta en la declaración general generada.

Bien, ¿cómo usamos esta biblioteca Neo4j GraphQL? Bueno, se publica como un paquete npm. Por lo general, lo usaríamos junto con algo como Apollo Server o GraphQL Yoga, si estás familiarizado con el ecosistema de GraphQL de Node.js. Hay un par de dependencias principales Neo4j JavaScript Driver y luego la implementación de JavaScript de GraphQL. Aquí está el fragmento básico. Entonces, este es más o menos el código mínimo que necesitamos para comenzar. Creo que aquí profundizamos un poco más. Primero importamos algunos paquetes o importamos la biblioteca Neo4j GraphQL, el controlador de JavaScript de Neo4j, que nos permite hacer una conexión a nuestra base de datos y luego Apollo Server, que creo que es, probablemente, la implementación de servidor GraphQL de Node.js más común, GraphQL Yoga es otra popular, pero esto funciona con cualquiera de las implementaciones de servidor GraphQL de JavaScript. Luego definimos algunas definiciones de tipo. Entonces aquí tenemos, tenemos películas y géneros. Entonces solo una parte de los datos con los que estamos trabajando hoy. Y luego tenemos esta relación con tipo y dirección. Entonces dije antes que en el modelo de gráfico de propiedades con el que trabajamos en Neo4j, cada relación tiene un solo tipo y una dirección. Y debido a las convenciones de nomenclatura que son un poco diferentes del modelo de gráfico de propiedades que usamos con Neo4j y GraphQL, entonces GraphQL como un nombre de campo, generalmente usamos una convención de camel case como esta donde comenzamos con minúsculas y luego mayúsculas cada palabra. La convención en el modelo de gráfico de propiedades con Neo4j para los tipos de relación es usar, creo que esto se llama snake case donde tenemos todo en mayúsculas y luego guiones bajos para los espacios. Entonces, codificar esta información en una directiva de esquema de relación nos permite no mezclar estas convenciones, pero también nos permite capturar la dirección de la relación, que no tenemos ese concepto similar en GraphQL. Entonces aquí usamos esa directiva de esquema de relación para codificar un poco más de información. Luego creamos una instancia del controlador de JavaScript de Neo4j con nuestras credenciales de conexión a nuestra base de datos. Aquí se está ejecutando localmente, nombre de usuario y contraseña. Luego creamos una nueva instancia de Neo4j GraphQL que llamamos Neo Schema aquí, pasando nuestras definiciones de tipo y nuestro controlador, y esto pasa por un proceso de aumento de esquema donde básicamente estamos generando todas esas consultas y mutaciones, cosas como los argumentos de campo para la paginación y el ordenamiento, el filtrado, todas esas cosas y generando las funciones de resolución. Luego pasamos ese objeto de esquema, en este caso, a Apollo Server y servimos nuestra API de GraphQL. Por lo tanto, no tuvimos que escribir ninguna función de resolución, todas se generan automáticamente para nosotros. Bien, esos son los objetivos generales de la biblioteca Neo4j GraphQL.

Veamos un ejemplo y recorramos la API de consulta para ver cómo podemos usarla. Vamos a ver un ejemplo diferente aquí, trabajando con una API para una librería en línea. Tenemos pedidos, clientes, direcciones, libros y reseñas. Puedes ver el modelo de grafo que esto define. A la izquierda, estamos definiendo nuestras definiciones de tipo de GraphQL. Y en la base de datos a la derecha, eso se mapea al modelo de grafo de propiedades equivalente en Neo4j. Veamos un par de estas directivas que estamos usando y algunos de los tipos que estamos usando. Creo que son bastante interesantes. En general, la forma en que configuramos la API de GraphQL generada con la que queremos trabajar es mediante el uso de estas directivas de esquema. Estas directivas de esquema son realmente poderosas. Ya hablamos de la directiva de esquema relationship, donde la usamos para codificar el tipo y la dirección que queremos definir en la base de datos. Otra que estamos usando aquí es la directiva ID. En este caso, estamos diciendo que el tipo order tiene un ID de pedido, que es de tipo ID y no nulo, por lo que el campo ID del pedido debe existir en cada pedido. Al agregar esta directiva ID, esto nos permitirá, cada vez que creemos un objeto de pedido, generar automáticamente un UUID, es decir, generar un ID aleatorio y almacenarlo en el nodo del pedido. Idea similar para timestamp, cuando creamos o actualizamos el pedido, al agregar esta directiva de esquema timestamp, el campo Place That se generará automáticamente para nosotros. También estamos trabajando con tipos escalares de fecha, hora y punto que están disponibles en la base de datos, por lo que podemos definirlos en nuestras definiciones de tipo.

Bueno, veamos la consulta de la API, y luego veremos cómo podemos usar esto para nuestras recomendaciones de películas data con las que estamos trabajando. Así que hablemos de algunos de los campos de consulta generados y cómo podemos usarlos. Por defecto, cada tipo que definimos en nuestras definiciones de tipo se mapea a una etiqueta de nodo, y luego obtenemos un campo de consulta para ese tipo, pero en plural. Entonces, en nuestro ejemplo aquí, tenemos el tipo libro, y eso se mapea a books, en plural, porque devuelve una matriz de libros. Podemos pensar en estos campos de consulta como el punto de partida para un recorrido a través del grafo de data. Ten en cuenta que la respuesta coincide con nuestro conjunto de selección tal como lo esperaríamos en GraphQL. Por lo tanto, cualquier campo que agreguemos se incluirá en esta consulta generada de base de datos en segundo plano.

Para la clasificación y paginación, bueno, vimos un poco de esto al principio en el ejemplo de conjunto de datos de películas que estábamos utilizando, donde tenemos el límite. También tenemos el offset que nos permite hacer paginación. Y luego aquí, estamos clasificando por precio de libros. También podemos hacer paginación basada en cursor basada en el tipo RelayConnection. Entonces, si has visto la API de GitHub, que creo que es una API GraphQL común que utiliza RelaySpec para la paginación basada en cursor, donde en lugar de especificar límites y desplazamientos para paginar y decir como grupos de 10 o algo así, obtenemos un cursor de cada consulta que podemos usar para obtener la siguiente página basada en ese cursor. Así que tenemos un par de opciones diferentes para la paginación disponibles.

Vimos un poco de esto, nuevamente, cuando estábamos viendo nuestro primer ejemplo de GraphQL de películas, pero tenemos opciones de filtrado complejas disponibles en este predicado where. Entonces, aquí estamos buscando libros donde el precio es menor a 20. Y vimos que estos inputs de filtrado se generan para cada campo en cada tipo. Y se basa en el tipo del campo. Entonces, para campos de cadena, tenemos los operadores de comparación de cadenas, para campos numéricos, tenemos cosas como mayor que, menor que, y así sucesivamente. Podemos usar este filtrado anidado en el conjunto de selección. Entonces, aquí estamos buscando libros con un precio menor a $20 y luego para las reseñas de esos libros, filtramos las reseñas o solo mostramos las reseñas que se crearon después de una cierta fecha. Así que ten en cuenta que este filtrado, cuando incluimos los argumentos de filtro en una parte anidada del conjunto de selección, el filtrado se aplica en el nivel donde lo hemos insertado. Entonces, no estamos filtrando libros. Estamos obteniendo todos los libros que son menores a 20, pero luego las reseñas es donde se aplica el filtrado en este caso. Veremos un ejemplo donde podemos aplicar el filtro a nivel raíz. También podemos buscar por distancia geográfica, una distancia de radio. Entonces, en este caso, tenemos direcciones que tienen una latitud y longitud aquí, estamos buscando nodos de dirección que están dentro de un kilómetro de un cierto punto y eso está disponible en cualquiera de los tipos de punto en la API.

Aquí hay un ejemplo donde aplicamos el filtrado a nivel raíz basado en un recorrido a través de una relación. Entonces, en el ejemplo anterior aquí, donde tenemos este filtro en el campo de reseñas, el filtrado se aplica en el campo de reseñas. Entonces, no en los libros, estamos obteniendo cualquier libro con un precio menor a 20 y luego estamos excluyendo algunas reseñas. Pero ¿qué pasa si queremos encontrar pedidos que estén dentro de un kilómetro o la dirección del pedido esté dentro de un kilómetro de este punto? Entonces, la dirección es su propio nodo conectado al pedido. Entonces, en este caso, tenemos una relación ship to para recorrer. Entonces, básicamente, movemos ese filtro al nivel raíz, pero especificamos la relación a la que queremos recorrer para que se aplique. Queremos que se aplique a la dirección de envío. Y aquí tenemos la ubicación menor que la distancia de un kilómetro desde este punto. Entonces, ahora solo encontraremos pedidos donde la dirección de envío coincida con este filtro de distancia. Y podemos aplicar esta lógica anidada, no solo con filtros de distancia, sino con cualquier argumento de filtro.

Ok, eso es un vistazo rápido a la API de consulta. Pasamos por alto la API de mutación generada, pero está bien. Veremos algunos ejemplos de eso en un minuto. Así que volvamos a algunas cosas prácticas. Echemos un vistazo a un par de formas diferentes de usar la biblioteca Neo4j GraphQL. Una forma es, vimos algunos fragmentos de código. Podemos crear una aplicación de servidor GraphQL en JavaScript utilizando algo como Apollo Server, GraphQL Yoga, o podemos usar la caja de herramientas Neo4j GraphQL, que es una herramienta de desarrollo y prueba de bajo código en el navegador para APIs GraphQL con Neo4j. Así que empecemos con esa, la caja de herramientas Neo4j GraphQL. Esta es una herramienta web alojada. Dejaré un enlace en el chat aquí. Pregunta de B, ¿cómo sabemos que la distancia está en metros y no en pies? Oh sí, eso es bueno. Sabemos eso simplemente porque esa es la convención utilizada por la función de distancia en Neo4j. Se especifica en la documentación que esa es la unidad predeterminada. Y creo que también se especifica en la documentación de GraphQL, si profundizamos en eso. Así que sí, SimplyConvention, así es como sabemos eso. Sí, buena pregunta. Genial, usemos la caja de herramientas Neo4j GraphQL para conectarnos a nuestra instancia de Neo4j Aura que creamos en el ejercicio anterior. Y veamos cómo podemos usar eso para desarrollar y probar una API GraphQL utilizando la biblioteca Neo4j GraphQL.

También está aquí en la pantalla. Esta es una herramienta útil. Actualmente está en versión beta. Por lo tanto, los nombres y las características no están finalizados, pero pensé que valdría la pena explorarlo porque es una excelente manera de ensuciarnos las manos rápidamente sin tener que escribir mucho código. Básicamente, lo que hace es empaquetar la biblioteca Neo4j GraphQL de una manera que nos permite generar una API de GraphQL y probar consultas contra una base de datos sin crear realmente un servidor de GraphQL.

Aquí hay algunos ejercicios definidos. Básicamente, lo que queremos hacer es abrir la aplicación de la caja de herramientas y ingresar nuestras credenciales de conexión para nuestra instancia de Neo4j Aura que creamos. Esperemos que hayamos guardado esas credenciales de conexión. Y lo primero que aparecerá es la opción de generar definiciones de tipos inspeccionando la base de datos. Inicialmente, vamos a cancelar y usar, hay un tipo de película predeterminado que vamos a usar. Quiero comenzar con eso porque simplificará algunas cosas para nosotros. Entonces, básicamente, si miramos, tal vez lo recorreré para que quede un poco más claro lo que estamos haciendo. Una caja de herramientas de GraphQL. Y lo primero que debo hacer es ingresar mis credenciales de conexión. Entonces, si descargaste el archivo .env, tendrá tu URI de conexión o podemos volver a Aura. ¿Dónde está mi instancia de Aura? Oh, me desconecté, volvamos a iniciar sesión. Entonces, hay otra forma de encontrar nuestra URI de conexión, que es esta parte aquí. Entonces, en el panel de control de Aura, hay una URI de conexión para tu instancia, podemos hacer clic en ese pequeño ícono aquí para copiarlo. Esa es la URI de conexión que quiero, y luego la contraseña, con suerte, la guardaste. Guardé la mía aquí en algún lugar. Ahí está. Pero también estará en ese archivo .env. Si descargaste los archivos .env, pégalo, haz clic en conectar, y luego verás esta opción de generar definiciones de tipos. Básicamente, esto significa que hay datos en la base de datos y podemos generar definiciones de tipos de GraphQL para que coincidan con los datos en tu base de datos. Voy a cancelar porque quiero comenzar de forma sencilla y ver más claramente cómo definimos las definiciones de tipos para impulsar la base de datos. Al principio, deberíamos ver solo este tipo de película único con un solo campo, título, que es una cadena, que coincide con los datos que tenemos.

Si hago clic en construir esquema... Ahora me lleva a una vista diferente, y verás, alternamos entre las definiciones de tipos y el editor de consultas aquí. Pero ese paso de construir esquema, al hacer clic en eso, básicamente está generando la API de GraphQL. Así que al pasar por ese proceso de agregar los campos de consulta y mutación, agregar los argumentos para filtrar, paginar, este tipo de cosas en una API bastante simple. Solo el tipo de película con un solo campo. Pero podemos ver lo que se genera para nosotros. Estamos usando en la caja de herramientas de GraphQL, la integración de Explorer para GraphiQL que combina esta idea de mostrarnos la documentación y darnos una opción de un solo clic para escribir nuestro conjunto de selección. Lo cual puede ser bastante agradable. Luego puedo hacer clic en este pequeño botón de reproducción para ejecutar esta consulta. Y así se ejecuta contra la base de datos. Devuelve mis 10 películas. Por lo tanto, esto se ejecuta contra la base de datos, incluso si no hay un servidor en funcionamiento, todo se gestiona en el navegador. Si voy a las herramientas para desarrolladores, así que vayamos a la consola de JavaScript. Y si ejecuto esta consulta nuevamente. ¿Necesito activar el modo de depuración? ¿Dónde está eso? Oh sí. Habilitar depuración. Aquí vemos que se muestra la consulta generada. Entonces, si volvemos a las definiciones de tipos y habilitamos el modo de depuración, ahora cuando ejecutamos la consulta, deberíamos ver, oh, ¿necesito hacer clic en construir esquema nuevamente, tal vez? Modo de depuración construir esquema. Ahí vamos. Entonces, si habilitamos este modo de depuración, hacemos clic en construir esquema nuevamente, luego cuando ejecutamos la consulta, veremos la sentencia CYPHER generada. Déjame hacer zoom en esto. Entonces, ese modo de depuración nos mostrará la sentencia CYPHER generada antes de que se ejecute. En este caso, generamos esta sentencia CYPHER.

Entonces, es bastante simple, coincidir película, devolver límite 10, pero eso es útil para ver qué se está generando en términos de consultas a la database. Bien, esa es la idea básica. Así que hay algunas cosas para trabajar aquí. Una es la consulta para encontrar todas las películas y luego encontrar solo Jurassic Park. Bueno, podemos hacer eso ahora. Esto es muy similar a lo que hicimos antes, así que está bien. Entonces vamos a agregar... En realidad, hagámoslo haciendo clic en explorar. Entonces sabemos que esto va a ser un where, donde el título es, Jurassic Park. Vamos a ejecutar eso. Aquí está nuestra película. Y ahora podemos ver la sentencia Cypher generada que incluye este predicado Jurassic Park donde este dot título es Jurassic Park. Bien, pero ahora, lo que queremos hacer es actualizar nuestras definiciones de tipos para incluir actores y consultar quiénes actuaron en Jurassic Park. Y aquí hay un recordatorio para usar la directiva de esquema de relación con un enlace a la documentation. Entonces, básicamente, lo que queremos hacer aquí es volver a las definiciones de tipos y editar nuestras definiciones de tipos aquí para incluir el tipo actor y la conexión entre actor y película para luego poder escribir una consulta para encontrar a todos los que actuaron en Jurassic Park. Y el punto es simplemente transmitir cómo definimos nuestras definiciones de tipos para impulsar la API generada por GraphQL. Y una vez que hayamos hecho eso, luego veremos esta función de introspección y veremos cómo funciona. Pero detengámonos aquí durante un par de minutos. Daremos tiempo a los participantes para que sigan estos pasos. Así que si aún no has abierto esta caja de herramientas de GraphQL, conéctala a tu instancia de Aura utilizando las credenciales de conexión, y luego haz clic en cancelar primero, no uses las definiciones de tipos generadas. Observa cómo funciona la herramienta de tooling de la caja de herramientas de GraphQL, y luego escribiremos algunas consultas y las veremos. Así que hagamos una pausa aquí durante un par de minutos y luego veremos el siguiente tema que es algo equivalente a esto pero escribiendo realmente una aplicación de servidor JavaScript Node.JS GraphQL. Y luego veremos cómo agregar lógica personalizada y agregar la función de recomendación personalizada a nuestra API.

Lo que queríamos hacer aquí era comenzar con el tipo de película y escribir algunas consultas, ver cómo se generan los argumentos para filtrar con un campo simple como el título. Agreguemos el tipo de actor. Sabemos que los actores tienen un nombre, lo haremos una cadena requerida. Y luego queremos poder conectar la película con el actor. Vamos a decir que los actores nos darán una matriz de objetos de actor. Y necesitamos, porque estamos usando la biblioteca de GraphQL de Neo4j, agregar esta directiva de relación para la conexión entre la película y los actores, que tiene un argumento de tipo, que será 'actuado en', y una dirección, que es un enum, con dos opciones: 'in' o 'out'. La forma de pensar en esto es que es 'actuado en', por lo que vamos del actor a la película, el actor actuó en una película, por lo que en ese caso, eso vendrá hacia el tipo de película. Y ahora, si construimos el esquema, obtenemos este error que dice que los campos de relación deben ser no nulos y tener entradas no nulas. Eso solo significa que esto necesita explicaciones. Y la razón de esto es que siempre devolveremos una matriz de este actor y eso se llama un campo de actores. Puede ser una matriz vacía si no tenemos ningún actor conectado a esta película, pero no devolveremos nulo. Y dentro de la matriz, lo único que estará dentro de la matriz son objetos de actor o nodos de actor de la base de datos. Y por eso tenemos el no nulo interno, nunca vamos a devolver un actor, un actor y luego un nulo dentro de la matriz. Así que eso es solo una verificación de tipo para asegurarnos de hacer un buen trabajo allí. Y ahora, si miramos los campos generados aquí, tenemos actores y en el tipo de película también tenemos un campo de actores. Agreguemos actores y el nombre, y luego para las películas, ¿estamos buscando Jurassic Park aquí? Creo que esa era la tarea. ¿Quiénes son los actores de Jurassic Park? Bueno, hemos visto este. Para recapitular, si las personas no pudieron escucharme claramente, agregamos el tipo de actores en nuestras definiciones de tipos aquí y agregamos la directiva de relación aquí en el campo de actores y película para permitirnos hacer consultas desde la película hacia los actores. Luego, en nuestra consulta, eso nos permitió escribir esta consulta para buscar Jurassic Park. ¿Quiénes son los actores de Jurassic Park? Genial. Y aquí podemos ver el cifrado generado. Ahora, la declaración de cifrado generada incluye este recorrido desde el actor hasta la película. Entonces puedes ver primero que se aplica el filtrado para encontrar la película, Jurassic Park. Y luego tenemos esta conexión desde la película hacia los actores. Genial. Una cosa a tener en cuenta aquí es que esto no nos da la capacidad de ir desde un nodo de actor para ver en qué películas ha actuado el actor. Y para ver eso, necesitaríamos agregar un campo de relación también al tipo de actor. Eso se vería así. Ahora el mismo tipo de relación va a ser 'actuado en' y esta vez la dirección va a ser saliente. Así como así. Ahora podríamos ir desde, en realidad, si construimos el esquema, podemos probar esto porque ahora para los actores, ahora podemos ver en qué otras películas han actuado. Aquí están las otras películas en las que Jeff Goldblum ha actuado. Genial, y creo que la última pregunta en nuestro ejercicio aquí es ahora seleccionar el botón de introspección, que podríamos haber hecho la primera vez. Entonces, cuando volvemos a las definiciones de tipos, tenemos esta opción aquí de introspección, dice que esto sobrescribirá sus definiciones de tipos actuales. Eso está bien. Ahora estamos inspeccionando la base de datos. Estamos viendo el modelo de datos en la base de datos y generando las definiciones de tipos de GraphQL para todos los datos en la base de datos. Lo interesante es que podemos ver aquí que hay algunas cosas que no hemos visto antes y algunas cosas que se ven un poco extrañas y que podríamos ajustar antes de usar esto realmente. Una cosa que vemos de inmediato es que hay una interfaz aquí llamada activo y propiedades. Ahora está utilizando esta directiva de propiedades de relación y lo que está sucediendo aquí es que en nuestro modelo de gráfico de propiedades y también deberíamos tener uno de estos para la calificación. Veamos la calificación. Esa es una que realmente usamos. Aquí, tenemos propiedades calificadas. Esa es la propiedad de relación. Y lo que está sucediendo aquí es que porque, en el modelo de gráfico de propiedades, almacenamos la calificación, así como el papel del actor en una película. Esa es información relevante para la relación o la conexión entre dos nodos. Y por eso tenemos una forma diferente de modelar propiedades de relación en GraphQL. Utilizamos el tipo de conexión de relay, que introduce el tipo de borde, si has visto esto antes, para trabajar con información meta sobre la conexión entre dos tipos en GraphQL, eso es un buen uso para el tipo de conexión de relay. Y para definir eso, ¿cuáles son las propiedades que hemos almacenado en las relaciones? Para eso, modelamos eso utilizando esta directiva de propiedades de relación, que luego se mapea a tipos de conexión de relay. Entonces, eso es algo que no hemos visto antes.

Lo otro que no hemos visto antes son estas directivas de etiquetas adicionales en el nodo actor. Bueno, dijimos anteriormente que en el modelo de gráfico de propiedades, podemos almacenar múltiples etiquetas en un nodo. Por ejemplo, el actor también tiene el nodo persona para indicar que esta es una persona, lo mismo ocurre para el director y así sucesivamente. Y en GraphQL, tenemos una directiva para agregar esa información adicional y capturar esa etiqueta adicional. También notarás que generamos un tipo actor dos, y esto se debe a que hay algunos nodos que tienen tanto la etiqueta actor director como la etiqueta persona. Por lo tanto, se agrega como un tipo separado, que realmente no necesitamos, así que podemos eliminarlo. Podemos eliminar el campo acted, dos acted in para conectar el tipo de película. Y luego cosas como estos actores acted in, la función de introspección utiliza algunas convenciones para codificar básicamente el tipo de relación y el tipo del otro nodo al que nos estamos conectando. Así que no necesitamos eso para ambos. Podemos simplemente decir que este es el campo actores aquí y similar a las calificaciones de usuario, tal vez una mejor manera de expresarlo. Así que puedes ver que esa función de introspección es realmente poderosa cuando tengo datos existentes en la base de datos y quiero generar la API de GraphQL basada en eso. Pero muchas veces, es algo que se genera, algo que podríamos querer ajustar un poco, lo cual podemos hacer en la caja de herramientas de GraphQL. Ahora, si presiono construir esquema, ahora podemos ver el esquema completo que se genera para nosotros.

Genial, nos quedan 45 minutos. Pasemos al siguiente ejercicio, que es conectar nuestra instancia de Aura a un servidor Node.js GraphQL real. En este caso, queremos escribir código que tenga la lógica para nuestra API GraphQL en lugar de usar la caja de herramientas de GraphQL. La caja de herramientas es útil para testing y desarrollo, pero no nos proporciona una API gráfica que podamos implementar en algún lugar. Para esto, echemos un vistazo a un code sandbox. Voy a copiar el enlace y dejarlo en el chat. ¿Alguien ha utilizado code sandbox antes? Si no estás familiarizado con code sandbox, te mostraré cómo se ve. Code sandbox nos permite ejecutar código JavaScript en el navegador, así que en este caso, como es código Node.js, crea un contenedor para nosotros y nos permite ejecutar ese contenedor y escribir código y editarlo en el navegador. El enlace que compartí está extrayendo código de GitHub para abrir un code sandbox. Luego puedes iniciar sesión en code sandbox con GitHub. Y si haces clic en este botón de bifurcación, el sandbox se volverá privado para ti. Y lo primero que queremos hacer aquí es echar un vistazo a este archivo .env.

Y ya hay una conexión de base de datos ficticiadatabase en ese archivo. Así que queremos actualizar esto para que apunte a nuestra instancia de Aura. Y copio la URI de conexión, reemplazo esa variable de entorno aquí. Este es el archivo .env, que establece las variables de entorno. En este caso, son como secretos, cosas que no quiero incluir en el control de versiones. El usuario será Neo4j. Y luego guardo la contraseña, ahí está mi contraseña. Así que guardaré eso. Y eso reiniciará mi sandbox. Y ahora debería poder escribir algunas consultas. Intentemos una simple, ups, opciones de películas. Hagamos solo un límite de 10, solo para probar que estamos conectados a nuestra database, obteniendo algunas películas, acceso activado. Bueno, reiniciemos eso. Creo que tal vez debemos reiniciar eso después de actualizar nuestras credenciales de conexión, trazando el plan de consulta, no necesitamos eso. Olvídalo, reiniciemos todo el contenedor.

El punto que quiero compartir aquí es realmente mostrar, aquí vamos, mostrar cómo se ve al ejecutarse fuera de la caja de herramientas, conectado a nuestra instancia de Aura. Así que estoy obteniendo este mensaje de error, se accede a database Neo4j no está permitido para el usuario recomendaciones con roles públicos. Y eso es esperado, ese es el error esperado que obtengo para los datos anteriores que había cargado aquí. Pero creo que no reiniciamos correctamente el contenedor tal vez. Voy a reiniciar el sandbox. Permítanme volver al contenedor. Así que creo que no recogió mis cambios tal vez en el archivo .env. Y no necesitamos esta database, pero estamos usando la database predeterminada. Mientras esperamos que se reinicie, echemos un vistazo al código que tenemos aquí. Así que lo haremos con index.js. ¿Qué está pasando aquí? Oh, sí, ahí vamos. Así que ahora reinicié el sandbox para recoger mis cambios en el archivo .env. Y ahora estamos conectados a mi instancia de Aura. Eso se ve bien. Pero veamos el código. Este es similar al fragmento de código que vimos antes, tal vez con algunas piezas adicionales. Estamos utilizando la integración de Neo4j GraphQL, estamos utilizando el servidor Apollo. Estamos utilizando la instancia del controlador de Neo4j. Un par de ayudantes, uno, fs nos permite leer desde el sistema de archivos, .env nos permite leer ese archivo .env y establecer esas variables de entorno. Estamos leyendo nuestras definiciones de tipo de este archivo de esquema.graphql. Y esto debería verse similar a las definiciones de tipo con las que estábamos trabajando en Playgrounds, es una versión simplificada, no incluyo todas las propiedades de relación y cosas así. Así que leemos esas definiciones de tipo o esas definiciones de tipo, creamos una instancia del controlador de Neo4j, utilizando nuestras variables de entorno, creamos una instancia del paquete Neo4j GraphQL con nuestras definiciones de tipo y el controlador. Y luego pasamos por el proceso de generación de esquema, eso toma nuestras definiciones de tipo, genera una API de GraphQL completamente funcional a partir de eso, y eso incluye generar nuestras funciones de resolución. Y luego pasamos eso a Apollo server. También estoy utilizando el complemento del servidor Apollo, que nos permite usar Playground de GraphQL, en lugar de que ahora el predeterminado sea Studios de Apollo, solo tratando de ser coherentes con el uso de nuestras herramientas allí. Entonces Rafael está preguntando con el esquema de Neo4j ¿también podemos usar el marco de trabajo Envelope? No estoy muy familiarizado con Envelope. Eso es la herramienta de la GraphQL Guild para... ¿Qué es exactamente eso? ¿Es para combinar servicios de GraphQL? Oh, para complementos. No estoy seguro, no lo he usado yo mismo. Esa es la respuesta. No estoy seguro. Bueno, es bueno intentarlo. Lo agregaré a la lista. Imagino... Quiero decir, básicamente todo lo que la biblioteca de Neo4j GraphQL está haciendo es generar resolutores a partir de definiciones de tipo, combinarlos para crear un objeto de esquema de Neo4j GraphQL, por lo que un objeto de esquema ejecutable. Y luego te da ese objeto para que puedas trabajar con él, que sigue la especificación de GraphQL y todas estas cosas. Así que deberías poder usar ese objeto de esquema luego con otras piezas de herramientas del ecosistema de GraphQL. Así que no estoy seguro específicamente sobre Envelope. Pero también para extender el contexto. Vale, puedes tener más información inyectada en el objeto de contexto con Envelope. Vale, genial. Sí, sí, eso sería algo para probar. No es algo que haya probado. Genial, así que eso es un vistazo a la conexión de nuestro ejemplo de código en ejecución en Code Sandbox a nuestra instancia de Aura. Tenía un ejercicio para esto, tal vez lo omitamos y hablemos un poco sobre la lógica personalizada y tal vez hablemos sobre la autorización también. Nos quedan unos 30 minutos. Asegurémonos de cubrir todo, y si no tenemos tiempo para trabajar en algunos de los ejercicios, tal vez sean algunas cosas con las que jugar después. Genial, así que hablemos sobre la lógica personalizada en nuestra API de GraphQL. Hasta ahora, solo hemos visto lo que llamamos CRUD, crear, leer, actualizar, eliminar, esa funcionalidad básica para generar una API de GraphQL. Pero no hemos visto cómo agregar lógica personalizada.

Tal vez tengamos alguna lógica de negocio. Siempre me gusta usar el ejemplo de recomendaciones, ¿verdad? Porque eso es algo que se puede aplicar a muchos dominios diferentes y demás. Pero esto realmente puede ser cualquier tipo de lógica personalizada más allá de la funcionalidad básica CRUD. Y hay dos formas de hacer esto con la biblioteca Neo4j GraphQL. Una es usar la directiva de esquema at-Cypher GraphQL. Así que vimos un ejemplo de esto cuando estaba hablando sobre las características de la biblioteca Neo4j GraphQL que nos permiten tomar declaraciones personalizadas de Cypher, vincularlas a nuestro esquema GraphQL. Y luego esas declaraciones se incluyen en la única consulta generada a la base de datos. Y luego el otro enfoque es, siempre podemos implementar resolvers. Así que podemos implementar resolvers personalizados y luego incluirlos en nuestro servidor GraphQL. y hacer que esos resolvers sean llamados junto con el resolver generado. Lo que debemos tener en cuenta aquí es que esos resolvers seguirán siendo llamados de esa manera anidada. Por lo tanto, es posible que terminemos haciendo múltiples viajes entre la consulta generada a la base de datos y nuestro resolver personalizado. Pero esto es común si tenemos otro sistema al que necesitamos llamar fuera de Neo4j.

Veamos algunos ejemplos de cómo usar esta directiva de Cypher. Vamos a volver a ver el ejemplo de la API de la Librería que vimos antes. Aquí estamos agregando un campo de subtotal al tipo de pedido. Recuerda que teníamos pedidos y los pedidos estaban conectados a libros. Podíamos colocar uno o más libros en un pedido, pero sería útil saber cuál es el subtotal. ¿Cuál es el precio de cada libro? Sumémoslos. Ese es el subtotal de nuestro pedido. Y así podemos definir fácilmente esa lógica en Cypher con la declaración de Cypher, haces coincidir esto. Entonces, con la directiva de Cypher, hay una variable, this, que se define automáticamente en estas declaraciones de Cypher. Y esto se refiere al objeto actualmente resuelto. Entonces, en este caso, esto se refiere al pedido que estamos resolviendo actualmente, similar al primer, creo que el primer argumento pasado a un resolver, que es el objeto que estamos resolviendo actualmente. Pero de todos modos, eso está disponible en las declaraciones de Cypher aquí con la palabra clave this. Haz coincidir donde este pedido contiene libros, devuelve la suma del precio del libro eso nos da el subtotal, que aquí hemos indicado que es un campo flotante. Una vez que hemos definido eso en el esquema, entonces ese campo de subtotal está disponible junto con todos los demás campos. No hay indicación para el cliente de la API de GraphQL de que haya algo especial en este campo. Podemos devolver escalares desde las declaraciones de Cypher. Podemos devolver una cadena, podemos devolver un entero, estamos devolviendo un flotante en el anterior. También podemos devolver nodos u objetos. Aquí está el campo recomendado, que me gusta usar como ejemplo. Aquí estamos agregando un campo recomendado en el tipo de cliente. Según el historial de compras de un cliente, ¿en qué otros libros podrían estar interesados puedes ver la consulta que estábamos usando aquí pasa por sus pedidos, sus pedidos contienen libros. ¿Qué otros pedidos hicieron otros clientes que contienen libros que este usuario no ordenó? Esos podrían ser buenas recomendaciones. Entonces, de las personas que leen los libros que estoy leyendo, ¿qué otros libros están leyendo que aún no he leído? Eso podría ser una buena recomendación. Básicamente eso es lo que dice la consulta de Cypher. Pero la parte importante aquí es que estamos devolviendo REC, que puedes ver aquí, REC es uno o más nodos de libro. Entonces indicamos aquí en nuestras definiciones de tipo de GraphQL que recomendado se resuelve en una matriz de objetos de libro. Y para que eso funcione en la declaración de Cypher, simplemente devolvemos objetos de nodo. Así que solo escribiré un poco de código en esto. Y aquí, estamos buscando libros recomendados para los clientes. Obtenemos un campo de objeto. Entonces necesitamos seleccionar el título de eso. Podemos usar argumentos de campo con los campos de la directiva de Cypher. Entonces, cualquier argumento de campo que agreguemos en las definiciones de tipo se pasan a la declaración de Cypher como parámetros de Cypher. Entonces aquí hemos agregado un argumento de límite, que es un entero, estableciendo un valor predeterminado de tres. Esto nos permite especificar el número de recomendaciones de libros a devolver. Entonces aquí, estamos diciendo que queremos devolver por defecto tres libros, pero en el momento de la consulta, podemos cambiar esto. Es útil saber aquí, si seguimos este camino, es útil establecer valores predeterminados para estos argumentos de campo, porque luego sabremos que siempre están definidos cuando estamos escribiendo nuestras declaraciones de Cypher como parámetros de Cypher. Entonces aquí especificamos. Solo queremos un libro recomendado. Ahora también podemos devolver objetos que no están almacenados en la base de datos desde un campo de directiva de Cypher. Y esto suena un poco extraño, pero esto es algo que podemos hacer. A menudo, tal vez queremos cambiar la forma de los datos que estamos devolviendo, o en este caso, como ejemplo, estamos llamando a un sistema externo utilizando un procedimiento de Cypher incorporado. Entonces, Cypher tiene una biblioteca estándar llamada APOC que agrega funcionalidad adicional al lenguaje de consulta, y uno de esos procedimientos nos permite llamar a otras API JSON. Entonces aquí, estamos haciendo una carga JSON de APOC llamando a esta API del clima, y así en este ejemplo, para nuestra dirección, entonces la idea es para nuestros repartidores que están entregando pedidos, los pedidos están conectados a un nodo de dirección, y en ese nodo de dirección, queremos agregar este objeto de clima que le dirá al conductor cómo está el clima en esa dirección. Agregamos un nuevo tipo, clima, que tiene cosas como temperatura, velocidad del viento, precipitación, este tipo de cosas, y luego estamos llamando a una API de clima externa para obtener esos datos. Y cuando lo devolvemos, puedes ver en la cláusula de retorno en nuestra declaración de Cypher, esto es una función de Cypher, de la que aún no hemos hablado, pero podemos devolver objetos o mapas o diccionarios que se proyectan a partir de los datos. Y así en este caso, estamos devolviendo un objeto de clima, aunque eso no se mapea a los datos que hemos almacenado en la base de datos, siempre y cuando lo hayamos definido en nuestras definiciones de tipo eso funcionará con GraphQL. Y nuevamente, eso se agrega como un campo de objeto adicional en el tipo de dirección aquí para que podamos ver el clima para estos varios pedidos.

Hasta ahora, los campos que hemos agregado han sido campos en tipos como libro, o dirección. No hemos visto campos de consulta personalizados a nivel de raíz o campos de mutación. Pero podemos usar directivas de Cypher en campos de consulta y mutación. Aquí estamos creando un índice de texto completo en la base de datos y luego agregando un campo de consulta. Un nuevo campo de consulta a nivel de raíz para realizar una búsqueda difusa de texto completo. Y este es un ejemplo un poco forzado porque en realidad podemos usar una directiva para habilitar la búsqueda de texto completo con la biblioteca de Neo4j GraphQL. Pero si tuviéramos alguna otra lógica para definir consultas a nivel de raíz, esto nos permite hacer coincidencias difusas con el título del libro. Aquí escribimos mal el título del libro y utiliza un índice de texto completo para encontrar cualquier coincidencia. Y podemos hacer lo mismo para las mutaciones. No hablamos mucho sobre la API de mutación que se genera cuando usamos la biblioteca de Neo4j GraphQL. Pero sigue la convención de generar un create, update y delete para cada operación, para cada tipo que definimos. Pero si queremos tener una lógica más personalizada, podemos tomar un objeto de entrada y luego definir un cipher de cómo queremos manejar esos datos en una mutación. Y luego, como dije antes, podemos usar la directiva de esquema de cipher o podemos escribir resolvers personalizados. Entonces aquí, hemos escrito un resolver personalizado para agregar un tiempo estimado de entrega a nuestro pedido. Esto, nuevamente, es bastante forzado porque esto es solo una función de JavaScript para encontrarlo al azar. Pero imagina que tuviéramos un sistema logístico más complejo o algo así donde tuviéramos que escribir algún código personalizado para llamar a ese sistema. Escribimos la función del resolver, y luego en las definiciones de tipo, agregamos la directiva ignore schema para indicar básicamente a la biblioteca de Neo4j GraphQL que vamos a ignorar este campo. No vamos a intentar obtenerlo de la base de datos. Estamos escribiendo un resolver personalizado para encontrarlo.

De acuerdo, tenemos un ejercicio para esto, para agregar un campo similar al tipo de película. Creo que nos quedan 20 minutos. Creo que lo que haremos en su lugar es dejar esto como un ejercicio y en su lugar hablaremos un poco sobre la autorización. Simplemente hablaré sobre esto y luego responderé cualquier pregunta que tengan las personas. Así que si tienen alguna pregunta, escríbanla en el chat y cualquier cosa que no hayamos cubierto, intentaré abordarla y al menos encontrar enlaces de seguimiento para compartir con las personas. Pero hablemos sobre algunas de las funcionalidades de autorización y luego podemos responder algunas preguntas al final aquí. Hay alguna funcionalidad de autorización incorporada en la biblioteca de Neo4j GraphQL. Se utiliza otra directiva de esquema para ello. Estas directivas de esquema son realmente muy poderosas. Creo que, la documentación, sí, aquí vamos. Esta página en la documentación enumera todas las directivas de esquema disponibles. Y como dije, así es como podemos configurar la API generada para la biblioteca de Neo4j GraphQL. En la directiva de autenticación, veamos la documentación. La directiva de autenticación, aquí vamos, así es como definimos las reglas de autorización para proteger los datos. Por lo tanto, nos aseguramos de que solo los usuarios que deben tener acceso a los datos puedan acceder a ellos a través de nuestra API. La convención con la directiva de autenticación es que usamos tokens web JSON, o JWT, o JWT como se les llama comúnmente. Y la idea con un token web JSON es que tomamos una carga útil JSON que tiene lo que se llaman reclamaciones. Por lo tanto, esto puede ser cosas como el ID de usuario, el correo electrónico, los roles que tiene el usuario. Y luego esas reclamaciones son firmadas criptográficamente por el servidor. Y luego podemos verificar que esas reclamaciones sean precisas, que sean reclamaciones válidas en la carga útil JSON, porque podemos verificar que eso fue firmado criptográficamente por nuestra aplicación. Y así pasamos este token web JSON como un encabezado de autorización en la solicitud de GraphQL, y luego la biblioteca de GraphQL decodificará ese token web JSON y aplicará esas reclamaciones a la solicitud de GraphQL. Aquí hay un ejemplo, simplemente muestra un token web JSON codificado y la carga útil JSON disponible. Y a menudo puedes encontrar estos si vas a la pestaña de red de tu navegador, puedes ver algunos de estos tokens que se usan en muchas aplicaciones web, puedes copiar el token, pegarlo en una herramienta como esta o decodificarlo y ver qué reclamaciones hay en él. Es algo interesante de hacer. Así que no necesitas la clave criptográfica para decodificar un token web JSON, siempre puedes leer las reclamaciones que hay en él, pero está firmado, por lo que sabemos que esas reclamaciones son verificadas por el servidor. Así que hablemos de un par de las reglas de autorización. Y nuevamente, esto es para la API de libros que estamos viendo. La regla de directiva de autorización más simple se llama ISAuthenticated. Y esto simplemente significa que la solicitud de GraphQL contiene un token web JSON firmado válido. Por lo tanto, en este caso, para acceder al tipo de sujeto, los libros tienen un sujeto, para acceder a eso, el usuario solo necesita estar autenticado. Y el caso de uso para esto podría ser en tu aplicación web, mostrar alguna información básica a los usuarios no autenticados, pero si desean obtener información más detallada, al menos necesitan registrarse e iniciar sesión en tu aplicación. Aquí se muestra la diferencia cuando somos un usuario no autenticado que solicita un campo protegido versus el usuario autenticado. Y aquí puedes ver cómo adjuntamos el token de autorización aquí como un encabezado de autorización en la solicitud de GraphQL. La siguiente regla de autorización se llama Roles. Y lo que esto significa es que, para acceder al campo protegido o al tipo protegido en la API de GraphQL, el token web JSON debe tener un cierto rol en la reclamación de Roles. Y aquí estamos diciendo que para el tipo de libro, para realizar cualquiera de las operaciones de mutación, crear, actualizar o eliminar, el usuario debe ser un administrador, debe tener un rol de administrador. Por lo tanto, solo los administradores pueden actualizar o eliminar datos. Y Allow es la siguiente regla de la que hablaremos. Y esto significa que, para acceder a la información, un valor del token web JSON debe coincidir con algún valor en la base de datos. Y en este caso, estamos mirando la reclamación sub. Así es como accedemos a las reclamaciones del token web JSON. Usamos este signo de dólar, JWT punto. Y luego las reclamaciones en la carga útil JSON. Sub es la convención para el suscriptor en un token web JSON. ¿Entonces esto está diciendo que el nombre de usuario almacenado en la base de datos debe coincidir con el sub, la reclamación del suscriptor en el token web JSON en la solicitud de GraphQL para acceder a los pedidos del cliente? Esto sigue una relación que va desde el nodo de pedido hasta el nodo de cliente, asegurando que el nombre de usuario coincida con el valor en el token para poder ver el pedido. Aquí tienes un ejemplo donde buscamos un cliente específico y sus pedidos. Y estamos correctamente autenticados como ese usuario. Sin embargo, si estamos autenticados como un usuario diferente, aquí estamos solicitando todos los pedidos, obtenemos un error aquí. Y esto es un poco problemático porque tal vez el cliente no sabe qué datos no tiene acceso. Entonces, en lugar de lanzar un error, sería bueno si solicitamos todos los pedidos, simplemente obtuviéramos los pedidos a los que tenemos acceso. Y eso es lo que veremos a continuación.

Una cosa más sobre allow. En cualquiera de estas reglas, realmente, podemos combinarlas. Así que la matriz de reglas aquí que estamos pasando en la directiva de autenticación, esto es una lógica OR. Esto significa que, para acceder a un pedido, debes estar autenticado como el usuario que realizó ese pedido o debes ser un administrador. Pero volviendo al problema aquí, donde estamos devolviendo un error porque el cliente ha solicitado información a la que no tiene acceso sin realmente saber que no tiene acceso a esa información. Para solucionar eso, podemos usar la regla where. Aquí estamos diciendo que, para acceder a la información del cliente, el nombre de usuario del nodo del cliente debe coincidir con la reclamación del suscriptor en el token web JSON. Esto significa que se agregará un predicado a la declaración de Cypher generada para filtrar cualquier dato al que el usuario no tenga acceso. Aquí estamos autenticados como un usuario, estamos solicitando todos los clientes y sus pedidos. Pero debido a la regla de autorización where, la consulta generada solo incluye los datos a los que el usuario autenticado tiene acceso, que es solo la información de ese usuario. El usuario autenticado actualmente. Bind es útil para mutaciones. Básicamente nos permite definir una regla que debe existir cuando ejecutamos una mutación. Aquí, para una revisión, estamos diciendo que el autor de la revisión debe ser el usuario autenticado actualmente. No queremos que puedas actualizar, crear revisiones y luego decir que alguien más las escribió. El autor debe ser el usuario autenticado actualmente. También podemos usar reglas de autorización en las directivas de Cypher. Hay un par de formas de hacerlo. Una es aplicar reglas como la directiva is authenticated y la directiva role. Esas se verificarán antes de ejecutar la declaración de Cypher, o también podemos acceder a la carga útil JWT en nuestra declaración de Cypher como variables de Cypher, parámetros de Cypher. Aquí estamos usando la regla is authenticated en una declaración de Cypher. Por lo tanto, libros para el usuario actual, no tiene sentido intentar buscar libros para un usuario no autenticado porque eso nos daría un error al buscar el cliente por este nombre de usuario. Puedes ver aquí cómo accedemos a auth.JWT.sub. Entonces, este auth.JWT, este es un parámetro especial que estamos usando aquí para inspeccionar la carga útil del token web JSON que hemos adjuntado en el encabezado de la solicitud de GraphQL, decodificado ahora, inyectado en nuestra declaración de Cypher para agregar lógica personalizada. Buscamos al cliente por nombre de usuario y luego recorremos el grafo para encontrar, ¿qué es esto básicamente? Todos los libros, oh, esta es una consulta de recomendación. Estos son todos los libros que han pedido, encontrando el tema de esos libros, luego usando el tema para encontrar otros libros en los que podrían estar interesados. Y me gusta usar la consulta de recomendación, es útil como un caso de uso que se aplica en muchos dominios. Bien, y luego hay un ejercicio aquí sobre autorización, que también omitiremos por falta de tiempo. Hay muchas cosas que no cubrimos hoy. Hay muchas funcionalidades interesantes que no hemos tocado, como el uso de tipos abstractos en GraphQL. Uniones e interfaces. Esos también están disponibles con la biblioteca Neo4j GraphQL, que nos brinda una forma muy expresiva de trabajar con tipos abstractos. Hay un OGM o mapeador de gráficos de objetos completo disponible para construir consultas de base de datos programáticamente, pero usamos definiciones de tipo GraphQL para definir los modelos con los que trabajamos. Hablamos un poco sobre las propiedades de las relaciones. Hablamos un poco sobre las agregaciones y luego mencioné algunas de las otras directivas disponibles. Si estás interesado en ver parte de la funcionalidad, simplemente navegando por la documentación enlazada aquí puede ser útil. Para reiterar algunos de los problemas que surgen con GraphQL, esta idea de rendimiento del problema de la consulta N más uno, de la productividad de la velocidad en el código repetitivo, espero que puedas ver cómo se aborda eso con Neo4j y la biblioteca Neo4j GraphQL. Hay algunos recursos enlazados al final de las diapositivas aquí. Anteriormente mencioné que escribí este libro, Aplicaciones Full-Stack GraphQL. Este libro está disponible para descargar de forma gratuita en este enlace aquí, que compartiré en el chat. Y nuevamente, el libro entra en mucho más detalle sobre cómo no solo construimos el backend de nuestra aplicación, sino también cómo integramos una API de GraphQL que hemos construido en nuestra aplicación frontend. Entramos en muchos detalles sobre cosas como la funcionalidad de autorización, cómo hacer que funcione con Auth0, servicios en la nube, etc. Así que definitivamente vale la pena descargarlo, vale la pena echarle un vistazo si estás interesado en el aspecto de GraphQL de pila completa. Esta es una buena página de inicio para todo lo relacionado con Neo4j GraphQL. También hay algunos recursos enlazados allí, así como algunos ejemplos para explicar parte de la funcionalidad que hemos hablado hoy. Y luego, por supuesto, las diapositivas, enlaces al código, enlaces a la documentación también. Muchas gracias a todos por unirse hoy y nos vemos la próxima vez. ¡Saludos!