GraphQL Galaxy

GraphQL Galaxy 2022

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

React Day Berlin

React Day Berlin 2022

Today's Talk introduces TRPC, a library that eliminates the need for code generation and provides type safety and better collaboration between front-end and back-end. TRPC is demonstrated in a Next JS application integrated with Prisma, allowing for easy implementation and interaction with the database. The library allows for seamless usage in the client, with automatic procedure renaming and the ability to call methods without generating types. TRPC's client-server interaction is based on HTTP requests and allows for easy debugging and tracing. The library also provides runtime type check and validation using Zod.

Do you know we can replace API schemas with a lightweight and type-safe library? With tRPC you can easily replace GraphQL or REST with inferred shapes without schemas or code generation. In this talk we will understand the benefit of tRPC and how apply it in a NextJs application. If you want reduce your project complexity you can't miss this talk.

Get rid of your API schemas with tRPC

Giorgio Boa

Vue.js Live Conference

Vue.js Live 2024

Composables are the Swiss Army knife of every Vue.js developer, helping build more extensible, adaptable, controllable, and trustful applications. They replace mixins and can be used everywhere, connecting different parts of the system and sharing common state. Composables are versatile, allowing for local or global use, and can be applied in both the domain layer and UI. They provide adaptability, controllability, easy testing, and eliminate the need to test the environment. Consider using Vue use for a library of composables and start building your own collection.

<div>Composables (composition functions) are stateful/stateless functions that can leverage Vue's reactivity API, decoupling it from components. </div><div>This shift in perspective opens the possibility for tackling common scenarios in a new and creative way.</div>

The Swiss Army Knife of Every Vue Developer

Juan Andrés Núñez Charro

Data loaders provide a solution for complex and repetitive data fetching in Vue.js applications. Using data loaders allows for more independent data fetching and integrates with the navigation cycle. The data loader plug-in adds a navigation guard for data fetching and loading. Lazy loading and caching can be implemented using Pina Colada and Glada loaders. These loaders can improve the performance and speed of data fetching in applications.

Data fetching is a critical part of modern web applications. It's a complex problem that has been (partially) solved in many different ways. In this talk, we'll explore the new Data Loaders API for Vue Router, how it compares to existing solutions, and how it can greatly simplify data fetching in your Vue applications.

Data Loaders - Elevating Data Fetching in Vue

Eduardo San Martin Morote

Node Congress

Node Congress 2024

Async local storage is an API that has been around in Node for quite some time and is gaining popularity in other frameworks and runtimes. It allows for easier logging by eliminating the need to pass values through multiple functions. The storage frame in async local storage acts as a map, storing key-value pairs. Tasks and promise continuations are used to perform the next steps in a promise chain. Async Context is a TC39 proposal that adds async local storage to the JavaScript language.

The AsyncLocalStorage API in Node.js is a powerful tool that has since been adopted across multiple runtimes. There is even an effort underway to standardize a variation of the API within JavaScript itself. But what is it? And more importantly, how does it work?

Understanding Async Context

James Snell

This talk focuses on improving performance in Node.js API development. It covers various areas such as optimizing database work, connection pool, JSON parsing, logging, and web framework selection. Key highlights include the use of Native Mongo Driver for better database performance, optimizing connection pool for improved throughput, replacing Express serializer for faster serialization and deserialization, and choosing Festify as an efficient web framework. Caching and authentication's impact on performance is discussed, along with recommendations for caching types. The talk also emphasizes considering environmental factors and human impact on performance. Fastify is highlighted as a recommended tool for Node.js performance optimization.

Node.js servers need to process a large number of requests concurrently as the scale grows.  A Node.js micro service which receives an API request needs to do multiple actions, like parsing JWTs, use caching, work with the databases and more. In this talk, Tamar will show strategies to improve your REST API performance - starting from new Node.js frameworks that can work faster, better parsing of request parts, efficient work with caching and DB , better parallelism and more strategies. The talk will include demos, benchmarks and profiling of code to see the improvements. At the end of this talk, developers will have practical knowledge on how to improve API performance in various Node.js platforms.

Making My Node.js API Super Fast

Tamar Twena-Stern

React Day Berlin 2023

