Construyendo APIs GraphQL con la biblioteca Neo4j GraphQL

ReactJS, a través de la boca de asistentes de proyectos y gerentes de proyectos. Bueno, hola a todos. Gracias por unirse hoy. Vamos a construir APIs de GraphQL para sandboxing, que es un database alojado como servicio. No es necesario configurar entornos locales. Vamos a hacer todo con estos entornos de sandbox alojados. Así que no se preocupen por configurar un entorno local, pero hablaremos de eso en un momento.

Los diapositivas están vinculadas en dev.neo4j.com slash GraphQL dash training, enlace en el chat aquí. Recomiendo abrir estas diapositivas mientras trabajamos en esto. Hay varios enlaces y fragmentos de código y cosas así, que es posible que deseen tomar de las diapositivas. Así que recomendaría abrir las diapositivas mientras avanzamos y tenerlas abiertas en una pestaña. También está el Discord, que Lara enlazó al principio. Así que estaré monitoreando tanto el chat de Zoom como Discord también. Eso es cualquiera de los dos. Si tienen preguntas, simplemente escríbanlas en el chat, ya sea en Zoom o Discord, e intentaré monitorear ambos y compartir enlaces en ambos.

Mi nombre es Will. Trabajo para una compañía llamada Neo4j, que es una base de datos de grafos que utilizaremos hoy. También co-presento un podcast llamado graphstuff.fm. Así que si están interesados en la tecnología de grafos y les gusta el formato de podcast, definitivamente les animo a que lo revisen. Aquí está nuestro esquema general para hoy. Hablaremos un poco sobre qué es Neo4j. Creo que como eso era completamente nuevo para la mayoría de las personas, dedicaremos un poco de tiempo allí pero realmente nos enfocaremos en GraphQL y en la construcción de APIs de GraphQL respaldadas por Neo4j. Así que hablaremos un poco sobre Neo4j, luego hablaremos un poco sobre GraphQL y cómo se construyen típicamente las APIs de GraphQL. Luego echaremos un vistazo a la biblioteca Neo4j GraphQL que es una biblioteca de Node.js JavaScript para construir APIs de GraphQL respaldadas por Neo4j. Luego veremos cómo agregar lógica personalizada a nuestra API. Y luego, en el módulo final, veremos cómo agregar reglas de autorización a nuestra API. Vamos a construir una API de una librería. Así que nos enfocaremos en la parte del backend de esto, no tanto en qué hago realmente con mi API de GraphQL una vez que la haya construido. En cambio, nos enfocaremos solo en la parte del backend. Por lo tanto, no cubriremos la integración, por ejemplo, de una API de GraphQL en una aplicación React o algo así. Nos enfocaremos solo en la parte del backend.

Como mencioné anteriormente, estaremos construyendo No necesitaremos preocuparnos por configurar un entorno de desarrollo local. Hoy utilizaremos estos servicios de Cloud Sandbox. Hay dos cosas que utilizaremos. Uno es Neo4j Aura DB. Hay un nivel gratuito de Neo4j Aura. Neo4j Aura es una instancia de Neo4j alojada en la nube que es privada para nosotros. Hay un nivel gratuito. Por lo tanto, no tendrán que ingresar una tarjeta de crédito ni nada por el estilo, lo cual es bastante bueno. Lo utilizaremos para nuestra base de datos. Todos tendrán la oportunidad de crear una instancia de Aura. Y luego, para ejecutar el código, estaremos construyendo una API de GraphQL utilizando JavaScript. Una aplicación de API de GraphQL en Node.js. Y para eso, utilizaremos Code Sandbox. Code Sandbox nos permite ejecutar código en el navegador, incluyendo código de Node que se ejecuta en un contenedor en algún lugar que ellos alojan para nosotros, lo cual es bastante bueno. Por lo tanto, no tendremos que preocuparnos por lidiar con problemas de desarrollo en entornos locales. Cada uno de estos módulos, debería decir, supongo que los últimos tres módulos tienen un enlace a un código de inicio básico en Code Sandbox con algo de código inicial. Comenzaremos de esa manera y luego realizaremos ejercicios, editando código, escribiendo consultas GraphQL, ese tipo de cosas. Verán este ícono de ejercicio práctico en algunas diapositivas. Cuando lo vean, nos detendremos durante unos minutos y nos adentraremos en algunos ejercicios. Me gustaría que esto sea lo más práctico posible. Y a medida que tengan preguntas, simplemente escríbanlas en el chat, ya sea en Zoom o en Discord, y responderemos a sus preguntas.

Genial, hablemos un poco sobre Neo4j antes de sumergirnos en la construcción de APIs GraphQL. Creo que la mayoría de las personas dijeron que Neo4j era nuevo para ellos, lo cual es genial. Supongo que tal vez ¿con qué tecnologías de base de datos están familiarizados? ¿La mayoría de las personas han utilizado bases de datos relacionales o tal vez Mongo, háganoslo saber en el chat. Si están familiarizados con bases de datos relacionales o bases de datos de documentos, las bases de datos de grafos son un concepto similar, ¿verdad? Entonces, aquí es donde almacenamos, modelamos y consultamos nuestros datos de la aplicación. La diferencia con una base de datos de grafo, como Neo4j, debería decir, una de las primeras diferencias que se nota es que el modelo de datos no son tablas, ni documentos. Un modelo de datos es un grafo. Y cuando decimos grafo, nos referimos a nodos. Estas son las entidades en nuestros datos y relaciones, que las conectan. Específicamente con Neo4j, utilizamos el modelo de datos de grafo de propiedades, del cual hablaremos un poco. Básicamente, eso significa que podemos almacenar propiedades de pares clave-valor arbitrarios en nodos y relaciones.

Con Neo4j, utilizamos un lenguaje de consulta llamado Cypher. Puedes pensar en Cypher como SQL, pero para grafos. Cypher se centra mucho en la coincidencia de patrones. Hay un ejemplo de declaración Cypher en la parte superior derecha de la pantalla en esta primera línea, donde dice match, y luego tenemos este patrón de grafo. Match es como una declaración que dice, es como una declaración que dice, encuentra algunos datos en el grafo donde existe este patrón. Y luego el patrón, dibujamos esta representación de arte ASCII de un grafo. Entonces tenemos address entre paréntesis, esos paréntesis son como dibujar un círculo, eso es un nodo. Entonces estamos diciendo encuentra nodos de dirección con una relación de dirección registrada entrante. Así que ves cómo estamos dibujando esa flecha entre corchetes que está conectada a un nodo de oficial, y luego atravesando desde ese oficial a nodos de entidad, filtrando donde la dirección contiene Nueva York. Esta declaración Cypher está diciendo, encuentra nodos de dirección donde la dirección está en Nueva York, y encuentra oficiales que tienen una dirección en Nueva York, y luego, ¿a qué entidades están conectados? Este conjunto de datos proviene, esta consulta proviene de los Papeles de Panamá o el conjunto de datos de los Papeles de Pandora, que es una investigación periodística de datos que utilizó Neo4j para dar sentido a estructuras complejas de entidades legales offshore en la banca offshore. Así que haremos un poco con Cypher hoy. Principalmente, nos centraremos en usar GraphQL y generar consultas Cypher a partir de GraphQL. Así que escribiremos un poco de Cypher cuando lleguemos a la sección de lógica personalizada. Pero si no has visto Cypher antes, solo quería mostrar algunos de los conceptos allí esta idea de coincidencia de patrones de grafo. Entonces hay muchas implicaciones interesantes de usar una base de datos de grafo en lugar de una base de datos de documentos o una base de datos relacional. Una es que podemos hacer muchas análisis de grafos interesantes con bases de datos de grafo, porque podemos modelar nuestros datos de manera diferente y eso nos permite, creo, escribir estas consultas muy interesantes que son equivalentes a escribir muchas uniones en SQL simplemente expresando este patrón de grafo lo cual es bastante bueno. También hay herramientas para visualización de datos en las que podríamos tocar un poco hoy. Y luego tenemos muchas integraciones. Entonces supongo que si pensamos en la base de datos como el código, la base de datos toca muchas piezas diferentes de la arquitectura de la aplicación, ¿verdad? Entonces la base de datos se encuentra en el núcleo de nuestra arquitectura, pero necesitamos poder mover datos de un lado a otro y hay muchos casos de uso diferentes que podemos tener para usar una base de datos en primer lugar. Así que desde el espectro a la derecha donde hablamos de cosas como análisis y casos de uso de ciencia de datos. Y luego en el extremo izquierdo del espectro donde hablamos más sobre aplicaciones operativas, transaccionales que estamos construyendo. Tal vez estamos construyendo una red social o sitios de e-commerce o algo así donde queremos cargas de trabajo más transaccionales y operativas. Y estamos interesados en cosas como construir una capa de API que se va a situar entre el cliente y la base de datos y pensar en las herramientas que vamos a usar allí. Así que para nuestra masterclass de hoy, estamos muy interesados en este extremo izquierdo del espectro donde estamos interesados en construir la capa de API para una aplicación de cliente. Y en este caso, nos vamos a centrar en hacer eso en GraphQL.

Genial, Anthony dice que está familiarizado con SQL Server, Firebase y Mongo. Genial, genial. Ahora puedes agregar Neo4j a esa lista después de hoy. Aquí tienes algunos recursos. Las diapositivas son probablemente las más importantes. Hay un enlace para las diapositivas en el chat, dev.neo4j.com/graphql-training. Permíteme dejar eso en el chat una vez más. Sé que a veces el chat desaparece y es un poco molesto desplazarse. Así que ese no es un enlace clickable. Intentémoslo de nuevo. Dev.neo4j.com/graphql-training. Genial.

Como dije, vamos a utilizar estos entornos de código sandbox y hay un enlace específico para cada uno. Así que si abres las diapositivas, al menos tenlas en una pestaña para consultarlas. Será útil tomar los enlaces y algunos fragmentos de código y cosas mientras trabajamos en los ejercicios. Todo el código de hoy también está enlazado aquí. Dev.neo4j.com/graphql-training-code. Y estas son las consultas de GraphQL con las que trabajaremos en algunos de nuestros ejemplos. Esta podría ser una buena para tener a mano también. Y luego las otras cosas aquí, así que vamos a utilizar la biblioteca de Neo4j GraphQL. La documentación está enlazada aquí. Hay una página de descripción general de la biblioteca de GraphQL, enlaces a aplicaciones de ejemplo y otros recursos, así como un entrenamiento a tu propio ritmo que profundiza mucho más en detalle de lo que cubriremos hoy.

