DEV Community: Vaibhav Solanki

GraphQL: The Future of APIs and the Exciting Road Ahead

Vaibhav Solanki — Wed, 24 Apr 2024 16:31:06 +0000

The world of web development is constantly evolving, and at the forefront of this innovation is GraphQL. This powerful query language has transformed the way developers interact with APIs, offering a level of flexibility and efficiency that traditional REST APIs struggle to match. As we delve into the latest advancements and trending topics in GraphQL, it's clear that this technology is not just maintaining its momentum but accelerating it.

GraphQL Federation: A Symphony of Microservices

One of the most significant advancements in GraphQL is the concept of federation[1]. This approach allows multiple GraphQL schemas to be combined into a single, cohesive schema. It's like an orchestra where each instrument plays its part, resulting in a harmonious symphony of microservices. Federation streamlines the development process, making it easier for teams to manage large-scale APIs and improve system maintainability.

Real-Time Data and GraphQL Subscriptions

The demand for real-time data is higher than ever, and GraphQL subscriptions are stepping up to the plate[1]. They enable client applications to listen for specific changes in data, ensuring users have access to the latest information as it happens. This is a game-changer for applications that rely on instant data updates, such as messaging apps or live sports scores.

Advanced Tooling and Ecosystem Growth

As GraphQL's popularity grows, so does the ecosystem around it. Tools like Postman's GraphQL client, Relay, and Urql are simplifying client-side integration, while code generation tools and compilers are optimizing development workflows[1]. This rich ecosystem not only supports developers but also fosters innovation, pushing the boundaries of what's possible with GraphQL.

Schema-First Development: Planning for Success

Another trend gaining traction is schema-first development[1]. This methodology emphasizes the importance of designing a robust and well-documented schema before diving into API implementation. It ensures consistency across the API and facilitates collaboration between front-end and back-end teams, leading to a smoother development process and a more reliable end product.

Security Enhancements: Safeguarding Your Data

With great power comes great responsibility, and the rise of GraphQL has brought new security considerations to light[1]. Techniques like query cost analysis and query depth limiting are emerging to protect APIs from malicious queries and potential breaches. These advancements are crucial for maintaining the integrity and security of data as GraphQL continues to be adopted at scale.

Partial Query Results: Resilience in the Face of Errors

GraphQL's ability to return partial query results is another advancement that enhances API resiliency[1]. When certain fields or operations fail, GraphQL APIs can still return the successful parts of the query. This means that client applications can handle partial data gracefully, providing a better user experience even when errors occur.

Trending Topics: GraphQL at Scale and Beyond

Looking at the trending topics, GraphQL at scale is a hot subject. Enterprises are rapidly adopting GraphQL, with predictions suggesting that over 50% will use it in production by 2025[3]. This reflects the technology's scalability and its ability to meet the demands of large organizations.

API management for GraphQL is also a key trend. Effective API management is essential for optimizing performance and security, especially when GraphQL acts as a gateway to various data sources[3].

Lastly, the intersection of GraphQL and artificial intelligence (AI) is an exciting area to watch. As AI continues to advance, its integration with GraphQL could lead to even more intelligent and adaptive APIs[3].

Conclusion

The advancements and trends in GraphQL are a testament to its growing significance in the API landscape. From federation to real-time data, advanced tooling to security enhancements, GraphQL is shaping the future of data exchange. As developers and organizations embrace these trends, we can expect to see more innovative, efficient, and user-friendly applications. The journey of GraphQL is just beginning, and the road ahead is filled with possibilities. Stay tuned for what's next in this exciting chapter of web development!

References:
1. Postman Blog
2. apollographql Blog
3. IBM Blog
4. devops

GCP PubSub - Batching with orderingKey

Vaibhav Solanki — Wed, 24 Apr 2024 13:07:31 +0000

Introduction
Google Cloud Pub/Sub (GCP Pub/Sub) is a cornerstone of modern application architecture, offering a fully-managed real-time messaging service that seamlessly connects independent applications. In the dynamic landscape of cloud services, scalability is a critical factor. GCP Pub/Sub provides two primary scaling strategies: vertical scaling through batching with ordering keys, and horizontal scaling with multiple consumers on the same subscription. This blog post delves into the intricacies of both approaches, their implementation, testing methodologies, and the results they yield.

Sample Code used to push messages with two diffrent orderingKey



// Importing the PubSub module from the Google Cloud Pub/Sub library
import { PubSub } from '@google-cloud/pubsub';

// Defining the topic name
export const TOPIC = '<TOPIC_NAME>';

// Creating a Pub/Sub client with the specified projectId
export const client = new PubSub({
    projectId: '<projectId>'
});