Today's Talk explores three powerful web APIs: indexedDB, cache storage, and the filesystem API. IndexedDB enables offline functionality and provides advanced features like coding & indexing, transactions, versioning, and security. Cache storage supports various caching strategies and namespaces, while the File System API allows fine-grained control over files, facilitating file uploads and downloads. A code example of interacting with the File System API is also provided.

Are you tired of relying on outdated web storage techniques? Join us as we explore the latest advancements in web storage and data management that will supercharge your web applications! In this presentation, we will dive into the world of advanced APIs such as IndexedDB, CacheStorage, FileSystem API, and more. We'll compare the benefits and limitations of each API, discussing their persistence, quota, security, and performance. We'll also explore real-world use cases and discuss web storage beyond local-storage and session-storage

The Future of Web Storage: Exploring Advanced Storage APIs 

Shubham Gautam

Today's Talk covers various web APIs and their functionalities, including the intersection observer API, screen wake lock API, background sync API, and broadcast channel API. The speaker emphasizes the importance of optimizing performance and using standardized code to reduce application bundle size. They also highlight the need for environmental responsibility in JavaScript development. The Talk addresses handling API support and modifying code to suit different browser implementations.

When writing code for the Web, there are a lot of capabilities that are offered out of the box by our browsers. If you ever wrote a File Upload component, used timers and intervals, interacted with the DOM, or stored something in the Local/Session Storage, you had to go to the MDN’s Web API docs, to find some relevant information on how to implement that code. In this session, we will delve into the exciting world of browser Web APIs that are not so commonly used (although they should be) and explore their incredible capabilities 🚀 All these features offer new opportunities for creating immersive web experiences that can help businesses grow and connect with customers. So if you are the kind of an engineer who wants to stay ahead of the curve when it comes to web development, learn how Intersection Observer, Background Sync API, Screen Wake Lock API (and many more) can help you create better web applications that will keep users engaged and coming back for more!

Superpowers of Browser's Web API

Nikola Mitrovic

Today's Talk covers the challenges of developing APIs and the available tools to simplify the process. It also demonstrates building a pizza menu application using React and Fastify, with documentation and SDK generation using Swagger and OpenAPI. Orval is introduced as a tool for generating mutations, testing with mock service worker-generated mocks, and using Zod for validation. It supports multiple languages and frameworks, and allows consuming APIs from various resources. The SDK can be tracked using version control, and Open API specifications can generate Swagger UI and Redux doc asserts.

In this talk, I'll introduce the audience to the potential of OpenAPI in simplifying and enhancing the development process for React applications. I will demonstrate how OpenAPI can be harnessed to seamlessly autogenerate REST APIs, streamlining the consumption of data within React projects. With a keen focus on efficiency and reliability, attendees will gain valuable insights into implementing automated tests to ensure robustness and quality in their applications.

How to Automatically Consume APIs with React

Theodore Vorillas

React Summit US

React Summit US 2023

In this Workshop, we explore GraphBase and GraphQL, focusing on using Neon as a connector and Postgres as a database. We learn how to set up Neon and the Postgres connector, automatically generate a GraphQL schema, and create a GraphQL API with Neon. We also delve into edge caching, extending GraphQL APIs, and integrating with MongoDB, Contentful, and other data services. Additionally, we cover adding API rules and security with Click as the auth provider.

Learn how to generate instant GraphQL APIs using a data source connector (GraphQL and non-GraphQL sources), extend and join them both with custom resolvers and deploy to the edge without leaving the code editor.

Build and Deploy Instant GraphQL APIs to the Edge

Jamie Barton

React Advanced

React Advanced 2023

Steven, a design tool nerd, worked on InVision Studio and now focuses on LiveBlocks, providing APIs and tools for multiplayer collaboration. Collaborative design tools like Figma, Canva, Mural, Notion, Mirror, Linear, and Pitch use conflict resolution algorithms such as OTs and CRDTs. Data migration and collaboration patterns are important considerations for building production applications. Figma stands out for its seamless assembly of collaboration features. LiveBlocks enables front-end developers to build collaborative experiences without complex backend infrastructure, using fractional indexing for consistent ordering.

Practical talk showing how to go from a local state to an on-the-edge offline capable persisted state to make an app like Figma, Notion, and more.