En cuanto al tiempo de hoy, debería haber dicho que esta es una sesión de tres horas y llevamos 20 minutos. Ese es el plan para hoy. Como dije, nos vamos a centrar en la parte del backend, no tanto en el aspecto del frontend. Así que si estás interesado en ver cómo encajan las piezas para una aplicación de pila completa, incluyendo cómo se ajusta el frontend. Hay un proyecto de inicio llamado GRANDstack. Ese es GraphQL, React, Apollo, Neo4j. Ese inicio de GRANDstack es un buen lugar para ver cómo encajan las piezas en el contexto de una aplicación de pila completa. Pero eso no será nuestro enfoque hoy. Hoy nos centraremos solo en la parte del backend. Genial, así que hablamos un poco sobre Neo4j, creo que tal vez veamos un ejemplo más práctico. Voy a mostrar este. Veamos este ejemplo. Esto debería ser público. Veamos, compartiré el enlace, si puedo recordar la contraseña aquí. Creo que news graph es uno de los usuarios. Voy a agregar eso. Sí, esto es opcional, voy a mostrar algunas consultas en Neo4j Browser aquí. Así que si quieres seguir, dejaré un enlace en el chat y luego el nombre de usuario es newsgraph y la contraseña también es newsgraph. Este es Neo4j Browser, es como un banco de trabajo de consultas para Neo4j. Escribo consultas Cypher y luego obtengo los resultados, ya sea en un entorno visual, pero este es el entorno de desarrollo común para trabajar con Neo4j. Tengo datos cargados aquí desde la API de New York Times. Este es un conjunto de datos de artículos de noticias. Creo que se ejecuta continuamente para rastrear los artículos de noticias más compartidos cada día. Así que tenemos cosas como artículos, los artículos se refieren a temas o están relacionados con personas, las organizaciones se refieren a una región geográfica y tienen fotos. Puedo ejecutar db.schema.visualization para ver, restablezcamos nuestro estilo aquí, ahí vamos. Puedo ejecutar esto para ver cuál es mi modelo de datos. Puedo ver los nodos que tengo y cómo están conectados esos nodos. Los artículos están relacionados con organizaciones o con una región geográfica, con personas. Tienen fotos y temas. Puedo escribir consultas Cypher. Por ejemplo, digamos que quiero encontrar los artículos más recientes. Puedo escribir una declaración Cypher utilizando este concepto de coincidencia de patrones de grafo. Así que el patrón para este es bastante simple. Estoy diciendo que encuentre nodos con la etiqueta artículo. Cuando decimos nodos de artículo, lo que estamos diciendo es encontrar nodos que tengan la etiqueta artículo. La etiqueta es una forma de agrupar nodos en la base de datos, similar a una tabla o una colección de una base de datos de documentos, es el mismo nivel conceptual para pensar en estos, supongo. Luego tenemos estas propiedades de pares clave-valor. Cada artículo tiene un título, la fecha en que se publicó, la URL del artículo y luego una descripción. Cuando pensamos en términos de GraphQL, lo que vamos a hacer es mapear nodos y etiquetas de nodos, específicamente, supongo, a tipos en GraphQL y cómo están conectados. Por supuesto, podemos escribir patrones mucho más complejos. Por ejemplo, podríamos decir, ¿tenemos alguna consulta de ejemplo aquí, veamos? Ya hemos escrito algunas interesantes. No, está bien. Digamos, encontremos artículos que tengan el tema, digamos ejercicio. Mi flecha va en la dirección equivocada, va así. Y nuevamente, no te preocupes por seguir el ritmo. Vamos a iniciar nuestra instancia de Aura. Pero si quieres, he enlazado el nombre de usuario y la contraseña para esta base de datos.

Estamos utilizando esto como una especie de API ORM aquí, asumiendo que lo tenemos disponible para consultar nuestra base de datos. En este caso, comenzaríamos buscando una sesión con una cadena de consulta y vamos a la base de datos y decimos encontrar todas las sesiones por el término de búsqueda y eso volvería a nuestro servidor de GraphQL y luego iteraríamos a través de ese conjunto de selección y veríamos, oh, el usuario también pidió en qué sala están estas sesiones. Entonces, el resolutor de la sala volvería a la base de datos para cada sesión que coincida con nuestra cadena de búsqueda, diría aquí está la sala en la que está y luego haría algo similar para el tema y para las recomendaciones. Puedes ver que estamos haciendo esto de manera anidada, ¿verdad? Es posible que para una operación de GraphQL hagamos múltiples viajes a nuestra capa de datos. Esto se llama el problema de la consulta N más uno, que es algo común que surge en GraphQL, que es que tenemos la posibilidad de hacer múltiples viajes a la capa de datos por una sola solicitud de GraphQL. Y esto puede ser problemático por razones de rendimiento, ¿verdad? Como que incurre en cierta sobrecarga ir a la base de datos, ir a la capa de datos cada vez. Sería mejor si pudiéramos, en una sola operación, ir a la base de datos y decir, aquí está todos los datos que necesito para esta operación de GraphQL. Y eso vuelve. Entonces, este problema de la consulta N más uno, esto es algo que surge. Hay diferentes formas de abordar esto. Existe el patrón del cargador de datos, que nos permite hacer un poco de agrupamiento y almacenamiento en caché de objetos. Lo que vamos a hacer hoy con la biblioteca Neo4j GraphQL es ver que podemos generar realmente una sola consulta a la base de datos. En nuestro caso, esta será una única consulta de CYPHER en el nivel raíz para cualquier solicitud de GraphQL arbitraria. Entonces, lo que eso significa es que en realidad no implementaremos resolutores, en cambio, vamos a dejar que la biblioteca Neo4j GraphQL se encargue de eso por nosotros, y eso nos brinda algunas ventajas aquí. Una es que no tenemos que escribir este tipo de sintaxis de plantilla para obtener datos de la base de datos, en cambio, la biblioteca se encargará de eso por nosotros. Y luego, tampoco tenemos que preocuparnos por el problema de la consulta N más uno porque esto significa que nuestra consulta a la base de datos se generará automáticamente en el nivel raíz, lo cual es bastante bueno.

Es posible que hayas visto los beneficios de usar GraphQL. Esta idea de abordar el exceso y la falta de datos, donde no enviamos demasiados datos a través de la red, obtenemos exactamente los datos que el cliente necesita para renderizar una vista. No tenemos que hacer múltiples solicitudes como lo haríamos en una API REST para acceder a diferentes recursos. Simplemente podemos agregar más cosas a nuestro conjunto de selección para obtener los datos que necesitamos en nuestra aplicación. Y luego, algunos de los desafíos que surgen, hablamos del problema de la consulta N más uno. Pero en mi opinión, creo que la forma de abordar la mayoría de estos desafíos de GraphQL es que muchas de las prácticas que provienen del mundo REST no se aplican de manera clara en el mundo de GraphQL. Cosas como el manejo de errores son un poco diferentes, ¿verdad? Podemos tener errores en diferentes niveles en nuestro conjunto de selección. Por lo tanto, debemos pensar en el manejo de errores de manera un poco diferente. La caché, de manera similar, las consultas de GraphQL pueden ser un tanto arbitrarias. Por lo tanto, no podemos simplemente almacenar en caché un cierto punto final o una cierta URL como podríamos hacerlo en el mundo REST. Y también cosas como cómo manejamos el costo de las consultas y la limitación de la tasa, nuevamente, relacionado con esta idea de la complejidad arbitraria de las consultas de GraphQL. Estos son algunos de los desafíos que surgen. Hay herramientas y mejores prácticas que abordan todos estos, pero creo que estas son cosas importantes de las que debemos estar conscientes y que pueden surgir.

Hoy vamos a utilizar GraphQL Playground. GraphQL Playground es una herramienta en el navegador para consultar e inspeccionar APIs de GraphQL. Quizás hayas visto Graphical o Apollo Studio, que tiene algo llamado Explorer. Creo que eso está integrado en Apollo Studio, que ahora es el valor predeterminado con Apollo Server. Estas herramientas son similares. Me gusta usar GraphQL Playground porque podemos alojarlo en nuestros puntos finales de GraphQL. Así que eso es lo que vamos a usar hoy. Y vamos a echar un vistazo a Playground en un minuto. En realidad, ahora mismo, si queremos.

Para esta parte práctica, lo que me gustaría que todos hagan es ir a movies.near4j-graphql.com, y verás GraphQL Playgrounds en esa URL. Y tómate unos minutos para explorar la pestaña de documentación, para ver cómo se ve el esquema y luego escribir algunas consultas de GraphQL. Solo para familiarizarnos con la forma en que funcionan, por ejemplo, nuestros argumentos de límite. Aquí estamos buscando las primeras 10 películas, obteniendo alguna información, y también estamos filtrando por directores. Así que voy a ir a movies.neo4j-graphql.com. Voy a dejar un enlace a eso, tanto en Zoom como en Discord. Así que deberías ver algo como esto. A la derecha, tenemos la pestaña de documentación. Esto nos permite inspeccionar la API. Podemos ver los puntos de entrada de la consulta, podemos ver los campos disponibles en cada tipo. Y podemos escribir algunas consultas de GraphQL. Ten en cuenta que es bastante útil debido a esta idea de la introspección, podemos usar control más espacio para obtener sugerencias de autocompletado, así que podemos agregar campos. Aquí estamos agregando la biografía de cada director, lo cual es bastante útil. De todos modos, tómate unos minutos. Todos pueden escribir algunas consultas de GraphQL y familiarizarse con GraphQL Playground si no lo has visto antes, mirando en la pestaña de documentación y usando control más espacio para autocompletar, agrega algunos campos a estas consultas y copia y pega estas, compartiré las consultas en Discord. Es bastante fácil de hacer. Aquí está la primera consulta en Discord y dejaré el enlace para la otra en Discord también, para que puedas copiar y pegarlas. Genial, haremos una pausa aquí por un par de minutos para que todos tengan la oportunidad de familiarizarse con GraphQL Playground y esta API y luego continuaremos. Si tienes alguna pregunta o problema, avísanos en el chat. Haremos una pausa por solo un par de minutos, así que si necesitas un descanso, volveremos a empezar en un par de minutos.

Entonces, otra cosa que la biblioteca Neo4j GraphQL hace por nosotros es básicamente tomar nuestro GraphQL y generar una API de GraphQL que tiene operaciones CRUD, es decir, operaciones de creación, lectura, actualización y eliminación para cada tipo que hemos definido. En el lenguaje de GraphQL, estas son cosas como generar los tipos de consulta y mutación para la API, agregar argumentos para cosas como el ordenamiento y la paginación, filtrado complejo, y también agregar soporte para trabajar con cosas como la fecha y hora, como los tipos temporales y los tipos espaciales disponibles en la base de datos. Además, se generan cosas como agregaciones y operaciones más complejas. Todo esto se genera automáticamente para nosotros. No tenemos que agregarlos explícitamente a nuestro esquema.

Luego, en el momento de la consulta, para cualquier operación de GraphQL arbitraria que enviemos, la biblioteca Neo4j GraphQL genera una única consulta a la base de datos por nosotros. Esto significa que no tenemos que escribir estas funciones de resolución. La biblioteca se encarga de generar la consulta a la base de datos por nosotros. No tenemos que preocuparnos por eso. No tenemos que escribir consultas Cypher para construir nuestra API de GraphQL. No necesitamos hacer eso. Solo necesitamos pensar en Cypher cuando lleguemos a considerar cosas como agregar lógica personalizada. Esto es realmente bueno para la productividad del desarrollador. Podemos tener una API de GraphQL en funcionamiento respaldada por una base de datos simplemente escribiendo algunas definiciones de tipo. Y luego, el aspecto del rendimiento. Esto resuelve el problema de las consultas n++ generando una consulta a la base de datos y enviándola a la base de datos para que figure cómo optimizarla. Y las bases de datos gráficas como Neo4j son realmente buenas en el recorrido del grafo de datos. Eso es para lo que están optimizadas las bases de datos gráficas. Así que muchas veces, en GraphQL, terminamos creando estas consultas que tienen una estructura muy anidada, un conjunto de selección muy anidado. Y las bases de datos gráficas son muy buenas en el recorrido de ese grafo. En términos de implementación de la base de datos, lo que está sucediendo allí es algo llamado adyacencia sin índices, lo que significa que en Neo4j, en la base de datos, podemos recorrer desde un nodo a cualquier otro nodo al que ese nodo esté conectado, recorriendo las relaciones. Podemos hacer eso sin usar un índice. Entonces, en una base de datos relacional, para hacer lo mismo, que sería una unión, estamos usando un índice para ver dónde se superponen dos tablas, una operación de conjunto. Y eso tiene que usar un índice, lo que significa que se ralentiza a medida que crece el tamaño de esas tablas. Pero en Neo4j, el recorrido, que es equivalente a una unión, básicamente estamos siguiendo punteros, yendo a un desplazamiento, que es algo en lo que las computadoras son muy rápidas, por lo que es más una operación de tiempo constante que solo depende del número de relaciones que estamos recorriendo, no del tamaño total de los datos. Entonces, a medida que agregamos más datos al grafo, nuestras travesías de un nodo a otro se mantienen con el mismo rendimiento para esos. Eso es lo que sucede en el fondo, y por eso las bases de datos gráficas son realmente buenas para recorrer relaciones.