// Function to check if a number is even
function isEven(number) {
    return number % 2 === 0;
}

// Looping through numbers from 0 to 9
for (let i = 0; i < 10; i++) {
    // Publishing a message to the specified topic
    const res = await client.topic(TOPIC, { enableMessageOrdering: true })
        .publishMessage({ data: Buffer.from(i.toString(), 'utf8'), orderingKey: isEven(i) ? 'EVEN' : 'ODD' });
    // Logging the result of the publishing operation
    console.log(res);
}

Vertical Scaling: Batching with Ordering Key
Vertical scaling is synonymous with optimizing the processing capabilities of individual messages. By implementing batching with an ordering key, subscribers can collectively process messages in a batch. This method significantly reduces overhead and enhances processing efficiency. However, the subtleties of message delivery with ordering keys demand a comprehensive understanding.

Test Scenario and Results
A test scenario was established to examine vertical scaling further, where 100 messages were published with alternating ordering keys. Despite the activation of ordering, GCP Pub/Sub did not sustain the anticipated sequence during batch processing. This discrepancy underscored a notable limitation of vertical scaling in managing voluminous message flows.



// Importing the PubSub module from the Google Cloud Pub/Sub library
import { PubSub } from '@google-cloud/pubsub';

// Defining the subscription name
export const SUB = '<TEST-SUB>';

// Creating a Pub/Sub client with the specified projectId
export const client = new PubSub({
    projectId: '<projectId>'
});

// ANSI color codes for console output
const RED = "\u001b[31m"; // Red color
const BLUE = "\u001b[34m"; // Blue color

// Creating a subscription with increased message flow to process multiple messages concurrently
const subscription = client.subscription(SUB, {
    flowControl: {
        maxMessages: 100 // Increased message flow to process multiple messages concurrently
    }
});

// Function to check if a number is even
function isEven(number) {
    return number % 2 === 0;
}

// Function to deserialize message data
function deserializeMessage(message) {
    return message.data.toString('utf8');
}

// Function to introduce random delay
function randomSleep() {
    const randomMilliseconds = Math.floor(Math.random() * (3000 + 1));
    return new Promise(resolve => setTimeout(resolve, randomMilliseconds));
}

// Asynchronous message handler function
async function handler(message) {
    // Introducing random delay to simulate processing time
    await randomSleep();
    // Logging received message with appropriate color based on its ordering
    console.log(isEven(message) ? BLUE : RED, 'received msg', 'ack msg', message);
}

// Function to process messages
function messageProcessor(message) {
    return Promise.resolve(message)
        .then(deserializeMessage)
        .then(handler)
        .then(() => message.ack())
        .catch(e => {
            // Handling errors encountered while processing messages
            console.debug('Error encountered while handling message.', {
                errorMessage: e.message,
                errorName: e.name,
                messageId: message.id,
                orderingKey: message.orderingKey
            });
            message.nack(); // Nacknowledging the message
        });
}

// Event listener for incoming messages
subscription.on('message', messageProcessor);

// Event listener for subscription errors
subscription.on('error', e => {
    console.error('Error encountered on subscription. Closing connection');
    console.error(e);
    // Closing subscription connection on error
    subscription.close((err) => {
        if (err) {
            console.error('Error on closing subscription');
            console.error(err);
            process.exit(1);
        }
    });
});

Result: we lost the order of message

Horizontal Scaling: Ordering Keys & Multiple Consumers
Horizontal scaling, in contrast, entails the distribution of workload across an array of subscribers. GCP Pub/Sub ensures that messages tagged with an ordering key are consistently delivered to the same subscription that previously received messages with the identical ordering key. This mechanism is pivotal for maintaining the sequence of messages across various consumers.

Test Scenario and Results
For the horizontal scaling test, two distinct subscribers (emulating separate pods) were configured for the same subscription. Each subscriber was tasked with handling messages bearing alternating ordering keys. The outcome aligned with expectations; every message sharing an ordering key was routed to the same subscriber, thereby preserving the order.

Code



import { PubSub } from '@google-cloud/pubsub'

export const SUB ='<TEST-SUB>'

export const client = new PubSub({
    projectId: '<projectId>'
})

const RED = "\u001b[31m";
const BLUE = "\u001b[34m";

const subscription = client.subscription(SUB, {
    flowControl: {
        maxMessages: 1 
    }
})

function isEven(number) {
    return number % 2 === 0;
}


function deserializeMessage (message) {
    return message.data.toString('utf8')
}

function randomSleep() {
    const randomMilliseconds = Math.floor(Math.random() * (3000 + 1));
    return new Promise(resolve => setTimeout(resolve, randomMilliseconds));
}