Real-Time Collaborative State on the Edge

Steven Fabre

The speaker discusses the challenges of server state and test maintenance, and how they found solutions using React Query and Mock Service Worker. They emphasize the benefits of defining contracts for faster development and stress reduction. The speaker also highlights the advantages of using Mock Service Worker over mock servers and explains how it allows for easy customization and test overrides. They mention the upcoming release of V2 of MS-Double and encourage the audience to stay updated.

How many times have you had to wait for your backend team to finish building the API so you can start your tasks? What if all you needed to move that task to in progress was the API contract? What if there was a library that did this for REST and GraphQL APIs and, at the same time, taking your tests to the next level? Join me and prepare to enhance your developer experience while learning all the battle-earned experiences of using one of my favorite libraries: Mock Service Worker.

All You Need Is a Contract…

Daniel Afonso

React Summit

React Summit 2023

GraphQL is a strongly typed, version-free query language that allows you to ask for specific data and get it in JSON format. It simplifies data retrieval and modification by allowing the server to handle all necessary operations. Serverless architectures, such as AWS Lambda, are scalable, cost-effective, and good for event-driven applications. Event sourcing and CQRS are techniques that ensure consistency and separate reading and writing parts of an application. Building a GraphQL API with commands and queries can be achieved using AWS AppSync and DynamoDB. This approach offers low latency, scalability, and supports multiple languages. Challenges include application complexity, data modeling, and tracing, but starting with simplicity and making something work first can lead to success.

GraphQL is a powerful and useful tool, especially popular among frontend developers. It can significantly speed up app development and improve application speed, API discoverability, and documentation. GraphQL is not an excellent fit for simple APIs only - it can power more advanced architectures. The separation between queries and mutations makes GraphQL perfect for event sourcing and Command Query Responsibility Segregation (CQRS). By making your advanced GraphQL app serverless, you get a fully managed, cheap, and extremely powerful architecture.

Advanced GraphQL Architectures: Serverless Event Sourcing and CQRS

Slobodan Stojanović

JS Nation

JSNation 2023

Technology is a spiral, with foundational ideas resurfacing. Java revolutionized enterprise applications. REST and JSON simplified building APIs and websites. Node.js enabled fast and custom development, leading to the microservices revolution. Platformatic aims to fill the gap in building, managing, and scaling microservices painlessly.

As developers we stand on the shoulders of giants, and it can be helpful to take a look at the past to gain a better perspective. In this talk we’ll briefly explore the past decade of backend development and architectural patterns. We’ve often ditched technologies in an attempt to make the developer experience frictionless. However we sometimes forget what we can learn from “the good old days”. What are you building: a monolith, a microservices system or something in between? A shift in how we see things can help us keep moving forwards.

APIs are Evolving. Again.

Matteo Collina

Luca Maraschi

Vue.js London 2023

Let's talk about Vue 3 and creating your first open source library. We'll discuss design choices, a personal example of creating a Vue 3 open source library, community and open source, lessons learned, and key takeaways for creating an open source project. We'll also cover building a Vue 3 library, the Authenticator project and its requirements, code sharing and best practices, using Xstate for state management, Vue 3 best practices, testing strategies, open sourcing and community feedback, documentation driven development, challenges and improvements, and the roadmap for the future.

Learn about how to create a Vue.js library, and what best practices you should follow. We'll also learn about open source, and how maintainers work. We'll touch on xState, the composition API and testing strategies including Cypess and Vue test utils!

Creating My First Open Source Vue 3 Library

Erik Hanchett

This talk compares Rev and Reactive in Vue 3, exploring reactivity and their limitations. It discusses the use of watchers, identity issues, and migration strategies. The talk also highlights the benefits of using the Ref function for better reactivity and the recommended pattern of grouping Refs. Opinions from the Vue community are shared, with a majority preferring Ref over Reactive.

There are two approaches to add a reactive state to Vue components using the Composition API. As a result, you must choose whether to utilize reactive(), ref(), or both. I'll guide you in making the best decision.

Ref() vs. Reactive(): What to Choose Using Vue 3 Composition API?

Michael Hoffmann

Node Congress 2023