De acuerdo, ese es uno de los objetivos de la biblioteca Neo4j GraphQL. El otro es exponer lógica personalizada a través de Cypher. Dijimos que la biblioteca genera operaciones CRUD basadas en las definiciones de tipo. No tenemos que escribir ningún Cypher, ninguna lógica de obtención de datos. Solo tenemos que escribir nuestras definiciones de tipo. Eso es genial para operaciones CRUD básicas. ¿Pero qué pasa cuando tenemos lógica personalizada? Bueno, para eso, podemos usar declaraciones Cypher en nuestras definiciones de tipo de GraphQL utilizando las directivas de esquema de Cypher. Las directivas de esquema son como anotaciones en nuestra API de GraphQL, en nuestras definiciones de tipo, que básicamente indican que debe ocurrir alguna lógica personalizada en el servidor. Nos permite extender cosas en GraphQL. Esta directiva de esquema de Cypher es como una anotación que agregaríamos a nuestras definiciones de tipo. Toma un único argumento, que es una declaración Cypher. En este ejemplo, estamos agregando un campo recomendado, creo que en un tipo de negocio. Esto es para una aplicación que tiene negocios y reseñas de usuarios de negocios. Piensa en algo como buscar restaurantes y querer restaurantes recomendados. Conozco un restaurante que me gusta. Aquí hay otros negocios, otros restaurantes que también podrías gustarte. La declaración Cypher aquí encuentra usuarios que han reseñado el negocio que estamos resolviendo actualmente y luego busca otros negocios que esos usuarios han reseñado y utiliza el número de coincidencias como puntaje para la recomendación. Esta es una consulta de recomendación de filtrado colaborativo donde estamos utilizando información de otros usuarios en la red para generar recomendaciones personalizadas. Este es un ejemplo bastante básico de filtrado colaborativo, pero creo que la idea se aplica a casos más avanzados. Pero este tipo de recorrido es muy expresivo en Cypher y las bases de datos gráficas. Ahora podemos agregar este campo recomendado a nuestro tipo de negocio para el cliente de nuestra API. Ellos no saben que este es un campo personalizado con esta lógica definida por Cypher. Solo ven un campo recomendado que les proporciona un arreglo de objetos de negocios. Creo que esta es mi característica favorita de la biblioteca Neo4j GraphQL. Es muy poderoso porque esto significa que podemos utilizar cualquier funcionalidad que tengamos en Cypher y exponerla en nuestra API gráfica, lo cual es muy poderoso. Notarás, supongo, una cosa interesante, que tenemos esta palabra clave aquí. Esto se refiere al objeto de negocio actualmente resuelto en este caso. Es como una variable especial que se inyecta en la declaración Cypher. Veamos cómo empezar con la biblioteca Neo4j GraphQL. No vamos a seguir esto. Vamos a pasar a un ejemplo de Code Sandbox en un minuto, pero quiero repasar los conceptos. Entonces, instalaremos la biblioteca Neo4j GraphQL y sus dependencias, que es la implementación de referencia de GraphQLJS y el controlador de Neo4j. Estos controladores de base de datos nos permiten crear una conexión con la base de datos, ya sea que se esté ejecutando localmente o en la nube, todo lo que haremos con él es simplemente crear esa conexión y luego pasar ese controlador a la biblioteca Neo4j GraphQL. Luego, en este caso, estamos usando Apollo server, que es bastante agradable y simple para crear servidores gráficos. Pero podríamos usar cualquier servidor gráfico, cualquier implementación de servidor gráfico en JavaScript, con la biblioteca Neo4j GraphQL. Aquí tienes un fragmento mínimo y viable. Veamos qué está sucediendo aquí. Lo primero que hacemos es importar nuestras dependencias. GraphQL, el controlador y Apollo server.

Luego definimos algunas definiciones precisas. Esto es solo para películas y géneros. Y observa aquí que estamos utilizando esta directiva de esquema de relaciones. Entonces dijimos que en el modelo de grafo de propiedades, cada relación tiene una dirección y un tipo con nombre. GraphQL no tiene ese mismo concepto para los campos de relación. Entonces necesitamos poder codificar eso porque estamos generando el modelo de base de datos a partir de estas definiciones de tipo. Entonces necesitamos poder especificar esos datos en la definición de tipo. Lo hacemos con esta directiva de esquema de relaciones para especificar el tipo y la dirección.

Luego creamos una conexión a nuestra base de datos utilizando el controlador de JavaScript de Neo4j. Hay una URI de conexión, que es la configuración predeterminada si estamos ejecutando localmente con Neo4j desktop o Docker, por ejemplo. Luego hay diferentes formas de autenticación, pero en este caso estamos utilizando un nombre de usuario y una contraseña. Luego creamos una instancia de la clase Neo4j GraphQL pasando nuestras definiciones de tipo y el controlador. Eso nos da un objeto de esquema ejecutable que luego entregamos a Apollo server, que servirá nuestra API de GraphQL. Así que ten en cuenta que no estamos escribiendo ningún resolvedor, no tenemos que escribir ninguna lógica de obtención de datos. Básicamente, lo único que estamos haciendo es escribir definiciones de tipo, entregarlas a la biblioteca Neo4j GraphQL, obtener un objeto de esquema ejecutable y pasarlo a Apollo server. Si iniciamos esto, tendríamos un punto final de GraphQL en ejecución localmente. Esa es la idea básica de lo que estamos haciendo. Puedes ver que la mayor parte del aspecto interesante aquí estará en escribir nuestras definiciones de tipo, configurar las directivas de esquema y entregar eso a la biblioteca Neo4j GraphQL.

De acuerdo, eso es todo. Genial. Bueno, pongámonos manos a la obra con un ejemplo en CodeSandbox. Lo que haremos durante el resto de la masterclass es construir una API de GraphQL para una librería en línea. Así que lo primero que normalmente haríamos es pasar por este proceso de modelado de datos en grafo. Ahora, alguien ya lo ha hecho por nosotros en este caso, vamos a comenzar con un esquema existente. Pero creo que es útil hablar sobre cómo llegamos a los tipos, cómo llegamos al modelo de datos con el que terminamos. Y pienso en este proceso de modelado de datos en grafo como un proceso iterativo, donde lo primero que hacemos es identificar cuáles son las entidades en nuestros requisitos comerciales, básicamente. Así que comenzamos con algunos requisitos comerciales que son como, necesito como usuario buscar libros por una cadena de búsqueda o buscar libros por tema. Como usuario, quiero poder agregar libros a un pedido. Como usuario, quiero poder enviar una reseña de un libro, esas cosas. Nuestros requisitos comerciales, identificamos las entidades, pensamos en qué propiedades estamos almacenando. ¿Cómo están conectadas estas entidades? Y cómo se convierten en relaciones. Y luego dibujamos el modelo de grafo. Y luego la siguiente parte es pensar en las preguntas que tenemos a partir de nuestros requisitos comerciales. Entonces tal vez necesito ver todos los libros en un pedido para un cliente específico. Y pienso, ¿puedo recorrer el grafo para responder esa pregunta? Bueno, ¿puedo ir desde un cliente a un pedido, desde el nodo de pedido puedo recorrer los libros contenidos en el pedido? Así que sí, puedo responder esa pregunta recorriendo el grafo. De esta manera, paso por cada una de esas preguntas para mis requisitos comerciales. Y si puedo responder todas las preguntas que quiero responder, entonces he terminado. Mi modelo de grafo está listo para usar. Si no, es posible que deba iterar un poco más. Así que pienso en esto como un proceso muy iterativo. Este es el modelo de datos que vamos a utilizar hoy. Así que tenemos libros. Los libros tienen un título, precio y descripción. Los libros tratan sobre un tema. Tenemos autores. Hay autores de libros. Tenemos pedidos que contienen libros y se envían a una dirección. Los clientes pueden realizar un pedido y los clientes también pueden escribir reseñas que están conectadas a un libro. Este modelo de datos, por cierto, utilizamos una herramienta llamada Arrows. Así que Arrows.app. Dejaré un enlace en el chat y en Discord. Utilizamos esta herramienta Arrows para diagramar nuestro modelo de datos. Fundamentalmente, Arrows es una herramienta de diagramación de gráficos, pero es muy conveniente. Nos permite expresar el modelo de grafo de propiedades. Por ejemplo, aquí hay uno, esto no es exactamente con lo que estamos trabajando, es de un proyecto similar, pero es muy similar. Podemos arrastrar nodos, por ejemplo, el usuario escribió una reseña. Y luego, bueno, la reseña debe estar conectada a un libro. Así que podemos actualizar nuestro modelo de esta manera. Y luego podemos guardarlo en control de versiones, podemos exportar el JSON y guardarlo en control de versiones, lo cual es bastante bueno. Esto es todo, ¿lo perdimos? No, tenemos la etiqueta libro.

No sé por qué se ve raro eso. Etiqueta libro. También podemos exportar definiciones de tipos GraphQL. Aunque no parece que tenga una etiqueta en libro por alguna razón está ahí. Borremos nuestro... Oh, tenía un duplicado. Genial. Libro. Así que pasamos por este proceso de modelado de datos en Arrows y podemos exportarlos como, Oh, necesito al menos una propiedad. Así que libro, vamos a darle un título. Ahí vamos. Ahora, estamos generando definiciones de tipos GraphQL que podemos copiar y pegar y entregar a la biblioteca Neo4j GraphQL solo con este diagrama. Esto es realmente bueno. Nos permite pasar rápidamente de diagramar nuestro modelo de datos a generar definiciones de tipos GraphQL, básicamente copiar y pegar en algún código de plantilla. Y tenemos una API de GraphQL, que es muy poderosa.

