Name: GraphQL Galaxy 2022
Start: 2022-12-08T15:00:00.000Z
End: 2022-12-09T20:00:00.000Z

Lera

Ricardo Machado

David Pugh

Oscar Pagani

Bernie Green

Nils BUntenbeck

Mathieu Habegger

Renata Rodrigues

Lukas

Mel Moe

Denis Radin

Missy

Norm Crandall

Creatopy Tech

Alex Hayton

Aman Beg

Hannah Vivian Shaw

Patrick ORGAN

Christian Guy

Ian Sutherland

Lia Moreira

Max Medina

Rishi Narang

Ludovic Bouges

Natalia Fernández

Mailing Delgado Medina

Vitor Barbosa

Paulo Jorge Sousa

Michael Chiche

Adrian Marte

Kasper Laursen

Ricardo Del Rio Rubial

Josh Freislich

Mohamed Taoufik TEKAYA

En esta charla, veremos algunas de las opciones modernas para construir una aplicación full-stack de React y GraphQL con convenciones sólidas y cómo esto puede ser de enorme beneficio para ti y tu equipo. Nos enfocaremos específicamente en RedwoodJS, un framework full stack de React que a menudo se llama 'Ruby on Rails para React'.

Aplicaciones sólidas de React y GraphQL para personas con prisa

The Talk discusses the challenges and advancements in using GraphQL and React together. It introduces RedwoodJS, a framework that simplifies frontend-backend integration and provides features like code generation, scaffolding, and authentication. The Talk demonstrates how to set up a Redwood project, generate layouts and models, and perform CRUD operations. Redwood automates many GraphQL parts and provides an easy way for developers to get started with GraphQL. It also highlights the benefits of Redwood and suggests checking out RedwoodJS.com for more information.

In this talk, we'll look at some of the modern options for building a full-stack React and GraphQL app with strong conventions and how this can be of enormous benefit to you and your team. We'll focus specifically on RedwoodJS, a full stack React framework that is often called 'Ruby on Rails for React'.

Rock Solid React and GraphQL Apps for People in a Hurry

Ryan Chenkie

Aunque GraphQL es declarativo, los resolvers operan campo por campo, capa por capa, lo que a menudo resulta en un trabajo innecesario para la lógica de tu negocio, incluso cuando se utilizan técnicas como DataLoader. En esta charla, Benjie presentará su visión de una nueva estrategia de ejecución de GraphQL de propósito general cuyo enfoque holístico podría conducir a ganancias significativas en eficiencia y escalabilidad para todas las APIs de GraphQL.

Deja paso a los resolvers: un nuevo enfoque para la ejecución de GraphQL

GraphQL has made a huge impact in the way we build client applications, websites, and mobile apps. Despite the dominance of resolvers, the GraphQL specification does not mandate their use. Introducing Graphast, a new project that compiles GraphQL operations into execution and output plans, providing advanced optimizations. In GraphFast, instead of resolvers, we have plan resolvers that deal with future data. Graphfast plan resolvers are short and efficient, supporting all features of modern GraphQL.

Though GraphQL is declarative, resolvers operate field-by-field, layer-by-layer, often resulting in unnecessary work for your business logic even when using techniques such as DataLoader. In this talk, Benjie will introduce his vision for a new general-purpose GraphQL execution strategy whose holistic approach could lead to significant efficiency and scalability gains for all GraphQL APIs.

Step aside resolvers: a new approach to GraphQL execution

Benjie

Construir con GraphQL por primera vez puede ser desde desafiante hasta pan comido. Comprender qué características buscar en tus herramientas de cliente y servidor y adoptar los hábitos correctos (y deshacerte de los viejos hábitos) es la clave para tener éxito con un equipo de cualquier tamaño en GraphQL. Esta charla ofrece una visión general de los desafíos comunes que he visto en numerosos equipos al construir con GraphQL, cómo superaron las fuentes comunes de frustración y la mentalidad que finalmente adoptaron, y las lecciones aprendidas, para que puedas adoptar y seguir confiando en GraphQL con confianza.

Tu Ritmo con GraphQL

The Talk discusses the value proposition of GraphQL and its ability to solve common pain points in API development. It highlights the importance of making informed decisions when choosing GraphQL clients, servers, and schema builders. The Talk also emphasizes the need to focus on the best developer experience in the present rather than seeking a perfect long-term solution. Additionally, it mentions the future of the Urkel GraphQL client and the reasons for dropping ReScript support. Overall, the Talk provides insights into the current state and future trends of GraphQL development.