TRPC is a tool that simplifies API development by allowing you to call functions in the backend and have the type data inferred into the frontend without code generation. It provides type safety and auto completion when querying databases using Prisma. TRPC can be used with various frontend frameworks and has features like automatic batching and middlewares. It can be shared between repositories using a monorepo or by publishing the types as an npm package. TRPC is easy to set up compared to gRPC and provides built-in input and output validation.

How, why and how to use tRPC by the creator of it

tRPC - Move Fast and Break Nothing

Alexander Johansson

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

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

TestJS Summit

TestJS Summit 2022

At StackHawk, we do application security testing, specifically dynamic application security testing. Legacy DAST tools are not effective for testing JavaScript front ends and APIs. To achieve better testing, it is essential to drive the API directly using industry standards like postman collections, OpenAPI spec, GraphQL, and introspection queries. StackHawk simplifies finding and fixing security issues in applications, integrating with CI/CD processes and providing simple descriptions and examples. Start a free trial at stackhawk.com to improve software quality.

Traditional security testing for JS apps has focused on the front-end, but actual security issues most often lie in the backing REST API. Join StackHawk co-founder Scott Gerlach for a quick overview of why you need to rethink how you test your JS apps and how StackHawk can help you find and fix security bugs fast.

Automated Security Testing for JS Apps

Scott Gerlach

React Advanced 2022

The Workshop covers best practices and patterns for managing API requests in states. It is divided into three parts: fetching and posting data with Axios, implementing the API layer and React Query, and using React Query for API requests. The Workshop also discusses request cancellation, providing meaningful feedback during API requests, and implementing loaders and pagination. The API layer approach separates API logic from components, making it easier to maintain and extend the codebase. React Query offers features like caching and deduping requests, improving the handling of API requests.

With the rise of frameworks, such as React, Vue or Angular, the way websites are built changed over the years. Modern applications can be very dynamic and perform multiple API requests to populate a website with fresh content or submit new data to a server. However, this paradigm shift introduced new problems developers need to deal with. When an API request is pending, succeeds, or fails, a user should be presented with meaningful feedback. Other problems can comprise API data caching or syncing the client state with the server. All of these problems require solutions that need to be coded, but these can quickly get out of hand and result in a codebase that is hard to extend and maintain. In this workshop, we will cover how to handle API requests, API states and request cancellation by implementing an API Layer and combining it with React-Query. Prerequisites: To make the most out of this workshop, you should be familiar with React and Hooks, such as useState, useEffect, etc. If you would like to code along, make sure you have Git, a code editor, Node, and npm installed on your machine.

Best Practices and Patterns for Managing API Requests and States

Thomas Findlay

React Summit 2022

The Workshop covered various topics related to AG Grid and React. It included installing dependencies, pulling data from remote sources, adding sorting and filtering capabilities, exploring grid properties and events, using Aggrid Enterprise for advanced functionality, and creating custom renderers and filters. The Workshop also discussed TypeScript support, server-side row model, and applying filters. Overall, the Workshop provided a comprehensive overview of AG Grid and React integration with a focus on practical usage and customization.

Get started with AG Grid React Data Grid with a hands-on tutorial from the core team that will take you through the steps of creating your first grid, including how to configure the grid with simple properties and custom components. AG Grid community edition is completely free to use in commercial applications, so you'll learn a powerful tool that you can immediately add to your projects. You'll also discover how to load data into the grid and different ways to add custom rendering to the grid. By the end of the workshop, you will have created an AG Grid React Data Grid and customized with functional React components.- Getting started and installing AG Grid- Configuring sorting, filtering, pagination- Loading data into the grid- The grid API- Using hooks and functional components with AG Grid- Capabilities of the free community edition of AG Grid- Customizing the grid with React Components

Hands-on with AG Grid's React Data Grid

Sean Landsman

StackHawk is a dynamic application security testing tool that helps developers find and fix security issues. The scan identified a SQL injection issue and a cross site scripting issue. The StackHawk YAML is used to configure the scanner with important information such as the application's location, environment, and ID. The scanner can also be pointed at open API spec or GraphQL definitions. Try StackHawk for free at stackhawk.com and integrate it into your development process to improve software quality.