Vale, lo siguiente que queremos hacer es configurar nuestro entorno de Code Sandbox. Comenzaremos con este Code Sandbox específico. Hay tres de estos para los módulos restantes. Tendremos un punto de partida para cada uno de estos módulos. Lo que tenemos que hacer es que todos abran el Code Sandbox y luego lo hagan un fork. Si aún no están registrados, deberán iniciar sesión en Code Sandbox, pero es gratuito registrarse con algo como GitHub o correo electrónico. Y luego el Code Sandbox será privado para ustedes. Solo ustedes podrán editarlo. Lo que vamos a hacer es configurar nuestro entorno de Code Sandbox inicial para que apunte a nuestra instancia de Neo4j Aura. Así que vamos a abrir el enlace de Code Sandbox aquí, que pondré en el chat. Dev.neo4j.com/graphql-sb1-sandbox1. Aquí está la parte1. Verán algo como esto. Y lo primero que queremos hacer es hacer clic en este botón de fork. Así que pueden ver aquí, si miran en esta URL larga, esto solo está extrayendo código de GitHub. Todo el código de los ejemplos que veremos está en GitHub. Pero vamos a hacer un fork de esto, y luego en ese punto necesitaremos iniciar sesión, parece que ya estoy registrado. Así que cuando hagan clic en fork, les pedirá que inicien sesión. Y luego les dará un nuevo Code Sandbox, que solo ustedes podrán editar. Tenemos un editor de código y luego tenemos la aplicación web, y en este caso, el Playground de GraphQL se está ejecutando aquí a la derecha, y la terminal. Así que vamos a editar todo nuestro código en Code Sandbox en el navegador aquí. Pero tenemos una plantilla de inicio básica. Veamos qué está sucediendo aquí. Este será nuestro editor de código. ¿Qué está pasando aquí? Esto será en estructura bastante similar al ejemplo de inicio que vimos, con algunas cosas agregadas. Estamos importando la biblioteca Neo4j GraphQL, Apollo server y el controlador Neo4j JavaScript. Y luego algunas utilidades. Estamos cargando algunas variables de entorno desde este archivo. Es posible que las suyas estén en blanco o que tengan valores antiguos aquí. Vamos a reemplazar estos con los valores de nuestra instancia de Aura. Vamos a hacer eso. Así que voy a volver a la consola de Aura y voy a copiar la URI de conexión. Pegar eso aquí. Y luego mi contraseña se generó cuando inicié la instancia y dijimos que necesitábamos guardarla en algún lugar. Así que la pegaremos aquí, y cuando guarde esto, iré a archivo, guardar. Lo guardo, reiniciará mi aplicación porque estamos usando node bond, y ahora estará conectada a mi instancia de Neo4j Aura, que inicié en el módulo anterior. Vale, estamos leyendo algunas variables de entorno. Luego estamos leyendo el archivo schema.graphql en nuestro tipo dev. Así que schema.graphql, así que si lo miramos, esto coincide con el modelo de datos que estábamos viendo hace un momento con clientes, pedidos, libros y reseñas. Luego entregamos esas definiciones de tipo cuando instanciamos la clase Neo4j.graphql, creamos una instancia del controlador Neo4j.driver, y aquí es donde estamos leyendo esas variables de entorno. Los valores que establecemos aquí en el archivo .env se están utilizando aquí como variables de entorno para especificar nuestra conexión a Neo4j. Luego entregamos ese objeto de esquema ejecutable a Apollo server, iniciamos nuestra API de GraphQL, que si miramos en el lado derecho de la pantalla, así que si necesitan más espacio en la pantalla, pueden copiar esta URL y abrirla en una nueva pestaña. Esto será privado, esta será una URL diferente para su Code Sandbox. Pero eso puede ser útil. Sin embargo, voy a hacer todo desde aquí, porque quiero ver la terminal, los resultados de la consola aquí. Y así, si todo funciona, si todo está conectado, deberíamos poder, por ejemplo, hacer clic en la pestaña de docs aquí y ver nuestros puntos de entrada. Así que tenemos campos de consulta para pedidos, recuento de pedidos, esto es como una agregación, direcciones de clientes. Y luego tenemos todas estas operaciones de mutación para crear, actualizar y eliminar pedidos y libros, y cosas así. Así que si todo está conectado correctamente, deberíamos poder ejecutar una consulta. ¿Qué tal si me das todos los libros y el título de cada libro? Y así lo ejecuto, por supuesto, obtengo una matriz vacía porque no tengo ningún dato en la base de datos. Pero puedo ver que no obtuve un error, así que realmente pude hacer una consulta a la base de datos. Y si miro en la consola aquí, puedo ver algunas cosas registradas. Me está diciendo que, vale, hay una solicitud de GraphQL entrante, aquí está la consulta, sin variables, no hay un token web JSON. Definitivamente usaremos tokens web JSON cuando lleguemos a la sección de autenticación. Y luego aquí está la consulta Cypher generada. Así que la biblioteca Neo4j GraphQL ha tomado esta solicitud de GraphQL y ha generado esta consulta Cypher y la ha enviado a la base de datos. Y, por supuesto, no se devuelve nada porque no tenemos libros, pero esto es genial porque puedo agregar otros campos. Así que eso también no sé, digamos, traer el precio del libro, ahora puedo ver que la consulta Cypher incluye también la propiedad de precio. Y así, a medida que agrego operaciones más complejas, ¿qué más tengo para libro, tengo alguna reseña? Puedo buscar reseñas para todos los libros. Y, por supuesto, sigo obteniendo una matriz vacía, pero la consulta Cypher generada ahora incluye este patrón de gráfico para encontrar cualquier reseña conectada al libro. Así que la consulta Cypher se genera específicamente para la operación de GraphQL, lo cual es bastante agradable, significa que no tuvimos que escribir ninguna lógica para obtener datos. Vale, vamos a usar esto como un punto de partida esquelético para agregar algunas cosas más a nuestra API. Así que vamos a hacer una pausa aquí por un par de momentos, dar a todos la oportunidad de abrir el enlace de Code Sandbox. Así que ese es este enlace aquí, dev.newfjetter.com/graphql-sb1, que debería estar en el chat tanto en Zoom como en Discord. Y luego hacer un fork del Code Sandbox y actualizar el archivo .env con las credenciales de conexión para su instancia de Aura. Y luego eso reiniciará su aplicación de API de GraphQL en Code Sandbox y escribir una consulta simple, solo esta de libros y título es buena. Y deberían obtener una matriz vacía. No deberían ver ningún error. Así que si ven un error, sabremos que algo salió mal, pero esa es la configuración básica.

Bien. ¿Cómo les va a todos? ¿Alguien tiene configurado su Code Sandbox, funcionando, conectado a su instancia de Aura? ¿Alguien está obteniendo errores? Bien. Entonces creo que podemos continuar. Bien, no veo a nadie quejándose en el chat de que haya tenido errores. Así que asumiré que todos hemos configurado nuestro Code Sandbox y estamos conectados a nuestra instancia de Aura y estamos listos para continuar. Genial. Entonces, estos son los pasos que queremos seguir. Si no hemos provisionado nuestra instancia de Aura anteriormente, definitivamente queremos obtener la cadena de conexión de la Consola de Aura aquí. Esta es la cadena de conexión para nuestra database. Y luego, cuando iniciamos o provisionamos por primera vez la instancia de Aura, nos da la contraseña, que vamos a tomar ambas, ponerlas en este archivo dotenv en nuestro Code Sandbox para conectar nuestra API de GraphQL a nuestra instancia de Aura. Genial, así que espero que todos hayan llegado hasta aquí. Hablemos un poco sobre las definiciones de tipos con las que estamos trabajando. Si miramos el archivo schema.graphql, en nuestro Code Sandbox, así que ese es este archivo aquí. Podemos ver que estas definiciones de tipos corresponden al modelo de datos del grafo que creamos anteriormente cuando pasamos por este proceso de modelado de datos del grafo para pensar en qué son las entidades, cómo están conectadas, ese tipo de cosas. Hay un par de cosas interesantes que quiero señalar. Una es la directiva de esquema de relación que mencionamos antes. La usamos para especificar la dirección y el tipo de la relación. Pero también verán otras directivas que estamos usando. Por ejemplo, la directiva de marca de tiempo que tenemos en el campo playlist at. Así que playlist at es de tipo date time. Primero que nada, estamos usando date time. También estamos usando este tipo de punto. Estos son agregados por la biblioteca Neo4j GraphQL. para exponer tipos temporales y espaciales que están disponibles en la database. Así que punto, date time, local date time, date, ese tipo de cosas. Sin embargo, timestamp es una directiva que podemos usar para indicar que queremos que este valor se genere automáticamente en el servidor. Así que cuando creamos un pedido, esto indica que se establezca la propiedad place at como la fecha y hora actual. No queremos que el cliente sea responsable de eso. No queremos que el cliente diga, sí, esta es la hora actual que puede ser. Un problema para el cliente hacer eso y también sería una vulnerabilidad de security. Queremos que se establezca en el servidor. La directiva ID es similar, eso indica, bueno, este es el campo que queremos usar para identificar la unicidad, pero también queremos que se genere un UUID automáticamente cuando se crea este objeto de pedido. Así que genera un ID único aleatorio, establece eso como el valor del ID del pedido. El cliente no necesita ser responsable de eso. Estos son algunos ejemplos de cómo estamos usando directivas para configurar el esquema que estamos creando. Hay algunas directivas más. Si miramos en la documentation, dejaré un enlace a esto en el chat también. Esta es la página de documentation. para la biblioteca Neo4j GraphQL, que es útil tener mientras trabajamos en esto. Pero aquí puedes ver que hay varias directivas que usamos para configurar nuestro esquema. Por ejemplo, la directiva auth, que usaremos bastante en un momento, nos permite agregar reglas de autorización a nuestro esquema.

Bien, eso son las directivas. Veamos cómo agregar algunos data a nuestra database utilizando mutaciones de GraphQL. Voy a cambiar a Code Sandbox aquí. Y espero que sea lo suficientemente grande para ver. Quiero hacer todo en Code Sandbox aquí para que podamos ver el cifrado generado. Creo que es útil para razonar sobre ello. Bien, ¿qué queremos hacer? Queremos crear algunos data en nuestra database utilizando una mutación de GraphQL. Así que primero, si miramos la pestaña Docs, hasta ahora los ejemplos que hemos estado usando han sido todas operaciones de consulta, pero necesitamos comenzar creando algunos data. Así que podemos ver que tenemos create, delete, update, mutación generada para cada tipo que hemos definido. Aquí está la de orders, create orders toma, create orders toma un objeto de entrada de tipo order create input. Y podemos ver que toma cosas como los costos de envío, los libros de los clientes, que se pueden usar para conectar en este caso a libros existentes o para crear nuevos libros. Así que puedes ver que en realidad podemos hacer cosas bastante sofisticadas aquí si pensamos en estas diferentes operaciones que tenemos disponibles en este objeto de entrada. Pero empecemos de forma sencilla. Comencemos creando un solo libro. Así que vamos a ver la mutación. así que mutaciones create books. Entonces este book create input es con lo que vamos a trabajar. Así que diremos mutación create books, toma un objeto de entrada. En realidad, esto es un array de objetos de entrada. Podríamos crear varios libros en una sola operación, pero solo haremos uno. Así que el libro va a tener un número ISBN. Lo inventaremos. Así que ISBN, esto es como el, no sé, como el ID del libro en algún formato internacional. Creemos nuestro libro Algoritmos de Grafos. Eso está disponible para 3748.

Tiene una descripción. Esto es un ejemplo para Neo4j y Apache Spark. Y luego, para nuestros conjuntos de selección, vamos a traer el libro, el título, el ISBN y el precio. Correcto, solo los campos que especificamos. Y luego también tenemos este objeto de información, que usaremos para decirnos el número de nodos que se crearon, si los hay.

De acuerdo, genial, así que vamos a ejecutar esto. Y dice, sí, ahora tenemos un libro llamado Algoritmos de Grafos. Creamos un nodo. Si nos desplazamos hacia abajo, en nuestra consola podemos ver la consulta Cypher generada, lo cual es genial. Así que está haciendo una declaración de creación, estableciendo algunos valores de propiedad. Genial, ahora podríamos abrir esto en el navegador de Neo4j para verificar que realmente creamos algunos datos. De hecho, hagámoslo. Si vuelvo a Aura, puedo ir a abrir con y puedo abrir el navegador de Neo4j, que vimos antes, o Neo4j Bloom, Bloom es como una herramienta de exploración visual sin código, así que Bloom es bueno si quiero explorar visualmente los datos del grafo sin escribir ningún Cypher. Pero hagamos el navegador por ahora. Y luego necesitaré... Cerraremos esto para que comience con una guía útil. Lo cerraremos. Y luego necesito ingresar mi contraseña, que guardé por aquí en algún lugar. Genial. Así que estoy dentro y puedo escribir una consulta Cypher que dice, hacer coincidir todo, devolver todo. Esto dice, encontrar todos los nodos. Anteriormente, teníamos algo como un artículo o algo así aquí que era la etiqueta. Esta 'a' se refiere a la variable que podemos usar para referirnos a cualquier nodo que coincidamos con este patrón más adelante. Esto simplemente dice, encontrar todos los nodos en la base de datos y devolverlos. Y dice, sí, tienes un libro, estas son las propiedades del libro. Así que eso es lo que creamos aquí. Así que hemos creado un solo nodo, eso está bien, pero tenemos un modelo de datos mucho más rico con el que trabajar. Veamos cómo crear una reseña. Así que ejecutemos otra operación de mutación. Entonces diremos mutación. Y esto va a ser crear reseñas, que va a tomar el objeto de entrada. Oh, mi contenedor ha hibernado. Reiniciémoslo. Reiniciando el navegador, ¿necesito reiniciar este navegador? No. De acuerdo. Así que solo necesito reiniciar nuestro contenedor. Sí. Así que estamos escribiendo esta entrada de creación de reseñas. Entonces la reseña, toma una calificación. Vamos a darle a este libro cinco estrellas. Esta es realmente la mejor descripción general de la ciencia de datos del grafo. Realmente lo es. Es un gran libro. Así que esa es la reseña, que creará el nodo de la reseña. Pero necesitamos conectar este nodo de reseña al libro, no al que creamos anteriormente. Así que tenemos un campo de libro. Y tenemos dos opciones aquí. Podemos hacer una operación de creación. Así que podemos crear un nuevo libro o podemos conectar a un libro existente. Esta es una reseña para el libro Algoritmos de Grafos. Así que nos vamos a conectar a un libro existente. Y luego tenemos un argumento where que podemos usar para especificar algún filtrado. Así que probablemente deberíamos usar el ISBN aquí, ya que es como el ID canónico que se refiere al libro, pero no puedo recordar lo que escribí. Acabo de inventar algo. Así que usemos solo el título, pero no es interesante todas las opciones que tenemos aquí para el filtrado. Básicamente podemos hacer cualquier filtrado en cualquiera de estos campos de nuestro tipo de libro. Pero lo que queremos hacer es filtrar por donde el título es Algoritmos de Grafos. Así que esto va a crear un nodo de reseña, establecerá el texto y la calificación, y luego creará una relación con el libro existente. Y luego en nuestro conjunto de selección, traeremos todas las reseñas que creamos. ¿Qué tal texto, calificación y también queremos asegurarnos de que sea para el libro correcto? Y luego también tenemos este objeto de información, que podemos usar para devolver el número de relaciones creadas. Así que ejecutaremos esto. Obtenemos algunas propiedades de nuestra reseña. Dice, sí, estamos conectados al libro Algoritmos de Grafos. Si echamos un vistazo ahora en el navegador de Neo4j, así que podemos escribir una nueva consulta Cypher, simplemente hacemos doble clic en esto para recorrerlo. Sí, aquí hay un nodo de reseña que está conectado al libro Algoritmos de Grafos. Y tiene una calificación, texto y una marca de tiempo de creación. Y recuerda que no tuvimos que especificar ese valor de creación en nuestra mutación de GraphQL. Esto fue establecido por el servidor porque usamos esa directiva de esquema de GraphQL para la marca de tiempo. Ese valor se establece automáticamente para nosotros.

