July 2023 Summaries

Hasura has introduced a new feature called Input Validation Permissions, aimed at enhancing data integrity and security in application development. By allowing developers to implement custom data validation logic for GraphQL mutations, this feature acts as a pre-mutation hook, ensuring that only valid data is processed and stored in the database. Input Validations can address various use cases such as user registration and authentication, managing user-generated content, and enforcing restrictions on allowing requests. This powerful tool helps developers build more reliable and secure applications by giving them control over the entire validation process.

Incremental database migration is a complex process that involves multiple phases and processes. The challenges increase significantly when migrating data across different cloud providers or data centers. This article discusses an approach using Hasura to incrementally execute the migration, tackling uncertainties while delivering results on time. Key steps include introducing Hasura and connecting it to the old database, connecting existing API service with Hasura, replicating some table schemas to the new database vendor, making remote joins across databases, and removing old data sources from Hasura once all data has been migrated.

MuleSoft and Hasura are two powerful platforms that can be combined to create a comprehensive and efficient API ecosystem. MuleSoft is an integration platform that enables seamless connections between disparate systems, applications, and data sources, while Hasura provides instant GraphQL APIs over existing databases and endpoints. By leveraging the strengths of both platforms, organizations can streamline their API development and integration processes, ensuring efficient data flow across the enterprise. The combination of MuleSoft and Hasura is particularly beneficial in scenarios such as e-commerce integration, healthcare data integration, and financial services integration.

The text discusses the concept of client side nullability in GraphQL and how it can be used to inform client component design through comprehensive examples. Client side nullability allows for better control over data fetching requirements, enabling developers to specify how errors or null values affect returned fields based on bubble-up logic. This feature is currently in the RFC stage and not yet supported by Hasura. However, it can be useful in federated setups with multiple data sources across a network, allowing clients to account for partial failures when resolving data. The GraphQL spec continues to evolve to solve real problems that developers encounter.

Breaking up a monolithic application into microservices can be achieved with Hasura's GraphQL engine. The process involves identifying microservice boundaries, creating GraphQL APIs, extracting microservices from the monolith, refactoring and redesigning components, deploying and scaling microservices, and monitoring and maintaining them. Hasura provides powerful data modeling capabilities and integrates well with containerization technologies like Docker and orchestration platforms like Kubernetes.

API security breaches are becoming more common, with Gartner predicting that by 2025, insecure APIs will account for over 50% of data theft incidents. As businesses continue to adopt an API-driven approach to software development, securing their APIs is crucial. GraphQL APIs require a more complex authorization layer than REST APIs due to factors such as data modeling, roles and attributes, nested rules, and performance considerations. Building an authorization layer involves various methods, including API-wide, resolver-based, and schema/model-based approaches. In GraphQL, the context object is used for passing authentication and authorization details to every resolver. However, writing custom authorization logic can be challenging and may lead to a lot of boilerplate code that becomes difficult to maintain. Hasura offers a powerful authorization engine that allows developers to declaratively define fine-grained permissions and policies to restrict access to specific data elements based on session information in an API call. This approach simplifies the effort needed to build authorization logic into APIs, making it easier for developers and security teams to create, maintain, evolve, and audit their code.