Traditional security testing for JS apps has focused on the front-end, but actual security issues most often lie in the backing REST API. Join StackHawk co-founder Scott Gerlach for a quick overview of why you need to rethink how you test your JS apps and how StackHawk can help you find and fix security bugs fast.

Automated Application Security Testing 

Node Congress 2022

Welcome to the Database Workflows and API Development with Prisma workshop. Prisma is an ORM that allows you to work with a relational database from an object-oriented programming language. The workshop covers topics such as data modeling, migrations, using Prisma Client for querying the database, and implementing REST and GraphQL APIs. It also highlights the benefits of Prisma, including its intuitive data modeling language, type-safe database client, and migration tool. The workshop provides hands-on tasks and guidance for beginners to get started with Prisma.

Prisma is an open-source ORM for Node.js and TypeScript. In this workshop, you’ll learn the fundamental Prisma workflows to model data, perform database migrations and query the database to read and write data. You’ll also learn how Prisma fits into your application stack, building a REST API and a GraphQL API from scratch using SQLite as the database. Table of contents: - Setting up Prisma, data modeling &amp; migrations- Exploring Prisma Client to query the database- Building REST API routes with Express- Building a GraphQL API with Apollo Server <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Database Workflows & API Development with Prisma

Nikolas Burk

GraphQL Galaxy 2021

This workshop focuses on building a GraphQL API on top of the Ethereum blockchain, using the Graph Protocol. The Graph provides a decentralized approach to data querying and storage, allowing developers to build decentralized APIs that read and index blockchain data. The workshop covers topics such as creating subgraphs, defining data models, handling events, and deploying and querying the subgraph. Participants learn how to interact with smart contracts and the Graph Node, and how to customize queries to retrieve specific information.

The Graph is an indexing protocol for querying networks like Ethereum, IPFS, and other blockchains. Anyone can build and publish open APIs, called subgraphs, making data easily accessible. In this workshop you’ll learn how to build a subgraph that indexes NFT blockchain data from the Foundation smart contract. We’ll deploy the API, and learn how to perform queries to retrieve data using various types of data access patterns, implementing filters and sorting. By the end of the workshop, you should understand how to build and deploy performant APIs to The Graph to index data from any smart contract deployed to Ethereum. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building GraphQL APIs on top of Ethereum with The Graph

Nader Dabit

The Workshop covered various topics related to software development and engineering. It included discussions on coding, communication, and troubleshooting Wrangler configuration. The participants learned about proxying requests in Cloudflare Workers, identifying mutations in GraphQL queries, and caching responses in a KV store. They also explored the AST with astexplorer.net and manipulated the AST to add type names to queries. The Workshop concluded with a discussion on caching subscriptions in GraphQL and handling mutations and query invalidation.

Table of contents: - Deploying a premade GraphQL API - Creating an edge worker + cache on Cloudflare - Configuring caching based on typenames - Adding invalidation based on mutation return types <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Recreating urql's GraphQL cache on the edge

Andy Richardson

Maxime Beunier, a developer advocate at MongoDB, demonstrates how to build a serverless GraphQL API using MongoDB Atlas and Realm. He creates a new app called Galaxy, links it to the production cluster, and deploys it in Ireland. He then shows how to authenticate users and obtain a token to access the GraphQL API. The demo showcases the ease and speed of building a serverless GraphQL API and provides all the necessary links for further exploration.

<div>At the beginning of the COVID-19 pandemic, Johns Hopkins University worked on gathering and refining data from multiple sources and provided the world with a Github repository and a bunch of CSV files. The Problem? It’s nearly impossible to build anything from raw data like this.In this live coding session, MongoDB Developer Advocate Maxime Beugnet will show you how to build a serverless GraphQL API based on this dataset using Python and the MongoDB Data Platform. We are finally going to put serverless and the MongoDB generous free tier to good use!</div> <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building a Serverless GraphQL API in 7 Minutes

Maxime Beugnet

This Talk is about building GraphQL APIs on top of Ethereum and the Ethereum virtual machine. The graph is an indexing protocol for querying blockchain networks like Ethereum and IPFS. Developers can build APIs called subgraphs to efficiently index data and make it available for querying from frontend applications. The graph serves over 1 billion queries per day and is used in various Web3 applications including DeFi, gaming, and NFT marketplaces. The process involves defining the data model using the GraphQL schema and contract addresses, deploying and testing the subgraph, and using a GraphQL client to query the subgraph.