De acuerdo, genial. También podemos crear estructuras más complejas. Estas mutaciones tienen estas operaciones anidadas de creación y conexión. Así que en realidad podemos crear subgrafos más complejos. Intentemos ejecutar esta. En lugar de escribir esto, simplemente voy a copiar esto. ¿Qué me falta? Ah, me falta el conjunto de selección. Y luego esta parte. Ahí vamos. Así que esta es en realidad una operación bastante compleja. ¿Qué estamos haciendo? Ahora estamos comenzando desde crear clientes. Estamos creando un nuevo cliente, y luego para las reseñas de este cliente, vamos a conectar. Vamos a crear un nuevo nodo de cliente y conectar relaciones a las reseñas que este cliente ha escrito. En este caso, donde el texto dice la mejor descripción general de la ciencia de datos del grafo, que debería coincidir, este nodo. Nuevamente, deberíamos estar usando un ID o algo para la reseña, pero esto funciona. Luego vamos a crear pedidos para el cliente, y vamos a agregar el libro de algoritmos de gráficos a ese pedido para el envío a, que esta es la relación con la dirección. Entonces, si miramos nuestras definiciones de tipo para el pedido, podemos ver que el pedido tiene libros, tiene un cliente, y tiene un campo de relación enviado a, que está conectado a una sola dirección. Y el nodo de dirección tiene una dirección y una ubicación, que es un punto, que estamos especificando aquí. Y la entrada para crear nuestro nodo de dirección, que luego se conectará al pedido, que está conectado al cliente. Así que puedes ver toda esta estructura que estamos creando en una sola operación de GraphQL. Así que ejecutemos esto. Y nuevamente, podríamos ver la consulta Cypher generada aquí. Si quisiéramos. Termina siendo bastante complejo nuevamente, porque estamos creando varios nodos y relaciones. Y podemos encontrar esto en el navegador. Así que ahora en el navegador de Neo4j, podemos recorrer. Sí, aquí está este usuario que escribió una reseña de este libro. También realizaron este pedido. Ten en cuenta que el pedido tiene un ID de pedido generado automáticamente. Esto se debe a que usamos la directiva de esquema ID para decir, hey, queremos generar esto automáticamente. Y luego tenemos la marca de tiempo de colocación, que también se genera automáticamente para nosotros. Y podemos ver que estamos enviando a esta dirección. Y el pedido contiene este libro. Genial. Así que ese es el concepto de operaciones de mutación anidadas donde podemos crear muchas cosas en una sola mutación de GraphQL. Podemos crear nodos, podemos crear relaciones, y así sucesivamente.

De acuerdo, genial. Si estabas siguiendo eso, vamos a borrar nuestra base de datos. Hay una mutación aquí en esta diapositiva, y voy a pegar esto. En realidad, déjame hacer esto ahora. Lo que queremos hacer es eliminar todos los datos en nuestra base de datos. Así que si no ejecutaste ninguna de estas mutaciones, no tienes que preocuparte por borrar los datos, pero luego vamos a ejecutar esta mutación. La cual no tengo nitro en Discord, así que no puedo pegar, pero creo que puedo enviar esto como un fragmento. Bueno, lo haré en dos partes. Déjame enviar uno para el conjunto de selección. Ahí vamos. Ok, así que si tienes las diapositivas abiertas, esta es la diapositiva 50 que es esta operación de mutación. También lo pegué en Discord, pero lo que queremos hacer primero es abrir el navegador de Neo4j. Así que, en la consola de Aura, deberías ver tu instancia de Neo4j listada aquí. Ve a abrir con el navegador de Neo4j, te pedirá tu contraseña aquí, y se verá así. Luego vamos a ejecutar esta consulta Cypher, así que coincidir, oh, está en Discord también, coincidir con un detach eliminar a. Asegúrate de estar en la instancia correcta de Neo4j, porque esto eliminará todos los datos en la base de datos. Y una vez que hagas eso, luego queremos ejecutar esta larga mutación, que creará algunos datos de muestra para que trabajemos en la siguiente sección. Así que voy a ir al navegador de Neo4j, digamos que coincida con un detach eliminar. La razón por la que digo detach, es porque esto coincide con todos los nodos. Y luego podría decir eliminar a, y eso eliminaría los nodos, pero no puedo tener relaciones con los nodos que se están eliminando. Relaciones sin el nodo, por lo que el detach simplemente reconoce que también quiero eliminar todas las relaciones conectadas a todos los nodos que también estoy eliminando. Ok, he eliminado cinco nodos. Así que ahora no tengo ningún dato en mi base de datos, y voy a copiar esta mutación, y entrar al playground de GraphQL aquí, pegar esto y ejecutarlo. Y hemos creado tres libros y algunos clientes, podemos ver esto en la base de datos, esto es lo que creamos, tres libros, algunos pedidos, algunos clientes, algunas reseñas, algunas direcciones y así sucesivamente, básicamente algunos datos de muestra con los que queremos trabajar, así que haremos una pausa aquí y daremos a todos un par de minutos para borrar su instancia de Neo4j y luego copiar y pegar esta mutación y verificar que hayan creado algunos datos en Neo4j, así que esto será los datos de muestra que usaremos para ver algunas de las funciones que se agregan para la consulta con la biblioteca Neo4j GraphQL y luego también veremos cómo agregar lógica personalizada. Antes de llegar a la lógica personalizada, el siguiente ejercicio será agregar algunos tipos faltantes, así que si estás un poco adelante de nosotros, puedes echar un vistazo al siguiente ejercicio si quieres ver cómo actualizaríamos las definiciones de tipo de GraphQL y luego comenzaremos a agregar autores y temas que no incluimos en nuestro esquema inicial, pero hagamos una pausa aquí hasta la hora en punto, dos minutos si necesitas tomar un descanso o quieres asegurarte de que hayas hecho funcionar esta mutación, así que si tienes algún error o algún problema, avísanos en el chat, de lo contrario, comenzaremos en dos minutos. Muy bien. ¿Todos pudieron ejecutar esa mutación para crear datos en la base de datos? Grita en el chat si no pudiste o si tuviste algún problema con eso, de lo contrario, pasaremos a ver cómo podemos consultar estos datos que hemos creado. Ok, veamos cómo consultamos estos datos. Hemos visto las mutaciones que se generan para nosotros. Vimos este concepto de estas operaciones de mutación anidadas donde podemos crear nodos, conectar a nodos existentes, crear relaciones. Ahora veamos el lado de la consulta. Hemos definido nuestras definiciones de tipo. No definimos explícitamente cosas como el ordenamiento y la paginación y el filtrado, todas estas cosas. No las definimos nosotros mismos en nuestras definiciones de tipo. Eso se agregó a la API para nosotros por la biblioteca Neo4j GraphQL. Así que veamos algunas funciones de las cosas que se generaron para nosotros que nos permiten consultar estos datos. Por defecto, cada tipo que hemos definido en nuestras definiciones de tipo de GraphQL tiene un campo de consulta en plural en el nivel superior. Así que el tipo libro se convierte en libros, pedido se convierte en pedidos, solo para referirnos, solo para indicar que es un campo de matriz de objetos. Cada uno de estos se convierte en un punto de entrada de consulta a nuestra API. Una forma de pensar en esto es el campo de consulta, el punto de entrada a la API, que se convierte en el punto de partida para un recorrido a través del grafo de datos. Y por supuesto, a medida que agregamos más campos a nuestros conjuntos de selección, la consulta a la base de datos que se genera en segundo plano tiene en cuenta eso para resolver todos los datos que hemos solicitado. Para el ordenamiento y la paginación, en la entrada de opciones, o en el argumento de opciones, tenemos opciones de entrada para ordenar por campos del tipo en orden ascendente y descendente. Podemos hacer paginación basada en offset utilizando límites y offset. Dame los primeros 10, salta 10 para la segunda página, salta 20 a la siguiente página, y así sucesivamente. Y aquí es donde entran las consultas de recuento. Vimos que hay puntos de entrada de libros, también hay un punto de entrada de recuento de libros, que nos puede decir el número total de libros. Podemos usar eso para calcular nuestras divisiones para la paginación basada en offset. Así que sabemos cuántos libros totales hay, sabemos que los estamos dividiendo en segmentos de 10, así que sabemos cuántas páginas totales vamos a tener. También podemos hacer paginación basada en cursor utilizando los tipos de conexión de relay de Neo4j GraphQL library. Así que aquí, por ejemplo, estamos buscando un pedido específico, y luego hay un campo de relación libros. También hay un campo de conexión de libros disponible. La conexión de libros nos dará los tipos de conexión de especificación de relay, que nos dan cosas como la información de página. Y también, por ejemplo, para obtener un cursor que nos permita hacer paginación basada en cursor para iterar a través de estas conexiones. Luego usamos esta sintaxis de bordes y nodos en estilo relay para obtener los nodos reales en este caso, para obtener los libros reales que están conectados a este pedido. Así que esta consulta está diciendo, encuentra un pedido específico y luego usa la paginación basada en cursor para paginar a través de todos los libros en el pedido. No sabemos si tenemos un pedido que tiene muchos libros, esto puede ser útil. Diferentes opciones para la paginación. Para el filtrado, hay un argumento 'where' que se incluye. Esto está tanto en el campo de consulta raíz como también anidado dentro del conjunto de selección. También podemos aplicar este filtrado. Los filtros que están disponibles para cada campo dependerán del tipo del campo. Así que para campos de cadena, tenemos operadores comunes de comparación de cadenas. Cosas como comienza con, contiene, termina con, este tipo de cosas para campos numéricos. Tienes mayor que, menor que, esas cosas. Así que aquí estamos buscando todos los libros que tienen un precio menor a 20, supongo que esto sería $20. Mencioné que los argumentos 'where' se pueden utilizar en el campo de consulta raíz o también anidados en el conjunto de selección. Es importante tener en cuenta que el filtro se aplica en el nivel donde se utiliza el argumento 'where'. Por ejemplo, en este ejemplo, estamos buscando libros donde el precio es menor a 20, y luego para esos libros, el precio es menor a 20. Estamos obteniendo todas las reseñas que se crearon después de una fecha específica.