Building with GraphQL for the first time can be anywhere between daunting and easy-peasy. Understanding which features to look for in your client-side and server-side tooling and getting into the right habits (and ridding yourself of old habits) is the key to succeed with a team of any size in GraphQL. This talk gives an overview of common struggles I've seen numerous teams have when building with GraphQL, how they got around common sources of frustration, and the mindset they eventually adopted, and lessons learned, so you can confidently stick with and adopt GraphQL!

Your GraphQL Groove

Phil Pluckthun

Let me introduce distinguished guests from GraphL, Apollo, Stellate, and Graphbase. They are experts in GraphQL and its future trends. Discussing GraphQL trends and user stories in Apollo. Excitement over the potential of defer in GraphQL applications. Challenges and solutions in GraphQL education and tooling for community advancement. Challenges in improving beginner education in GraphQL. Panelists discussing challenges in standardizing advanced GraphQL topics and teaching back-end GraphQL development. Challenges in designing GraphQL schemas and the complexities of ensuring backward compatibility. Introduction to Graphast, an alternative execution model for solving GraphQL problems efficiently on the backend. Simplifying GraphQL deployment for developers with evolving frameworks. Addressing front-end and back-end role boundaries in GraphQL and exploring simplification options. Innovations like fragment utilization and segregating data from components enhance the GraphQL experience.

Panel Discussion 'The Future of Server-side GraphQL'

Danielle Man

Uri Goldshtein

Fredrik Björk

Tim Suchanek

Sesión de preguntas y respuestas con Lee Byron

Sesión de preguntas y respuestas con Lee Byron

GraphQL at Facebook started as a solution for the migration to structured product infrastructure and the move to mobile. The birth of FQL highlighted the need for a better tool than SQL. The impact of GraphQL has been impressive, with unexpected growth and usage in various domains. Exciting developments include new features like defer and stream, making GraphQL a live, continuous data delivery and UI rendering tool. Personal experiences with GraphQL involve using it to move data between backend and frontend, with challenges in integrating it into IDE environments.

AMA Session with Lee Byron

Lee Byron

Los requisitos cambian, pero los contratos de API son para siempre - ¡Ojalá! Un cambio significativo es algo que no es compatible con versiones anteriores. Esto significa que un consumidor de tu API no podría usar la nueva versión sin hacer un cambio de código ellos mismos. Evitamos cambios significativos si es posible, pero hay casos en los que son inevitables. Podría ser algo pequeño: como hacer un campo obligatorio opcional. O podría ser algo grande: como eliminar una consulta o una mutación. En esta charla revisaremos los tipos de cambios significativos que puedes encontrar y cómo lidiar con ellos de manera elegante.

Manejo de Cambios Significativos en GraphQL

This Talk discusses handling breaking changes in a GraphQL schema, including the use of the deprecated directive to tag fields that should no longer be used. It also covers the process of deploying GraphQL APIs and mobile apps, highlighting the challenges of mobile app release adoption. The Talk emphasizes the importance of making safe upgrades in mobile apps and provides strategies for detecting and handling breaking changes, such as using TypeScript and GraphQL Inspector. Overall, the Talk emphasizes the need to minimize user impact when introducing breaking changes in GraphQL schemas.

Requirements change, but API contracts are forever - I wish! A breaking change is something that is not backwards compatible. This means that a consumer of your API would not be able to use the new version without making a code change themselves. We avoid breaking changes if possible, but there are cases when they are inevitable. It could be something small: like making a mandatory field optional. Or it could be something big: like removing a query or a mutation. In this talk we'll review the types of breaking changes you may encounter and how to deal with them gracefully.

Handling Breaking Changes in GraphQL

Kadi Kraman

<div>Reaccionar a los cambios de datos y publicar esos cambios como eventos de GraphQL con suscripciones puede ser difícil, especialmente en un entorno de múltiples servicios con múltiples bases de datos o al escalar su servidor de GraphQL con múltiples instancias. Los clientes de GraphQL no deben perder eventos ni recibirlos dos veces, sin importar cómo sea su arquitectura backend o qué problemas (caída del servicio, pérdida de conexión a la base de datos, ...) puedan tener al atender una solicitud de suscripción.</div><div>En esta charla, te mostraré cómo Debezium y Apache Kafka pueden ayudarte a construir suscripciones confiables a partir de cambios en tu base de datos. Debezium es una herramienta de captura de datos de cambio (CDC) que puede enviar cambios desde el registro de transacciones de una base de datos al broker de mensajes Kafka.En mi charla, utilizaré un backend de GraphQL implementado en Java con "Spring for GraphQL", pero como Debezium y Kafka no están limitados a Java, la idea también es utilizable con otros frameworks y lenguajes de programación de GraphQL. No es necesario tener conocimientos de Java o Spring for GraphQL para entender la charla.</div>