Blockchains are databases with a unique set of properties. Unlike most databases which are optimized for both read and write operations, blockchains are optimized for write operations, typically focused on optimizing and scaling transaction cost, transaction volume, and transaction speed. In this talk, I'll dive into the web3 space, and show how developers can leverage The Graph Protocol to build performant, scalable, and decentralized GraphQL APIs and dapps on decentralized networks like Ethereum and IPS. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building GraphQL APIs on Ethereum

GraphQL can be used beyond HTTP, including scenarios like WebSockets for real-time messaging. It is versatile and can handle background jobs, generate reports, export large amounts of data, and handle webhook payloads. GraphQL's support for WebAssembly allows for executing user-provided code while maintaining security and authorization.

You might be familiar with HTTP GraphQL APIs. Did you know GraphQL does not have to be delivered over HTTP? We can use GraphQL in some different contexts. asynchronous queries, batch operations, user-provided scripts, WebAssembly, webhooks, and many more. We will explore how Shopify uses GraphQL in different contexts and how you can extend your current GraphQL schema beyond HTTP APIs. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

GraphQL Beyond HTTP APIs

Guilherme Vieira

GraphQL is an up and coming trend in API development, allowing for the combination of REST endpoints into a single API call. Tyk, an open source API gateway vendor, is now offering full lifecycle API management. With GraphQL, developers can import REST APIs into Tyk and convert them into GraphQL APIs, simplifying the process and reducing the number of API calls required. This lightning talk provides a demonstration of importing IDs, defining data sources, and combining endpoints using GraphQL.

REST is an API design architecture, which, in the last few years, has become the norm for implementing web services. It uses HTTP to get data and perform various operations (POST, GET, PUT, and DELETE) in JSON format, allowing better and faster parsing of data. But REST comes with some downsides that have enterprises considering alternative mechanisms to manage performance, developer time, and production of their APIs — enter GraphQL. GraphQL doesn't have to be a replacement to REST, the two API designs can co-exist and be leveraged for the appropriate use-case. Join us for a conversation about what benefits, shortcomings, tooling, and design decisions you need to consider while making this evaluation. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

All Things Graph...

Sedky Haider

This Talk explores the performance implications of using GraphQL in a hotel property management system. It discusses optimizing GraphQL API calls, schema design, and caching using Data Loader. The use of automatic persisted queries and caching can improve performance. The impact of response size and pagination in GraphQL queries is also addressed. Additionally, the Talk emphasizes the importance of monitoring and testing queries, as well as improving perceived performance through visual feedback.

GraphQL abstracts the downstream API calls from the frontend and all that frontend has to do is request fields in a query that are required for the rendering of the component. The frontend is not aware that a corresponding field might result in an API call or heavy computations on the backend side. This abstraction hits the performance when the GraphQL schema is not structured properly. Let's take an example to understand more:Here's the query to get available rooms for a hotel:hotel (id: $hotelId) { id rooms { id type name } }The frontend doesn't know that the rooms field inside the query hotel will fire another API call even type field would be fetched from another API endpoint. These nested API calls worsen the performance if there are more rooms. We can effectively solve this structuring the schema well and using data loaders.

GraphQL Performance and Monitoring

Ankita Masand

Max Stoiber, co-founder of GraphCDN, discusses the challenges faced with RethinkDB and the need for caching in a read-heavy API. He explores how GraphQL clients handle caching and the potential of running a GraphQL client at the edge for faster response times. Authorization and cache key management at the edge are also discussed, along with the benefits of edge-caching and the importance of caching in GraphQL APIs. The audience response reveals that a significant percentage are already caching their APIs, while different use cases for caching and the concept of edge computing are explained.

For years, not being able to cache GraphQL was considered one of its main downsides compared to RESTful APIs. Not anymore. GraphCDN makes it possible to cache almost any GraphQL API at the edge, and not only that but our cache is even smarter than any RESTful cache could ever be. Let's dive deep into the inner workings of GraphCDN to figure out how exactly we make this happen. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

How to Edge Cache GraphQL APIs

Max Stoiber