Entonces, estamos filtrando los libros y luego estamos filtrando las reseñas. No estamos diciendo 'muéstrame solo los libros que tienen una reseña creada después de esta fecha'. Este filtro para la fecha se aplica a las reseñas de los libros ya filtrados, si eso tiene sentido. Por lo tanto, el filtro se aplica en el nivel del conjunto de selección donde lo utilizo. Podemos filtrar basado en la distancia geográfica. En nuestros nodos de dirección, tenemos una propiedad de ubicación que es un punto, una latitud y longitud. Para cualquier campo de punto, se genera un filtro que nos permite buscar por distancia de radio dentro de los puntos. Aquí estamos diciendo 'encuentra todas las direcciones que están dentro de un kilómetro de este punto'. Esto es en algún lugar del área de California. Y obtenemos una dirección en San Mateo, que es la única que está dentro de un kilómetro de donde sea que esté este punto. Así que acabamos de decir, en la diapositiva anterior, que los filtros pueden filtrar basado en la distancia geográfica. Pueden ser anidados, pero se aplican en el nivel donde usamos el argumento de filtro, donde usamos el argumento 'where' en esencia. Pero, ¿qué pasa si queremos que el filtro se aplique en un nivel más alto? En este caso, queremos filtrar pedidos. Queremos que el filtro se aplique en el nivel raíz. Pero en lo que queremos filtrar es en pedidos que tienen un nodo de dirección donde la ubicación del nodo de dirección está dentro de un kilómetro de este punto. Para hacer eso, utilizamos el filtrado a través de nuestras relaciones. Creamos una estructura anidada en nuestro argumento 'where'. Aquí estamos diciendo 'encuentra pedidos donde la distancia de la ubicación de envío es menor a un kilómetro desde este punto'. Puedes ver que estamos anidando el filtro de envío en este argumento 'where'. Y terminamos con solo un pedido que fue enviado a una dirección dentro de un kilómetro de este punto.

De acuerdo, genial. Así que eso es un vistazo a algunas de las semánticas de consulta generadas como parte de la biblioteca Neo4j GraphQL. Lo que queremos hacer a continuación es un ejercicio práctico para actualizar nuestro esquema de GraphQL. Nos hemos dejado algunas cosas. Necesitamos actualizar los archivos de esquemagraphql. Necesitamos actualizar nuestras definiciones de tipo para incluir el tipo de autor y el tipo de tema. Y una vez que hayamos agregado esos tipos en el esquema, también debemos pensar en las relaciones que necesitamos agregar, luego queremos ejecutar algunas mutaciones de GraphQL que agregarán los autores y los temas a nuestra base de datos según la tabla a continuación. Tenemos tres libros. Aquí están los autores de los libros y también los temas de cada libro. Así que hagamos una pausa de unos cinco minutos, y luego continuamos a los 16 minutos después de la hora. En el code sandbox que tenemos abierto, actualiza el archivo de esquemagraphql para agregar el tipo de autor y el tipo de tema. También piensa en las directivas de relación que querrás usar para conectar el autor y el tema con los libros, y luego intenta escribir las mutaciones de GraphQL para agregar autores y temas basados en la tabla aquí en el grafo. Si te quedas atascado, las soluciones están enlazadas en el archivo readme de este otro code sandbox. Pero hagamos una pausa de cinco minutos y luego volvamos para ver las soluciones. Si te quedas atascado, si tienes algún problema o preguntas, no dudes en preguntar en el chat.

De acuerdo. De acuerdo. Así que eso fueron cinco minutos, creo. ¿Alguien lo logró? ¿Alguien pudo actualizar las definiciones de tipo de GraphQL para incluir autor y tema y luego crear las mutaciones para agregarlos al grafo? ¿Alguien pudo hacer eso? De acuerdo, veamos la solución. Nos quedan unos 40 minutos y tenemos una sección sobre lógica personalizada en la sección de autorización, que quiero asegurarme de cubrir. Así que tal vez echemos un vistazo rápidamente a las soluciones y luego sigamos adelante. Mi contenedor ha sido hibernado, lo actualizaré. A veces esto sucede con Code Sandbox que entra en hibernación, necesitamos reiniciarlo. Creo que en general Code Sandbox ha sido bastante bueno para este tipo de talleres. Creo que hay un equilibrio entre el uso de herramientas en línea como esta o configurar tu entorno de desarrollo local, lo cual a veces puede ser un desafío en este tipo de talleres en línea, pero me gusta Code Sandbox, así que de acuerdo, dijimos que necesitamos dos tipos, así que vamos a agregar un autor. El autor tiene, creo que solo un nombre y tema, que probablemente también solo tiene un nombre, haremos que estos campos sean requeridos o no nulos, eso es lo que significa este signo de exclamación, para crear un nodo de autor, necesita tener un nombre, para crear un nodo de tema, necesita tener un nombre y luego necesitamos un campo de relación, así que un autor, un autor puede haber escrito uno o más libros, así que haremos que sea un campo de arreglo de objetos y queremos usar nuestra directiva de relación, así que el autor, digamos que el autor escribió un libro, y luego la dirección, así que vamos desde el autor hacia el libro, autor, escribió, libro, así que en este caso, desde el autor, la dirección será hacia afuera, y similar para el tema, el tema también tendrá, llamaremos a ese campo libros, y el tipo de relación, que llamaremos, un libro trata sobre un tema, y en este caso, vamos a ir desde el nodo del libro, el libro tratará sobre un tema, así que para el tipo de tema, la dirección será hacia adentro. Y también, en el tipo de libro, queremos poder ir desde el libro hacia el autor y desde el libro hacia el tema, así que diremos autores, creo, así que un libro puede tener varios autores, así que creo que esto también debería ser un campo de arreglo y necesitaremos un tipo de relación, que dijimos que era escribió, así que desde el punto de vista del libro, la dirección será hacia adentro porque vamos desde el autor hacia el libro. Y similar para el tema, así que un libro puede tener cero o más temas realmente y una directiva de relación, así que la relación que dijimos para esto era sobre, ups, falta nuestra comilla doble allí, así que en este caso, la dirección será hacia afuera, así que estamos diciendo que el libro trata sobre temas, Andrés dice que se está retirando. Sí, gracias por unirte, sí, creo que se enviará una grabación y sí, gracias por unirte, de acuerdo, guardaremos esto, no lo comandé, también podemos ir aquí arriba a archivo guardar, puedes ver que esto provoca un reinicio de nuestra aplicación de API de GraphQL, y creo que necesitamos actualizar este navegador para que el playground de GraphQL vuelva a cargar las definiciones de tipo, pero ahora si miramos en los documentos, deberíamos tener autores, sí, tenemos autores y temas, genial.

De acuerdo, tenemos esta tabla, necesitamos escribir mutaciones de GraphQL para agregar los autores a nuestros libros. Así que hagámoslo, tenemos un libro llamado Inspired que fue escrito por Marty Kagan. Así que veamos cómo hacer eso. Vamos a eliminar eso, esto va a ser, sé que va a ser una mutación. Y necesitamos decidir cómo queremos comenzar. Hay un par de formas en las que podríamos abordar esto. Podríamos hacer una actualización de libros y buscar el libro y luego conectar, o hacer una operación de creación desde el libro para crear un nuevo autor, o podríamos hacer una creación de autores. Tal vez empecemos con eso. Así que diremos Crear Autores, el autor tiene un nombre, pero Marty Kagan y luego Marty Kagan escribió un libro. Ya tenemos la base de datos. Así que esto va a ser una conexión, no una creación. Así que vamos a conectar donde el nodo. Puedes notar que tenemos que decir, conectar donde el nodo si tuviéramos propiedades en la relación. Aún no hemos hablado de esto, pero hasta ahora hemos estado almacenando propiedades en los nodos. Si tuviéramos propiedades en las relaciones, tendríamos otra opción aquí para filtrar basado en el objeto de borde, que básicamente es, de todos modos, por eso tenemos el nodo aquí, parece una capa adicional, pero simplemente porque no tenemos el filtro de borde porque no tenemos propiedades de relación. De todos modos, queremos filtrar donde el título sea Inspired y obtendremos un poco más de espacio para poder ver lo que dice esto. Luego traeremos autores, nombre, y libros en el título del libro. Y también queremos que la información nos diga si creamos algún nodo. De acuerdo, identifiquemos esto y veamos esto. Entonces, ¿qué estamos haciendo? Estamos diciendo crear autores y aquí está el objeto de entrada, crear un autor, establecer el nombre como Marty Kagan, luego para el campo de relación de libros, nos vamos a conectar a los libros existentes donde el título del libro sea Inspired. Así que ejecutemos eso. Y decimos que hemos creado a Marty Kagan, e Inspirado de la comunidad, hemos creado un nodo podemos verificar esto si vamos a Neo4j, busquemos autor. Aquí está Marty Kagan, puedes hacer doble clic para recorrer, escribiste este libro inspirado, que trata sobre la gestión de productos. Genial, de acuerdo, excelente. Así que eso fue actualizar nuestro esquema, agregar autores y temas. Voy a omitir el resto de los autores y los temas para poder avanzar y tener tiempo para cubrir la sección restante, pero puedes imaginar cómo usamos esas operaciones de mutación anidadas para crear los autores y temas. Puedes encontrar las soluciones enlazadas en el code sandbox también en el archivo readme si quieres revisarlo. Genial, sigamos adelante. Así que hemos hablado de escribir nuestras definiciones de tipo que luego impulsan la base de datos, impulsan el esquema de GraphQL que se genera que nos brinda las operaciones CRUD para crear data. ¿Qué pasa con la lógica personalizada? ¿Cómo encaja eso? Eso es de lo que vamos a hablar en esta sección. Así que voy a hacer algunas configuraciones aquí, puedes seguir si quieres, pero no es necesario. Borremos nuestra base de datos. Porque estábamos haciendo ese ejercicio y tenemos esquemas algo diferentes, voy a hacer otro, coincidir a, desconectar, eliminar a. Así que borremos todo en la base de datos y luego tenemos un nuevo code sandbox. Copiemos el enlace de este, peguemos el enlace en el chat. Hagamos eso de nuevo. Este es un nuevo code sandbox, lo que significa que necesitaremos actualizar nuestro archivo .env nuevamente. Así que voy a copiar eso de este code sandbox. Voy a hacer clic en el enlace que pegué en el chat y luego queremos bifurcar este code sandbox. Para que tengamos uno que sea privado para nosotros y voy a pegar mis credenciales en ese archivo .env y guardarlo. Nuestra aplicación de API se reiniciará. Así que este esquema ahora incluye muchas otras cosas. Incluye el autor. Sí, el autor y el tema. También tenemos estos campos de directivas Cypher ahora donde hemos agregado algo de lógica personalizada. Incluso tenemos un nuevo tipo de clima y si miramos en Index.JS vemos que realmente hemos implementado un resolvedor aquí. Entonces, vamos a hablar de este code sandbox en el contexto de agregar lógica personalizada. Así que si quieres seguir con ese code sandbox, puedes ver algo de código actualizado, pero para terminar la configuración, necesitamos ejecutar esta mutación para crear algunos datos basados en el esquema completo correcto. Así que eso incluía autores y temas. Así que eso se está ejecutando para guardar algunos datos en nuestra instancia de Aura. Puedes ver que estamos creando los autores para cada libro, los autores para cada libro, un puñado de libros, y luego creando clientes y algunos pedidos. Supongo que hay un par de operaciones de notaciones aquí. De acuerdo, genial. Así que hablemos de la lógica personalizada. Entonces, obtenemos mucho que se genera para nosotros de forma gratuita, básicamente, por la biblioteca Neo4j GraphQL en función de nuestras definiciones de tipo.