Suscripciones de GraphQL con Debezium y Kafka

This lightning talk explores the use of GraphQL subscriptions with Kafka and Debezium. By adding a message broker like Apache Kafka and a change data capture tool like Debezium to the deployment, issues with multiple service instances and database writes can be resolved. Debezium picks up changes directly from the database and sends CDC event messages to the connected message broker, ensuring that any change in the database will be published to Kafka and received by the service instance. This technology stack can also be used for queries by building a dedicated read model database for the GraphQL API.

<div>Reacting on data changes and publishing those changes as GraphQL events with subscriptions can be hard, especially in a multi-service environment with multiple databases or when scaling your GraphQL server with multiple instances. GraphQL clients shouldn't miss events or receive them twice, no matter how your backend architecture looks like or what trouble (service goes down, database connection lost, ...) they might have when serving a subscription request.</div><div>In this talk, I will show you, how Debezium and Apache Kafka can help you building reliable subscriptions from changes in your database. Debezium is a change data capture (CDC) tool that can forward changes from a database' transaction log in to the Kafka message broker.In my talk I will use a GraphQL backend implement in Java with "Spring for GraphQL", but as Debezium and Kafka are not tied to java the idea is usable also with other GraphQL frameworks and programming languages. You do not need to have knowledge of Java or Spring for GraphQL" to understand the talk.</div>

GraphQL Subscriptions with Debezium and Kafka

Nils Hartmann

Aplica el poder de los grafos al desarrollo de aplicaciones móviles iOS en este masterclass práctico. Exploraremos cómo utilizar la biblioteca Neo4j GraphQL para construir APIs de GraphQL respaldadas por Neo4j AuraDB y cómo integrar GraphQL en una aplicación iOS utilizando SwiftUI y la biblioteca Apollo iOS GraphQL mientras construimos una aplicación móvil de lectura de noticias. Tabla de contenidos:- Introducción a Neo4j AuraDB- Construcción de APIs de GraphQL con la biblioteca Neo4j GraphQL- Introducción a SwiftUI- SwiftUI + GraphQL Requisitos previosPara seguir el masterclass, los asistentes necesitarán una computadora Mac con una versión reciente de Xcode instalada. Será útil tener cierta familiaridad con Swift y el desarrollo de aplicaciones iOS, aunque no es necesario.

Masterclass práctico con SwiftUI, GraphQL y Neo4j AuraDB

Today's Workshop focused on building native iOS applications using SwiftUI and GraphQL, with a database powered by Neo4j. The Neo4j GraphQL library reduces boilerplate code and offers performance advantages. SwiftUI allows for building declarative UIs and includes a preview functionality. Cypher and GraphQL are both used to query and interact with graph data, with Cypher being more focused on graph databases and GraphQL being more versatile. The workshop also covered topics like building a GraphQL API, configuring the Neo4j GraphQL library, and using Apollo iOS for GraphQL data fetching in iOS apps.

Bring the power of graphs to iOS mobile app development in this hands-on workshop. We will explore how to use the Neo4j GraphQL Library to build GraphQL APIs backed by Neo4j AuraDB and how to integrate GraphQL into an iOS app using SwiftUI and the Apollo iOS GraphQL library as we build a news reader mobile app. Table of contents:- Intro to Neo4j AuraDB- Building GraphQL APIs with the Neo4j GraphQL Library- Intro to SwiftUI- SwiftUI + GraphQL PrerequisitesTo follow along during the workshop attendees will need a Mac laptop with a recent version of Xcode installed. Some familiarity with Swift and iOS app development will be helpful, although not required.

Hands-On With SwiftUI, GraphQL, & Neo4j AuraDB

William Lyon

@defer ha sido ampliamente discutido dentro del grupo de trabajo de GraphQL, y aunque aún no forma parte de la especificación, es una emocionante adición que puede ayudar con la experiencia del usuario de tu aplicación y ocultar problemas de rendimiento.

GraphQL no resolverá tus problemas de rendimiento, pero @defer podría ayudar

The talk discusses the defer directive in GraphQL, which allows clients to specify parts of a query that can be delivered incrementally. It addresses the problem of higher latency fields while still having a single response. The talk explores different approaches to solving this problem, such as query splitting and prefetching. It also covers examples of using the defer directive for partial rendering and lazy loading, as well as its use in mutations. The talk emphasizes the importance of performance for user experience and provides resources for further exploration.

@defer has been long discussed within the GraphQL working group, and while not part of the specification yet, it’s an exciting new addition that may help with your application’s user experience and mask performance problems.

GraphQL won’t solve your performance problems, but @defer might help

Lucas Leadbetter