Today's workshop focused on building GraphQL APIs using Neo4j, a graph database. The Neo4j GraphQL library was used to generate the API, handle data fetching, and solve the N plus one query problem. Custom logic and authorization rules were added using Cypher statements and the auth schema directive. The workshop also covered filtering, sorting, and pagination options in GraphQL, as well as the integration of Neo4j with Code Sandbox and Neo4j Aura DB. Overall, the workshop provided a comprehensive overview of building GraphQL APIs with Neo4j and highlighted the benefits and challenges of using this technology.

This workshop will explore how to build GraphQL APIs backed Neo4j, a native graph database. The Neo4j GraphQL Library allows developers to quickly design and implement fully functional GraphQL APIs without writing any resolvers. This workshop will show how to use the Neo4j GraphQL Library to build a Node.js GraphQL API, including adding custom logic and authorization rules. Table of contents: - Overview of GraphQL and building GraphQL APIs - Building Node.js GraphQL APIs backed a native graph database using the Neo4j GraphQL Library - Adding custom logic to our GraphQL API using the @cypher schema directive and custom resolvers - Adding authentication and authorization rules to our GraphQL API <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building GraphQL APIs With The Neo4j GraphQL Library

William Lyon

TestJS Summit 2021

This Talk discusses the use of end-to-end tests for API development, specifically using the Nest.js framework. The process of initializing the Nest API for testing is explained, along with customization options such as overriding authentication guards. The benefits of end-to-end tests are highlighted, including ease of modification and serving as additional documentation for the API. The challenges of writing the initial version of the test and a trick for mocking the date in tests are also mentioned.

Having adequate test coverage means a lot for the good API. But what can make the whole life pathetic is endless mocking of data and functions for integration tests. Every time you've changed the code you need to fix the mock. After several iterations the correct thought is - what's went wrong? Alternative approach is e2e tests for the API. Which require only minimal mocks and data preparation. The rest - pure code of your API. Change the code - e2e test remains the same.This talk is about my experience of switching from integration tests to e2e tests for the API, proc and cons and how I started to feel happy about tests. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

E2E Tests for API – Saving Nerves and Hours

Valentin Kononov

StackHawk is a dynamic application security testing tool that helps you find, understand, and fix security bugs in your running HTTP applications and API endpoints. It runs active security tests using OWASP top 10 best practices and can be integrated into CI/CD workflows. The scanner provides detailed scan results, including findings like SQL injection and cross-site scripting issues, and can be configured using YAML. StackHawk can be used to triage and prioritize security issues, and it can be seamlessly integrated into the development workflow.

With StackHawk, engineering teams can run security tests against JS applications and the backing APIs to find and fix vulnerabilities faster. With automated testing on every PR, you can be confident that your app is secure. Join StackHawk co-founder Scott Gerlach for a quick overview of JS application security testing with StackHawk. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Automated Application Security Testing

Maaret Pyhäjärvi, a principal test engineer at Vaisala, emphasizes the importance of balancing different types of testing to build better teams. Testing the application with different locations reveals potential issues with its behavior. The speaker highlights the significance of testing integrations and dependencies, including libraries and operating systems. They prefer code-oriented tools like Requests and Python for API testing. Exploratory testing is the only type of testing they perform, and they encourage others to participate in it as well.

Coming into software with an exploratory testing mindset is like coming to a multi-layer canvas with lots of information and an open ended task: find what we may have missed! This is the assignment for us all in software teams in our quest for quality. Framing the search of how our system falls short of expectations is easier when we are able to see software from its user’s perspective. However, useful tests aren’t a collection of end-to-end tests we automate, but great tests to leave behind will decompose the testing problem differently. In this talk, we learn about using architecture as a filter in decomposing tests and look at an example of taking control over the API responses to test a React frontend. Users don’t know or care if the problem is in the frontend and services your team provided if it fails to meet their expectations but you care. Granularity of feedback matters. Recognizing the same problems in incomplete scope - half-done features or only in frontend or APIs - is a skillset the software industry needs to be building. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Go Find What We May Have Missed!

Maaret Pyhäjärvi

React Advanced 2021