async function handler(message){
    await randomSleep()
    console.log(isEven(message)?BLUE:RED,'received msg','ack msg',message)
}


function messageProcessor (message) {
    return Promise.resolve(message)
        .then(deserializeMessage)
        .then(handler)
        .then(() => message.ack())
        .catch(e => {
            console.debug('Error encountered while handling message.',
                { errorMessage: e.message, errorName: e.name, messageId: message.id, orderingKey: message.orderingKey })
            message.nack()
        })
}

subscription.on('message', messageProcessor)

subscription.on('error', e => {
    console.error('Error encountered on subscription. Closing connection')
    console.error(e)
    subscription.close((err) => {
        if (err) {
            console.error('Error on closing subscription')
            console.error(err)
            process.exit(1)
        }
    })
})

Result: on delivery Order Was preserved

Conclusion
The decision between vertical and horizontal scaling in GCP Pub/Sub hinges on the specific requirements of the message flow and the system architecture. Vertical scaling is advantageous for its efficiency in processing smaller batches of messages, while horizontal scaling excels in maintaining order across high-volume message streams. Both methods have their merits and limitations, and the choice ultimately depends on the balance between order preservation and processing efficiency.

By understanding the strengths and weaknesses of each scaling approach, developers can make informed decisions that align with their application's needs, ensuring robust and scalable message handling in their cloud infrastructure. The exploration of these scaling strategies underscores the importance of thorough testing and evaluation in optimizing cloud-based messaging services.

refferance:
Batch messaging By GCP Doc
Google Cloud Pub/Sub Ordered Delivery by Kamal Aboul-Hosn

Elevate Your GraphQL API: Mastering File Uploads with Yoga GraphQL

Vaibhav Solanki — Tue, 23 Apr 2024 06:27:58 +0000

Introduction:
GraphQL Yoga is a robust framework that seamlessly integrates file uploads into your GraphQL API workflow, thanks to its support for the GraphQL Multipart Request Specification. By leveraging this feature, you can efficiently handle file uploads and process binary data within GraphQL resolvers via HTTP. In this guide, we'll explore how to harness the capabilities of GraphQL Yoga to elevate your API with file upload functionality.

Key Features:

Seamlessly Consume Uploaded Files:
With GraphQL Yoga, you can effortlessly consume uploaded files or blobs as WHATWG standard File or Blob objects, similar to those found in the browser's API. This standardized approach simplifies the handling of file uploads, ensuring compatibility across various client applications.
Quick Integration with Client Solutions:
GraphQL Yoga is compatible with any client that supports the GraphQL Upload specification. Whether you're using Apollo Client, Relay, or another GraphQL client solution, you can seamlessly integrate file uploads into your application workflow.

Implementation Guide:

Getting Started:
To begin processing file uploads in GraphQL Yoga, start by adding a File scalar to your schema. This simple step sets the stage for seamlessly handling file uploads within your GraphQL API.
Example Code:
Here's a sample implementation demonstrating how to process file uploads in GraphQL Yoga:

import { createYoga } from 'graphql-yoga'
import { createServer } from 'http'

// Provide your schema
const yoga = createYoga({
  schema: createSchema({
    typeDefs: /* GraphQL */ `
      scalar File

      type Query {
        greetings: String!
      }

      type Mutation {
        saveFile(file: File!): Boolean!
      }
    `,
    resolvers: {
      Query: {
        greetings: () => 'Hello World!'
      },
      Mutation: {
        saveFile: async (_, { file }: { file: File }) => {
          try {
            const fileArrayBuffer = await file.arrayBuffer()
            await fs.promises.writeFile(
              path.join(__dirname, file.name),
              Buffer.from(fileArrayBuffer),
            )
          } catch (e) {
            return false
          }
          return true
        },
      }
    }
  })
})

// Start the server and explore http://localhost:4000/graphql
const server = createServer(yoga)
server.listen(4000, () => {
  console.info('Server is running on http://localhost:4000/graphql')
})

Testing with Curl: After starting the server, you can use Curl to test your endpoint. Here's a sample Curl command for testing file uploads:

curl --location 'http://127.0.0.1:4000/graphql' \
--form 'operations="{ \"query\": \"mutation ($file: File!) { saveFile(file: $file) }\", \"variables\": { \"file\": null } }"' \
--form 'map="{ \"0\": [\"variables.file\"] }"' \
--form '0=@"mytext.txt"'

Conclusion:
By following this guide, you'll unlock the full potential of file uploads in your GraphQL API using Yoga GraphQL. With its seamless integration and robust capabilities, GraphQL Yoga empowers you to enhance your API with efficient file upload functionality, delivering an exceptional user experience for your application.