Hay muchas ventajas en utilizar GraphQL como fuente de datos para el desarrollo frontend, en comparación con las API REST. Nosotros, los desarrolladores, por ejemplo, necesitamos escribir mucho código imperativo para recuperar datos y mostrarlos en nuestras aplicaciones y manejar el estado. Con GraphQL, no solo puedes reducir la cantidad de código necesario para la obtención de datos y la gestión del estado, sino que también obtendrás una mayor flexibilidad, mejor rendimiento y, sobre todo, una mejor experiencia de desarrollo. En este masterclass aprenderás cómo GraphQL puede mejorar tu trabajo como desarrollador frontend y cómo manejar GraphQL en tu aplicación frontend de React.

GraphQL para Desarrolladores de React

Today's workshop focuses on GraphQL for Front-End Developers, comparing it to REST APIs and exploring its operations and subscriptions. The workshop covers schema definition, data retrieval, and using GraphQL in the application. It also includes exercises on restructuring data, using named queries, and implementing Apollo Client. Other topics discussed are manual updates, mutations, and automatic data updates using refresh queries. The speaker also mentions the GraphQL code generator for generating TypeScript types.

There are many advantages to using GraphQL as a datasource for frontend development, compared to REST APIs. We developers in example need to write a lot of imperative code to retrieve data to display in our applications and handle state. With GraphQL you cannot only decrease the amount of code needed around data fetching and state-management you'll also get increased flexibility, better performance and most of all an improved developer experience. In this workshop you'll learn how GraphQL can improve your work as a frontend developer and how to handle GraphQL in your frontend React application.

GraphQL for React Developers

Roy Derks

En esta charla, cubriré por qué cambiar a GQL y Apollo Client 3 debería hacer que te alejes de Redux. También hablaré sobre mi transición de Redux a Apollo Client y usaré algunos ejemplos de proyectos para demostrar por qué tiene sentido de manera holística y los desafíos que experimenté durante esa transición. Hacia el final de esta charla, tendrás confianza sobre los pros y los contras de cada enfoque.

GraphQL. Gestión del estado

Today's talk is about GraphQL State Management and the benefits it offers. Redux and Apollo GraphQL are compared for their state management capabilities, with Apollo Client 3 highlighted as a powerful tool that simplifies front-end development. Data transformations and manipulation in Apollo Client, including type policies and reactive variables, are discussed as key features. The talk concludes by emphasizing the advantages of using Apollo Client for state management and providing access to the presentation materials and newsletter for further updates.

In this talk, I will cover why your switch to GQL and Apollo Client 3 should make you walk away from Redux. I will also talk about my journey from Redux -&gt; Apollo Client and use a few project examples for why it makes sense holistically and the challenges I experienced during that transition. Toward the end of this talk, you will be confident about the pros and cons of each approach.

GraphQL. State management

Ankita Kulkarni

En esta charla, cubriremos las mejores prácticas de evolución de esquemas, los errores comunes al extender un esquema GraphQL existente y los patrones para monitorear de manera segura el uso y finalmente eliminar los campos de GraphQL obsoletos con el tiempo. El esquema GraphQL de última generación no necesita versionado, ya que solo devuelve los datos que son solicitados explícitamente por un cliente. En teoría, las nuevas capacidades y tipos agregados al esquema GraphQL solo están disponibles cuando el cliente actualiza sus conjuntos de selección de operaciones. Sin embargo, en la realidad, alterar y extender un esquema GraphQL podría romper fácilmente los clientes existentes dependiendo de cómo se haya implementado el cambio, especialmente al usar tipos de enumeración, interfaz y unión.

Diseño de esquema GraphQL a prueba de futuro

Today's Talk is about GraphQL Yoga version 3, its evolution, improvements, and features. Yoga version 3 is easy to get started with, production-ready by default, and fits into any existing stack. It offers upgrades to GraphQL 2, simpler subscriptions, and a powerful deference stream feature. Yoga aims to make production deployment easier with error masking, validation and parser caching, health checks, and integration with JavaScript runtimes. The Talk also highlights the extendability of Yoga through plugins and its battle-tested nature in production.

In this talk, we will cover schema evolution best practices, common mistakes when extending an existing GraphQL schema and patterns for safely monitoring usage, and finally removing deprecated GraphQL fields over time. The state-of-art GraphQL schema does not need versioning as it only ever returns data that is explicitly requested by a client. In theory, new capabilities and types added to the GraphQL schema are only available as the client updates their operation selection sets. However, in reality, altering and extending a GraphQL schema could easily break existing clients depending on how the change has been implemented, especially when using enum, interface, and union types.

Future-Proof GraphQL Schema Design