Hay dos formas de agregar lógica personalizada. Si tenemos lógica empresarial más allá de nuestras funcionalidades básicas de creación, lectura, actualización y eliminación. Entonces, los dos enfoques para eso, uno es la directiva de esquema Cypher GraphQL. Aquí es donde agregamos lógica personalizada mediante la adición de declaraciones Cypher al esquema GraphQL o implementando resolvers personalizados. Podemos implementar funciones de resolvers personalizados con cualquier lógica, podemos llamar a Neo4j y llamar a otra base de datos. Básicamente, podemos hacer lo que queramos en un resolver personalizado. Hay algunas compensaciones aquí. Si usamos la directiva de esquema Cypher, el beneficio que tenemos aquí es que aunque estamos agregando una declaración Cypher personalizada, esa declaración aún se incluye como una subconsulta en nuestra única declaración Cypher generada. Así que todavía estamos enviando una sola consulta a la base de datos. Solo un viaje a la base de datos. Entonces, aunque estamos agregando lógica personalizada, no estamos yendo por el camino del problema de la consulta N más uno. Si implementamos resolvers personalizados, bueno, esos resolvers de clientes aún se llaman de forma anidada. Así que podemos terminar haciendo múltiples viajes a nuestra capa de datos en ese caso. Algo de lo que debemos ser conscientes. Y, por supuesto, implementar un resolver personalizado requiere un poco más de trabajo que simplemente adjuntar una declaración Cypher en nuestras definiciones de tipo. Así que vimos un ejemplo anterior de la directiva de esquema Cypher. Creo que estaba buscando una recomendación empresarial como un filtrado colaborativo para usuarios que revisaron este negocio. ¿Qué otros negocios están revisando esos usuarios? Si te gusta este negocio, esa podría ser una buena manera de encontrar recomendaciones. Así que veamos las diferentes formas en que podemos usar esta declaración Cypher. Y estos fragmentos provienen del código que está en el code sandbox. Entonces, este enlace de code sandbox para este módulo incluye todos estos ejemplos. Puedes ejecutarlos y ver cómo funcionan. Aquí estamos agregando un campo a order, usando esta sintaxis extend en SDL de GraphQL, donde podemos agregar estos campos en la definición de tipo. Me gusta usar esta funcionalidad extendida porque así puedo tener mis definiciones de tipo básicas en un solo lugar y mi lógica personalizada en otro lugar y agregarlas juntas. Pero es solo un azúcar sintáctico, supongo. Aquí estamos agregando un campo de sub-total al tipo order. Podemos calcular esto mirando el pedido, recorriendo todos los libros que están contenidos en el pedido y luego sumando el precio de cada libro. Por supuesto, esto podría ser un poco más complicado. Podríamos tener descuentos y cosas así para tener en cuenta. Pero esta es una forma en que podemos calcular el sub-total. Aquí estamos usando la directiva Cypher para calcular un campo escalar. Estamos calculando un flotante. Y nuevamente, observa el uso de this. Esta es una variable que se inyecta para referirse al pedido resuelto actualmente. Y para el cliente de nuestra API de GraphQL, esto simplemente parece otro campo, ¿verdad? No es obvio que esto se esté calculando realmente. Veamos esto como ejemplo. Esto es interesante. En Playground, oh, tenemos un error en esto. No sé por qué no obtuve un error. Oh, tal vez no pegué las credenciales correctas en mi archivo .env, tal vez. ¿Es eso lo que pasó? Copiar. Pegar. Y estamos en esto de nuevo. Ahí vamos. Funcionó esta vez. Sí, creo que no tenía las credenciales correctas de mi base de datos. Pero, okay, ¿qué queremos hacer? Queremos ver los pedidos. Y para los pedidos, ¿qué tienen? Un ID de pedido y un sub-total. Así que ejecutemos esto. Aquí están todos nuestros ID de pedido y el sub-total. Ahora, si miramos la consulta Cypher generada, tengo que desplazarme hacia abajo en la salida del terminal. Si miro la consulta Cypher generada para eso, puedo ver, okay, estamos haciendo coincidir en el pedido, estamos devolviendo el ID del pedido. Y luego, para el campo de sub-total, aquí está nuestra consulta Cypher que adjuntamos al esquema donde estamos recorriendo todos los libros en el pedido y sumando el precio para obtener el sub-total. Así que eso es lo que queremos decir cuando decimos que la declaración Cypher que adjuntamos con la directiva Cypher, se inyecta como una subconsulta en la única declaración Cypher generada. Así que todavía estamos haciendo solo una solicitud a la base de datos. Okay, eso es usando la directiva de esquema Cypher en un campo escalar. También podemos hacer esto en campos de nodo, objeto y matriz de objetos. Aquí estamos agregando un campo recomendado al tipo de cliente. Este es un array de libros. Así que estamos mirando los pedidos que este cliente ha realizado. Así que partiendo de esto, es el cliente resuelto actualmente, recorriendo los pedidos que ha realizado este cliente a los libros que están en el pedido, y luego mirando otros pedidos que contienen estos libros que otros clientes han realizado. Esto significa que para todos los libros que he pedido, ¿qué clientes también están pidiendo los mismos libros que me gustan? Básicamente, encontrar clientes similares, ¿verdad? Compran los mismos libros, preferencias similares. Luego, en la siguiente declaración, la siguiente línea de coincidencia aquí, vamos desde esos otros clientes, ¿qué pedidos están realizando con otros libros que no he pedido? Entonces, ¿qué clientes están pidiendo libros que también estoy pidiendo? ¿Qué otros libros están pidiendo? Esas podrían ser buenas recomendaciones para mí. Nuevamente, esta es otra forma de expresar esta idea de filtrado colaborativo donde estoy usando las preferencias de otros usuarios en la red para personalizar recomendaciones para un usuario específico, lo cual podemos expresar en Cypher. Así que ahora tenemos este campo recomendado en los clientes. Y nuevamente, podemos consultar esto. Probablemente omitiré consultar esto por motivos de tiempo aquí. Pero ahora tenemos este campo recomendado que nos da libros. Podemos seleccionar libros y continuar en una estructura anidada también.

Cualquier argumento de campo que definamos en nuestras definiciones de tipo para los campos de la directiva Cypher se pasan a la declaración Cypher como parámetros Cypher, lo cual es bastante bueno. Por ejemplo, en nuestro campo recomendado, queremos controlar el número de libros recomendados. Podríamos agregar aquí un argumento de campo límite, y luego eso está disponible para nosotros en la declaración Cypher como un parámetro Cypher. Usamos el signo de dólar para indicar que queremos usar un parámetro Cypher en ese nombre, que coincide con lo que se incluye en nuestro Cypher, en nuestro argumento GraphQL. Lo siento, tengo algunos ruidos fuertes de fondo.

De acuerdo, esto es bastante bueno. Creo que es una buena idea, por lo general, usar valores predeterminados aquí. Aquí estamos estableciendo un valor predeterminado de tres. Eso significa que este parámetro Cypher límite siempre tendrá un valor, por lo que no necesitamos pensar en cómo manejar eso en el caso de que no tengamos un valor que el usuario especifique. También podríamos hacerlo un valor de entrada requerido, pero me gusta establecer un valor predeterminado. Eso facilita las cosas para el cliente, si no les importa, pueden usar el valor predeterminado. Pero luego no tenemos que manejar en nuestra declaración Cypher el caso en el que no se proporciona ningún valor. De todos modos. Aquí, estamos anulando ese valor predeterminado al decir que solo queremos un libro recomendado.

De acuerdo, hemos utilizado la directiva Cypher para campos escalares, la hemos utilizado para devolver nodos, también podemos usar campos de directiva Cypher para devolver un objeto y Cypher, creo que los llamamos mapas, pero un objeto, un mapa, un diccionario. De cualquier manera que lo piense, pares clave-valor. Entonces podemos usar, escribir una declaración Cypher que devuelve un objeto, y luego asignarlo a un tipo que hemos definido en nuestro esquema. Por ejemplo, en este caso, tenemos nodos de dirección. Puede ser útil para nuestros repartidores, que puedan ver el clima actual en estas direcciones donde van a entregar cosas. Entonces aquí estamos usando Cypher para llamar a una API del clima. Estamos usando APOC. APOC es la biblioteca estándar para Cypher que agrega funcionalidad adicional. Entonces una cosa que podemos hacer con APOC es llamar a otras APIs. Aquí es APOC load JSON, llamándolo a una API adyacente para luego trabajar con los datos JSON que regresan de esta API del clima. Pero ten en cuenta que tenemos la ubicación, latitud y longitud disponibles para nosotros porque esta dirección resuelta actualmente tiene una propiedad de ubicación. Luego devolvemos este objeto. Entonces temperatura, velocidad del viento, dirección del viento, precipitación y resumen que coincide con este tipo de clima que hemos agregado a nuestro esquema. Entonces esto es bueno para este caso donde podemos estar llamando a otra API para obtener algunos datos y solo definimos algunos tipos que no necesariamente necesitan existir en la base de datos. Entonces no tenemos nodos de clima en la base de datos, pero está bien. Los estamos proyectando desde una declaración Cypher. Y nuevamente, para el cliente de la API, de nuestra API de GraphQL, no hay indicación de que esto esté llamando a otro sistema, que en realidad no existe en la base de datos, lo que sea, ni siquiera saben que proviene de una base de datos. Es solo otro campo de objeto, clima actual. Hasta ahora hemos estado usando estos campos de directiva Cypher en tipos. También podemos usarlos para consultas y mutaciones de nivel superior. Entonces para campos en los tipos de consulta y mutación. ¿Por qué haríamos esto? Bueno, un caso podría ser exponer coincidencias difusas a través de un índice de texto completo o alguna lógica de consulta personalizada. Entonces podemos crear un índice de texto completo en la base de datos con esta declaración, que voy a omitir ejecutar por falta de tiempo aquí. Pero luego podemos consultar el índice de texto completo e indicar específicamente que queremos usar coincidencias difusas. Eso es el tilde al final aquí. Entonces estamos buscando libros que tengan un título o descripción que contenga graph pero siempre mal escrito graph. Pero aún queremos devolver resultados útiles al usuario, eso es lo que indica el tilde. Esto, por cierto, esta es una sintaxis de consulta admitida por Lucene. Lucene tiene un motor de texto completo que es el respaldo para los índices de texto completo en Neo4j. Entonces esa es la sintaxis de Lucene. Cualquier tipo de sintaxis de Lucene que podríamos usar aquí. De acuerdo, eso es cómo lo consultamos en la base de datos. ¿Pero cómo lo exponemos a través de nuestra API de GraphQL? Bueno, aquí estamos agregando un campo de búsqueda de libros al tipo de consulta. Este campo de búsqueda de libros toma un argumento de campo de cadena de búsqueda. Pasamos esa cadena de búsqueda a nuestra declaración Cypher para buscar en el índice de libros. Agregamos el tilde para indicar que queremos coincidencias difusas. Entonces ahora hemos agregado un campo de coincidencia difusa respaldado por texto completo para buscar libros. Entonces ahora, si buscamos libros e incluso escribimos mal graph, aún obtendremos algunos resultados útiles. Entonces ese es un caso en el que podemos usar la directiva Cypher para campos de consulta personalizados. Podemos hacer algo similar para mutaciones. Tal vez tengamos alguna lógica de mutación personalizada que tenemos. Tenemos algunas estructuras muy específicas que queremos crear, o tenemos alguna forma específica en la que queremos cargar los datos. Podemos crear campos de mutación donde la lógica está definida también usando Cypher. De acuerdo, esas son las diferentes formas en que podemos usar la directiva Cypher. Mutación personalizada, campos de consulta personalizados, campos escalares, devolución de nodos y proyección de objetos desde declaraciones Cypher que en realidad no existen, o pueden no existir en la base de datos. Otra forma en que podemos agregar lógica personalizada es implementando resolvers. Los resolvers son generados para nosotros por la biblioteca Neo4j GraphQL. Aún no hemos tenido que escribir ningún resolver. Tenemos todo esto, incluida la funcionalidad personalizada en nuestra API de GraphQL, lo cual es bastante bueno y muy poderoso. Por lo general, escribimos resolvers solo para especificar la lógica de obtención de datos. Podemos anular los resolvers generados, o si tenemos datos que en realidad no están en la base de datos, queremos llamar a otro sistema, sea cual sea el caso, podemos implementar funciones de resolver. Entonces aquí estamos agregando un campo al tipo de orden llamado entrega estimada, que es una fecha y hora. Tal vez tengamos un sistema logístico o algo así al que estamos llamando, que nos dirá si tenemos esto en stock y cuándo creemos que realmente podremos enviarlo. En nuestro caso, solo estamos calculando una fecha al azar en esta función, pero imagina hacer algo más complicado. Aquí, solo estamos calculando una fecha al azar. Pero cuando hacemos esto, necesitamos agregar la directiva ignore a nuestro esquema para indicar que no debemos intentar obtener este campo de la base de datos, que no incluyamos el campo de entrega estimada en nuestras declaraciones de Cypher generadas, porque eso no es un dato en la base de datos, en su lugar, realmente llamamos a este resolver de entrega estimada para obtener los datos para este campo. Y así esto se convierte en otro campo disponible en nuestro tipo de orden. De acuerdo, tenemos otro ejercicio. Voy a omitir este, lo dejaremos para que lo hagas en tu tiempo libre, ya que solo nos quedan unos 10 minutos. Pero si miras el código en el code sandbox que está vinculado, verás un campo similar en el tipo de libro. Y el ejercicio aquí es pensar en otras formas en Cypher en las que podríamos calcular libros similares, intenta modificarlo, ve cómo se ven los resultados en función de eso. Pero lo dejaremos como ejercicio para hacer en casa, supongo. De acuerdo, nos quedan 10 minutos para el último módulo, que trata sobre la autorización. Hay un code sandbox específico para esto. Déjame abrirlo. Creo que probablemente solo hablemos de los ejemplos aquí. Permíteme copiar esto, copiar enlace. Aquí está el enlace, que dejaré en el chat. Compartí este enlace anteriormente.