This Talk covers advanced patterns for API management in large-scale React applications. It introduces the concept of an API layer to manage API requests in a more organized and maintainable way. The benefits of using an API layer include improved maintainability, scalability, flexibility, and code reusability. The Talk also explores how to handle API states and statuses in React, and provides examples of canceling requests with Axios and React Query. Additionally, it explains how to use the API layer with React Query for simplified API management.

In this talk, you will discover how to manage async operations and request cancellation implementing a maintainable and scalable API layer and enhancing it with de-coupled cancellation logic. You will also learn how to handle different API states in a clean and flexible manner. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Advanced Patterns for API Management in Large-Scale React Applications

Node Congress 2021

Today's workshop focused on observability in modern Node.js applications and the challenges in distributed systems. The workshop covered building an Express application, making API requests, deploying to AWS Lambda, and integrating with Epsilon for tracing and troubleshooting. Epsilon provides a comprehensive solution for monitoring and troubleshooting, including visualizing trace data, indexing requests, and creating alerts. The workshop also included a treasure hunt contest to find a hidden password within the APIs. Overall, the workshop emphasized the importance of observability and provided practical tools and techniques for implementing it in real-world applications.

The benefits of Node.js to develop real-time applications at scale are very well known. As Node.js architectures get more and more complex, visualization of your microservices-based architecture is crucial. However, the visualization of microservices is incredibly complex given the scale and the transactions across them. In this workshop, you will learn how to leverage service maps to instantly understand your architecture and troubleshoot any API error. We will write a simple Express application and explore best practices when using Express. Then, we’ll deploy the application on AWS, integrate the environment with Epsagon, and deep-dive into various features of the platform to enable immediate detection and fast troubleshooting of application errors. Goals: Visualizing your architecture, monitoring your applications, reducing your mean time to detection and recovery (MTTD and MTTR). Who should attend? DevOps, Engineers, Cloud Architects, IT, Software Developers, Solution Architects and Engineers, SREs, and anyone who is running microservice-based applications (Kubernetes, containers, serverless functions, and more) in the cloud. Prerequisites<ul><li>We prefer to use VSCode for a better experience (other IDEs are fine)</li><li>Preinstall npm and node</li><li>        Pre-existing AWS Account - You can create a free tier <a href="https://aws.amazon.com/ru/free/?all-free-tier.sort-=item.additionalFields.SortRank&amp;all-free-tier.sort-order=asc">here</a></li><li>        Attendees are free to create an Epsagon account in advance <a href="https://app.epsagon.com/login">here</a>, not mandatory</li></ul> <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

How to Troubleshoot API Errors and Reduce MTTD/R 

Gal Bashan

GraphQL Galaxy 2020

The Talk discusses the evolution of code and data coupling, the challenges of managing code and API complexity, and the rise of GraphQL as a solution. It explores the power of directives in GraphQL and their ability to preprocess and post-process requests and responses. The at lambda directive is highlighted as a way to implement fields in JavaScript. The Talk also touches on the benefits of working from home and the flexibility of placing directives in various parts of a GraphQL schema.

<div><div><div><div><div>Apps are hard enough to build without having to worry about layers and layers that sit between your users and the database. In this talk we examine trends in serverless computing, and their impact on modern databases and API layers.</div></div></div></div></div><div><div><div></div></div></div> <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

The Diminishing API Layer

Tejas Dinkar

This Talk discusses the safe handling of dynamic data with TypeScript using JSON Schema and TypeBox. Fastify, a web framework, allows developers to validate incoming data using JSON schema, providing type safety and error handling. TypeBox is a powerful library that allows developers to define JSON schemas and derive static types in TypeScript. The combination of JSON schema, TypeBox, and Fastify provides powerful tools for type safety and validation of dynamic data.

TypeScript makes JavaScript safer adding static type definitions. Static definitions are wonderful; they prevent developers from making trivial mistakes ensuring every assignment and invocation is done correctly. A variable typed as a string cannot be assigned a number, and a function expecting three arguments cannot be called with only two. These definitions only exist at build time though; the code that is eventually executed is just JavaScript. But what about the response from an API request? In this talk Ethan Arrowood, Software Engineer 2 @ Microsoft, he will cover various solutions for safely typing dynamic data in TypeScript applications. This talk features popular technologies such as Fastify, JSON Schema, Node.js, and more! <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

#api development