Laurin Quast

Aprende cómo utilizar la biblioteca Neo4j GraphQL para construir APIs GraphQL en Node.js respaldadas por la base de datos de grafos Neo4j. Este masterclass cubre la construcción de APIs GraphQL utilizando la biblioteca Neo4j GraphQL y la base de datos nativa de grafos Neo4j AuraDB en la nube para construir una API GraphQL de comercio electrónico respaldada por una base de datos de grafos nativa en la nube. Tabla de contenidos:- Introducción a GraphQL y Neo4j- La biblioteca Neo4j GraphQL: modelando un grafo con definiciones de tipos GraphQL; creando y consultando una API GraphQL utilizando la biblioteca Neo4j GraphQL- Agregando lógica personalizada con Cypher y resolutores personalizados: utilizando la directiva de esquema @cypher GraphQL; agregando funciones de resolutores personalizados con la biblioteca Neo4j GraphQL- Autorización con la biblioteca Neo4j GraphQL: trabajando con JSON Web Tokens (JWT) para autenticar a los usuarios de tu API; utilizando la directiva de esquema @auth GraphQL para adjuntar reglas de autorización a tu API GraphQL Prerrequisitos:No se requiere configuración local para el masterclass. Utilizaremos Codesandbox (una herramienta basada en el navegador para editar y ejecutar código en el navegador) y Neo4j AuraDB, un servicio de base de datos administrada gratuita. Alguna familiaridad con GraphQL y JavaScript es útil, aunque no estrictamente necesario. No se requiere experiencia con Neo4j.

Construyendo APIs GraphQL con la biblioteca Neo4j GraphQL y Neo4j AuraDB

Today's workshop focused on Neo4j and GraphQL, covering topics such as graph pattern matching in Cypher, use cases for graphs in Neo4j, and the basics of GraphQL. The workshop also explored resolver functions and performance optimization in GraphQL, as well as writing queries and setting up a Neo4j Aura database. The Neo4j GraphQL library was introduced, highlighting its features and the ability to add custom logic and authorization. The workshop concluded with a discussion on connecting Neo4j Aura to a Node.js GraphQL server and implementing custom resolvers and authorization rules.

Learn how to use the Neo4j GraphQL library to build Node.js GraphQL APIs backed by the Neo4j graph database. This course covers building GraphQL APIs using the Neo4j GraphQL Library and the Neo4j AuraDB cloud-native database to build an e-comerce GraphQL API backed by a native graph database in the cloud. Table of contents:- Introduction To GraphQL &amp; Neo4j- The Neo4j GraphQL Library: modeling a graph with GraphQL type definitions; creating and querying a GraphQL API using the Neo4j GraphQL Library- Adding Custom Logic With Cypher And Custom Resolvers: using the @cypher GraphQL schema directive; adding custom resolver functions with the Neo4j GraphQL Library- Authorization With The Neo4j GraphQL Library: working with JSON Web Tokens (JWTs) to authenticate your API users; using the @auth GraphQL schema directive to attach authorization rules to your GraphQL API Prerequisites:No local setup is required for the workshop. We will make use of Codesandbox (a browser-based tool for editing and running code in the browser) and Neo4j AuraDB, a free managed database service. Some familiarity with GraphQL and JavaScript is helpful, however not strictly required. No experience with Neo4j is necessary.

Building GraphQL APIs With The Neo4j GraphQL Library & Neo4j AuraDB

GraphQL Code Generator v3 trae la forma más fácil y liviana de obtener GraphQL con tipos en tus front-ends solo generando tipos. En esta charla, veremos que generar tipos GraphQL nunca ha sido tan fácil.

GraphQL Code Generator v3: ¡generar tipos GraphQL nunca ha sido tan fácil!

Hi, everyone! Today, I'll be discussing the future of GraphQL Code Generator and the new features that enhance the developer experience. Code Gen has evolved significantly since its creation in 2016, from generating simple types to hooks and now to a new feature. It has expanded to support multiple languages and framework-specific plugins. Code Gen is widely used in the GraphQL stack, with 7 million monthly downloads on NPM. The new features include Type Document Node, which allows typing GraphQL operations without hooks, and the Client Preset, an improved version of Type Document Node. The Client Preset provides a seamless developer experience by generating the GraphQL function that returns the proper type document node type to your variable. Another interesting feature is fragment masking, which simplifies the usage of fragments in GraphQL and allows for better understanding of data dependencies within the component tree.

GraphQL Code Generator v3 brings the easiest and most lightweight way to get typed GraphQL in your front-ends by only generating types. In this talk, we will see that generating GraphQL types has never been so easy!