También encontrarás todas las consultas que estamos ejecutando aquí, así como en este enlace.

De acuerdo, hablemos de la autorización. Hay otra directiva de esquema disponible en la biblioteca de GraphQL de Neo4j que es muy poderosa llamada la directiva de esquema de autenticación de GraphQL. Auth nos permite definir reglas de autorización para proteger los tipos y campos en nuestro esquema. Utilizamos tokens web JSON para verificar los permisos y aplicar las reglas que hemos definido en nuestro esquema. Si no estás familiarizado con los tokens web JSON, básicamente es una forma de firmar criptográficamente una carga útil JSON y luego codificarla en una cadena. Cualquiera puede decodificarlos. Puedes tomar cualquier token web JSON. Hay una herramienta en línea llamada JWT IO, pégalo allí y podrás ver la carga útil. Y luego hay una clave separada que puede ser una cadena secreta o un par de claves pública-privada que se utiliza para verificar que el token esté firmado. En nuestro caso, está firmado por una aplicación que verifica esos permisos, ya sea utilizando una clave compartida o firmándolo con la clave privada. Y luego usaremos la clave pública para verificar que sea un token válido y que los permisos o la carga útil, los datos que son un objeto JSON, sean válidos. Entonces en este caso, tenemos un permiso sub, que es el suscriptor, que es como el usuario. ID de usuario, eso es lo que se usa típicamente allí. Luego tenemos roles. Entonces este token es un token válido que verifica que el usuario sea BABLABLA7687 y que este usuario tenga un rol de administrador para esta aplicación. Hay muchas otras cosas. Entonces podemos agregar básicamente cualquier par clave-valor JSON a la carga útil de un JWT. Hay algunas convenciones como sub que se usa comúnmente para roles de suscriptor, ámbito, cosas así. De acuerdo, veamos algunas de las reglas que podemos definir utilizando esta directiva de esquema de autenticación. La más simple es autenticado y esto simplemente significa que para acceder al campo o tipo, la solicitud de GraphQL debe tener un JWT válido. En el encabezado de la solicitud. Aquí hay un ejemplo donde hemos agregado está autenticado al asunto. Entonces tal vez, no sé. Tal vez tengamos una búsqueda pública para nuestros libros y luego puedes ver el título y el autor pero si quieres ver el asunto necesitas iniciar sesión en nuestra aplicación, algo así. Entonces obtendremos un error si solicitamos asuntos y no estamos pasando un token pero aquí hemos agregado un encabezado de autorización en el playground de GraphQL con un token de portador. Este es el JWT y la biblioteca de GraphQL de Neo4j validará que el token sea válido utilizando una clave compartida o una clave privada y luego obtendremos los datos que esperamos. El siguiente tipo de regla que podemos crear se basa en roles así que vimos ese token antes que tenía un permiso de roles y era una matriz e incluía administradores. Este era un usuario administrador. Por cierto, también podemos especificar las operaciones para cada una de estas reglas de autenticación, por lo que decimos que esta regla se aplicará a las operaciones de creación, actualización y eliminación en el tipo de libro por lo que esta regla no se aplicará a la lectura por lo que cualquiera puede leer, pero para crear, actualizar o eliminar un libro necesitas tener un rol de administrador. Otro tipo de regla que podemos definir es permitir. Permitir comparará los valores en la base de datos con los valores en la carga útil del token web JSON por lo que aquí decimos que para tener acceso a un pedido no estamos especificando ninguna operación aquí por lo que esto se aplica a todas las operaciones para el pedido, incluida la lectura el nombre de usuario del cliente del pedido debe coincidir con el permiso sub o suscriptor en el JWT Entonces esto dice que los usuarios solo pueden leer sus propios pedidos o crear o actualizar sus propios pedidos. Entonces aquí estamos autenticados como este usuario ML de 7474 y estamos diciendo muéstrame todos los pedidos para este usuario pero ahora si eliminamos ese filtro y decimos muéstrame todos los pedidos. Bueno, estoy tratando de solicitar pedidos a los que no tengo acceso, así que obtendré un error. Podemos combinar múltiples reglas. Esta es una operación OR. Entonces decimos que solo los clientes tienen acceso a sus propios pedidos. O si eres un administrador, si tienes un rol de administrador y también tienes acceso a los pedidos. Entonces hay un problema con esta en la que estamos autenticados, estamos solicitando todos los pedidos. Aún obtenemos un error porque no estamos filtrando los pedidos para el usuario autenticado actualmente. Por lo tanto, puede haber casos en los que realmente no queremos que la aplicación del cliente sea responsable de agregar estos filtros para filtrar solo el usuario autenticado actualmente. Ahí es donde entra en juego la regla dónde. Entonces dónde es similar a permitir, y nos permite especificar reglas, valores coincidentes en la base de datos con valores en el token web JSON. Pero la diferencia con permitir es que dónde agregará automáticamente esos predicados a la consulta Cypher generada para que el cliente pueda, es libre de solicitar datos, pero ese predicado siempre se agregará. Por lo tanto, solo recibirán datos a los que tengan acceso. Aquí estamos agregando una regla dónde al tipo de cliente que dice que solo el cliente autenticado actualmente puede acceder al tipo de cliente. Entonces solo puedes acceder a tus propios datos de cliente. Y ahora estamos autenticados como un usuario específico pasando este encabezado de autorización y pasando este token de portador. Estamos solicitando todos los clientes, su nombre de usuario y sus pedidos. Pero si observas los resultados, solo estamos obteniendo información del cliente para el usuario autenticado actualmente porque hemos aplicado esa regla dónde. Bind es otra regla que podemos crear. Esto también coincidirá con datos en la base de datos con datos en el JWT. Y en este caso, estamos diciendo que para crear o actualizar una reseña, el nombre de usuario del autor de la reseña, así que ten en cuenta que estamos atravesando el grafo un poco en esta regla, vamos desde la reseña atravesando la relación escribió hasta el cliente, estamos diciendo que el nombre de usuario de ese cliente que escribió la reseña en la base de datos, ese nombre de usuario debe coincidir con el permiso sub del JWT. Entonces solo los usuarios pueden crear o actualizar sus propias reseñas, lo cual tiene sentido. Y bind significa que esto se aplicará durante la mutación. Entonces si intentamos crear una reseña y tratamos de crear, conectar ese nodo de reseña a un usuario que no sea el usuario o el cliente con el que estamos autenticados actualmente, entonces obtendremos un error. Podemos utilizar la funcionalidad de autorización con campos de directiva Cypher. Por lo tanto, podemos definir reglas de autenticación para campos de directiva Cypher y luego también en cualquier campo de directiva Cypher, cuando hemos configurado la autorización, tenemos acceso a todos los permisos en el token decodificado, lo cual es realmente genial bajo los parámetros de autenticación de Cypher. Hay un parámetro de autenticación de Cypher, por ejemplo, decimos auth.jbt.sub aquí mismo en la primera línea de nuestras declaraciones Cypher para referirnos al usuario autenticado actualmente. Entonces podemos obtener su nombre de usuario del token, buscar ese cliente en la base de datos. Y luego aquí estamos generando recomendaciones de libros para el usuario actual. Entonces nuevamente, aquí estamos viendo qué libros ha comprado este usuario, cuáles son los temas de esos libros, cuáles son otros libros que tienen temas similares. Por lo tanto, recomendamos libros basados en temas similares. Esto es bueno porque podemos tener simplemente un campo Libros para el Usuario Actual, no tenemos que filtrar en esa consulta de GraphQL para especificar el usuario autenticado actualmente que se obtiene de los permisos en el token de este encabezado de autorización, y obtenemos libros recomendados. Genial, se nos acabó el tiempo, hay un ejercicio más, que es crear un nuevo usuario utilizando el token de portador de administrador, luego crear un JWT para el nuevo usuario, firmado con un secreto, y luego agregar algunos datos desde la perspectiva de ese usuario. Así que lo dejaré como ejercicio para hacer en casa ya que se nos acabó el tiempo, creo que la solución está incluida en este enlace que he proporcionado, sí, al final aquí. Genial, así que gracias a todos por unirse y por quedarse hasta el final aquí. Muchas gracias. Tenemos muchas otras cosas interesantes que podemos hacer con la biblioteca de GraphQL de Neo4j que no tuvimos tiempo de cubrir hoy, como trabajar con uniones e interfaces. También hay un paquete OGM que nos permite tener una API programática que utiliza definiciones de tipo de GraphQL, lo cual puede ser interesante.

Hablamos un poco sobre las propiedades de las relaciones, pero en realidad no hicimos nada con ellas, solo agregaciones y demás. Así que hay muchas otras cosas interesantes. Estos son enlaces a la documentación de cada uno de estos temas si quieres profundizar más. Aquí está nuevamente esta lista de recursos, todos deberían tener las diapositivas, el código está en línea para que puedas encontrarlo.

Una cosa que mencionaré es la capacitación de la Graph Academy. Si quieres profundizar más, la capacitación de la Graph Academy es una capacitación a tu propio ritmo que puedes hacer por tu cuenta, obtendrás un certificado cuando termines. Es un contenido similar al que cubrimos hoy, pero con un poco más de profundidad, utiliza la misma aplicación de la API de la librería de libros.

Genial, bueno, nuevamente, nos hemos pasado de tiempo, así que creo que nos detendremos aquí. Estoy realizando otra masterclass a través de GraphQL Galaxy el martes. Si estás interesado en eso, echemos un vistazo. GraphQL Galaxy, ¿dónde están las masterclass? ¿Dónde están las masterclass? Entonces, esta es esta, construyendo APIs GraphQL con la librería de GraphQL de Neo4j. Ya hemos hecho esa. El martes, creo que es el martes. Sí, el martes 7 de diciembre a las 1800 CET, vamos a hacer una masterclass enfocada en las aplicaciones GraphQL de pila completa utilizando Neo4j Aura, Next.js y Vercel. Hoy nos centramos solo en construir la pieza del backend y la capa de la base de datos y la API. El martes, veremos cómo usar Next.js para construir realmente una aplicación de pila completa que incluye la pieza del backend, pero también el frontend, y luego cómo usamos Vercel y Neo4j Aura para implementar nuestra aplicación. Entonces, haremos algunas cosas en React. Entonces, si estás interesado, no dudes en unirte el martes, de lo contrario, eso es todo lo que tengo hoy. Así que muchas gracias a todos por unirse.