GraphQL Code Generator v3: generate GraphQL types has never been easier!

Charly Poly

Se están explorando diferentes enfoques para construir un lago de datos operativo con una API de acceso a datos fácil, así como una API de acceso a datos federada, y GraphQL abre oportunidades para habilitar estas arquitecturas al sentar las bases para un data mesh.

Explorando el Data Mesh impulsado por GraphQL

This Talk discusses the challenges of working with data APIs and GraphQL, including standardization, performance, and security. It emphasizes the need to optimize data fetches and push down authorization logic. The concept of externalizing authorization and using a GraphQL engine is explored. The Talk also covers the generation of GraphQL schemas and APIs, as well as the implementation of node-level security. Overall, the focus is on designing and standardizing GraphQL for data APIs while addressing authorization challenges.

Different approaches are being explored for building an operational data lake with an easy data access API, as well as a federated data access API, and GraphQL opens up opportunities for enabling these architectures by laying the foundation for a data mesh.

Exploring the Data Mesh Powered by GraphQL

Tanmai Gopal

Tal como dice la documentación de GraphQL: "Delega la lógica de autorización a la capa de lógica empresarial". ¿Es eso realmente todo lo que necesitas saber? Este consejo proviene de un buen lugar, pero depende de que sepas cómo abordar la autorización en primer lugar, ¡y este no es un problema ampliamente resuelto! Además, muchos de los enfoques utilizados en aplicaciones tradicionales no se aplican completamente. En esta charla, obtendrás un curso intensivo sobre autorización y cómo implementarla para las APIs de GraphQL."

Patrones de Autorización en GraphQL

This talk introduces the theory and practice of authorization in GraphQL, highlighting the importance of proper authorization in ensuring application functionality and security. Delegating authorization to the business logic layer is a golden rule in GraphQL, ensuring consistency and avoiding duplication of logic. Authorization can be done in the resolver layer, but it is recommended to combine it with filtering at the database level. Abstracting authorization behind an API centralizes logic and makes it easier to manage. Custom directives and permissions fields can reduce the tedium of ensuring correct authorization in every resolver.

As it says in the GraphQL documentation: "Delegate authorization logic to the business logic layer". Is that really everything you need to know? This advice is coming from a good place, but it relies on you knowing how you would go about doing authorization in the first place — and this isn't a widely solved problem! On top of that, many of the approaches used in traditional applications don't quite carry over. In this talk, you'll get a crash course in authorization and how to implement it for GraphQL APIs."

Authorization Patterns in GraphQL

Sam Scott

Todos hemos escuchado el revuelo en torno a llevar la seguridad de las aplicaciones a manos de los desarrolladores, pero si eres como la mayoría de las empresas, ha sido difícil convertir esto en realidad. No estás solo: establecer la cultura, los procesos y las herramientas necesarias para lograrlo es difícil, especialmente para aplicaciones sofisticadas como aquellas respaldadas por GraphQL. En esta sesión técnica práctica, Topher Lamey, Ingeniero Principal de StackHawk, te guiará a través de cómo proteger tus APIs de GraphQL contra vulnerabilidades utilizando pruebas de seguridad automatizadas. Prepárate para ponerte manos a la obra con las pruebas de seguridad de aplicaciones automatizadas.

Cómo automatizar las pruebas de seguridad para tu servicio GraphQL

The workshop focuses on automating security testing for a GraphQL service using software composition analysis, static application security testing (SAST), and dynamic application security testing (DAST). GitHub Actions is used to set up an automated workflow, including dependency scanning with Dependabot and code scanning with CodeQL. StackHawk is implemented for dynamic app scanning, and integration with Snyk and CodeQL is demonstrated. The workshop emphasizes the importance of early bug detection and provides insights into vulnerabilities in the GraphQL application.

We’ve all heard the buzz around pushing application security into the hands of developers, but if you’re like most companies, it has been hard to actually make this a reality. You aren’t alone – putting the culture, processes, and tooling in place to make this happen is tough – especially for sophisticated applications like those backed by GraphQL. In this hands-on technical session, StackHawk Lead Engineer Topher Lamey will walk through how to protect your GraphQL APIs from vulnerabilities using automated security testing. Get ready to roll-up your sleeves for automated AppSec testing.

How to Automate Security Testing for Your GraphQL Service

Topher Lamey

Grafbase es una plataforma de datos para desarrolladores que te permite construir e implementar backends GraphQL con una experiencia de desarrollo de primera clase.

Instantáneamente Backend GraphQL sin servidor

In the Schema 1st approach, you can build and deploy a backend only by writing your GraphQL SDL. Connect this to GitHub, and GraphBase takes care of the rest. Once the code is deployed, sign in to GraphBase using your GitHub account and explore the dashboard, schema, and playground. GraphBase offers authentication, authorization, permissions, and custom directives. Connect GraphBase to user-management software and create sign-in and sign-up pages.

Grafbase is a data platform for developers that lets you build and deploy GraphQL backends with a top-notch developer experience.

Instant Serverless GraphQL Backends

Jamie Barton

Con StackHawk, los equipos de ingeniería pueden realizar pruebas de seguridad en las API de GraphQL para encontrar y solucionar vulnerabilidades antes de que lleguen a producción. Con pruebas automatizadas en cada PR, puedes estar seguro de que tu aplicación es segura. Únete a Scott Gerlach, cofundador y Director de Seguridad de StackHawk, para obtener una breve descripción de las pruebas de seguridad de GraphQL con StackHawk.

Pruebas de seguridad modernas para API de GraphQL

DAST helps prioritize fixing application security issues by identifying discoverable and exploitable vulnerabilities. StackHawk runs active security tests against APIs to ensure safe handling of user input and output. It also implements OWASP top 10 API best practices. The tool can be used locally and in CI/CD pipelines.

With StackHawk, engineering teams can run security tests against GraphQL APIs to find and fix vulnerabilities before they hit production. With automated testing on every PR, you can be confident that your app is secure. Join StackHawk co-founder and Chief Security Officer Scott Gerlach for a quick overview of GraphQL security testing with StackHawk.

Modern GraphQL API Security Testing 

Scott Gerlach

Lanzamos la próxima versión principal de GraphiQL a principios de este año! Repensamos por completo la experiencia con un enfoque particular en la personalización. No todos los usuarios y cada API tienen las mismas necesidades para un entorno de desarrollo integrado (IDE) de GraphQL, por lo que uno de nuestros grandes objetivos fue permitir que GraphiQL funcione para una gran variedad de casos de uso. Sumergámonos en los cambios de cómo llevamos la personalización al siguiente nivel y exploremos juntos cómo puedes hacer que GraphiQL sea tuyo.

El nuevo GraphiQL: Personalización al siguiente nivel

GraphQL is successful due to its tooling and customizability, but developers face challenges such as learning, syntax, schema exploration, API building, visualization, documentation, and collaboration. GraphQL version 2 has made significant improvements, including a plugin API and building blocks in GraphQL React. Customization in GraphQL involves overriding CSS variables and building custom functionality using plugins. The ability to embed a GraphQL IDE into a blog allows users to interact with GraphQL concepts directly. Overall, GraphQL continues to evolve and adapt to the changing needs of its ecosystem.

We shipped the next major version of GraphiQL earlier this year! We completely rethought the experience with a particular focus on customizability. Not all users and every API have the same needs for a GraphQL IDE, so one of our big goals was to allow GraphiQL to work for a large variety of use-cases. Let's dive deep into the changes of how we took the customizability to the next level and explore together how you can make GraphiQL your own.

The new GraphiQL: Next-level Customizability

Thomas Heyenbrock

Únete a Thomas del equipo de GraphQL en Neo4j mientras habla sobre una de las características más nuevas de la biblioteca Neo4j GraphQL: Suscripciones GraphQL. Utilizando esta nueva característica, los consumidores de la API GraphQL pueden escuchar los cambios de datos en tiempo real que ocurren en Neo4j a través de la biblioteca GraphQL. Después de una visión general de alto nivel de la biblioteca Neo4j GraphQL, demostrará la nueva característica de Suscripciones.

Actualizaciones de datos en tiempo real para Neo4j utilizando suscripciones GraphQL

This Talk is about real-time data updates for Neo4j using GraphQL subscriptions. The Neo4j GraphQL library provides automatic schema generation, read queries, mutations, and resolvers. It handles subscriptions using WebSockets and is completely agnostic. The library also has built-in support for events and relationships, allowing for real-time updates and easy scaling. The Talk concludes with details about subscriptions using AMQP and a showcase of Neo4j GraphQL subscriptions in a project called neo place.

Join Thomas from the GraphQL Team at Neo4j as he talks about one of the newest features of the Neo4j GraphQL Library: GraphQL Subscriptions. Using this new feature, GraphQL API consumers can listen to data changes in real-time, which happen in Neo4j via the GraphQL Library. Following a high-level overview of the Neo4j GraphQL Library, he will demonstrate the new Subscriptions feature.

Real-Time Data Updates for Neo4j Using GraphQL Subscriptions

Thomas Wiss

En un mundo dirigido por datos, nosotros como desarrolladores hemos recurrido a esquemas para ayudar a describir y organizar esos datos. Pero ¿qué sucede cuando tienes un montón de esquemas para hacer un seguimiento? En esta charla aprenderás el papel de todos los diferentes esquemas en una API de GraphQL.

Esquemas en todas partes: Entendiendo GraphQL, Bases de Datos y Prisma

Welcome to the talk! As developers, we manage and understand the data that the world runs on. Each individual schema in your infrastructure defines your data in the context of its own domain. The Prisma schema is used to generate migrations and create a mapping between the database and API, enabling type-safe interactions. The GraphQL schema allows clients to safely query the database via the API. By using Prisma and GraphQL Code Generator, you can achieve an end-to-end type-safe environment.

In a world run by data, we as developers have turned to schemas to help describe and organize that data. But what happens when you have a ton of schemas to keep track of? In this talk you will learn the role of all the different schemas in a GraphQL API.

Schemas Everywhere: Understanding GraphQL, Databases & Prisma

Sabin Adams

Los servidores GraphQL son componentes críticos de tu infraestructura y deben ser altamente disponibles, confiables y tolerantes a fallos. Esta charla demuestra cómo aprovechar el filtro de proxy GraphQL Envoy de Solo.io para implementar puntos finales GraphQL a prueba de balas que sean confiables, seguros y amigables para los desarrolladores. ¡Todo esto sin escribir ningún código!

¿Sin código? ¡Sin problema! Cómo los servidores GraphQL fallan y cómo fortalecer tus resolvers

We discuss GraphQL servers, their current state, and how to harden resolvers. The talk explores the working of resolvers, handling server outages, and implementing passive health checking. It also delves into the role of API Gateways, proxies, and declarative resolvers in improving network traffic handling. The use of JQ for data transformation and outlier detection is demonstrated. The talk concludes with the importance of resilient resolvers and engagement with the GraphQL community.

GraphQL servers are critical components of your infrastructure and must be highly-available, reliable, and fault-tolerant. This talk demonstrates how to leverage Solo.io’s GraphQL Envoy proxy filter to deploy bullet-proof GraphQL endpoints that are reliable, secure, and developer-friendly. All without writing any code!

No Code? No Problem! How GraphQL Servers Break and How to Harden Your Resolvers

Kevin Dorosh

Sai Ekbote

Todos hemos escuchado el revuelo acerca de trasladar la seguridad de las aplicaciones a manos de los desarrolladores, pero si eres como la mayoría de las empresas, ha sido difícil convertir esto en realidad. No estás solo: establecer la cultura, los procesos y las herramientas necesarias para lograrlo es complicado, especialmente para aplicaciones sofisticadas respaldadas por GraphQL. En esta sesión técnica práctica, el Ingeniero Principal de StackHawk, Topher Lamey, te guiará sobre cómo proteger tus APIs de GraphQL contra vulnerabilidades mediante pruebas de seguridad automatizadas. Prepárate para ponerte manos a la obra con las pruebas automatizadas de seguridad de aplicaciones.

GraphQL Declarativo en una Puerta de Enlace Nativa en la Nube

This workshop provides an overview of GraphQL, a schema query language that allows you to request exactly what you need from the server. BlueEdge integrates GraphQL as an API gateway for microservices. The workshop covers topics such as installing BlueEdge, creating virtual services, generating schemas, and running queries. It also explores the benefits of GraphQL aggregation, schema stitching, and securing GraphQL APIs with external authentication.

Declarative GraphQL in a Cloud-Native Gateway

Leon Nunes

Hay un grupo de desarrolladores que intenta convencerte de que GraphQL solo pertenece al front-end. Únete a la resistencia y descubre el verdadero poder de GraphQL como una herramienta ubicua y agnóstica para la normalización de datos. Desde patrones basados en eventos y sin servidor, hasta plataformas de bajo código, hablaremos sobre el por qué y el cómo de liberar el acceso a los datos con GraphQL.

GraphQL en todas partes

GraphQL is a preferred tool for solving the complex data access challenge in the current ecosystem. It allows merging diverse sets of data into a single API, reducing overhead and providing reusable patterns. GraphQL's purpose is to define data dependencies and it aligns with accessing complex data models and federated data dependencies. Hasura introduces the GraphQL data specification, a powerful tool for defining data needs and creating APIs. They are actively hiring and encourage users to try out their alpha release and provide feedback.

There's an old guard of developers that try to convince you that GraphQL only belongs on the front-end. Join the resistance and see the true power of GraphQL as the ubiquitous and agnostic tool that it is for data normalization. From event-driven, serverless patterns, to low-code platforms, we'll talk about the why and how of freeing data access with GraphQL.

GraphQL Galaxy 2022

The biggest GraphQL conference in the cloud