What are some pain points in the development process which Hasura solves?
- Automatically exposes full-featured GraphQL query, mutation, subscription CRUD types for each table in your database.
- Compiles client GraphQL into optimized SQL queries, providing unmatched speed and efficiency.
- Massively reduces time writing boilerplate database CRUD API's.
- Replaces long, complex, unintuitive SQL queries with the declarative simplicity and benefits of GraphQL.
- Allows you to manually extend your GraphQL API with extra endpoints to deal with any business logic you may need.
- Supports adding the authentication solution of your choice.
- Secures your data with user roles and fine-grained row level permissions.
- Replaces multiple data sources with a single unified endpoint for your entire application.
- Provides tools to define relationships between disparate data.
- Tracks changes over time allowing changes to be added to version control and synchronization with your codebase.
- Provides an optimized and massively scalable Cloud and Enterprise solution with which to host projects with extra features.
What databases does Hasura support?
Hasura supports the following databases natively:
- PostgreSQL (and the Postgres family of compatible databases)
- Microsoft SQL Server
- Google Cloud BigQuery
Check out the list of compatible databases.
How does Hasura work?
Although Hasura presents itself as a web-service API, Hasura is essentially a JIT compiler. Hasura takes incoming GraphQL API calls over HTTP and then tries to achieve theoretically optimal performance while delegating the data fetches to downstream data sources. You can read more about how Hasura works here and our design philosophy in this blog post.
How much time & effort does Hasura save?
Hasura cuts development time by roughly at least 50-80%. You can find out more from our case studies here.
How do I use Hasura if I already have an existing application or API?
Hasura is designed for incremental adoption without having to rip-and-replace or entirely rebuild your stack. You can incrementally migrate your application to Hasura. Use Hasura to first build any new features for your application using your existing data as well as a high-performance read layer for any read-heavy use-cases as this takes no time to set up. You can also use any business logic in your existing applications by delegating to them via Hasura Actions. This gives you the time to migrate over any legacy code or rewrite existing microservices with Hasura.
How can I get Hasura up-and-running quickly?
What does my first-time demo experience look like?
Using the Hasura Console, click on the Data tab and connect up a new Postgres database from our partner company Neon. Then create tables, insert some demo data and test out some queries and mutations using the GraphiQL interface in the API tab. Alternatively, from your connected database in the Data tab, try one of our demo templates from the Template Gallery which can demonstrate key Hasura features for you quickly. If you already have an existing database with tables and data you can also just have Hasura connect to it, track tables and relationships, and you can immediately start exploring your new GraphQL API.
What's so great about GraphQL?
GraphQL's declarative and efficient fetching paradigm allows your API consumers to easily specify exactly which data they want and get only what they need returned to them, saving multiple request round trips. GraphQL is also strongly typed which allows users to know exactly what is available and what the data will look like.
How do I manage my database once it's connected to Hasura?
Your database is still manageable in exactly the same way as it was before. In addition, you can perform many database management functions from the Hasura Console or run SQL directly on your DB from the Console.
How do I model out my data in a relational way in Hasura?
Hasura allows you to specify relationships between your data including one-to-one, one-to-many and relationships to Remote Schemas between remote databases.
Can I connect my existing API endpoints, databases / data sources, or GraphQL servers?
Yes, you can use Hasura as a data federation solution to connect multiple disparate data source types and define relationships between them. Read more here.
Are the common models accounted for? Querying? Filtering? Pagination? Inserting records? Live Queries?
Yes. Hasura automatically generates
subscription abilities on your databases
on_conflict arguments where applicable.
How do I track changes to my Hasura instance and keep them in sync with my codebase?
When using the Hasura CLI to manage Hasura, all actions regarding the underlying databases and Hasura config (Metadata) are recorded and can be committed to version control to enable easy versioned backups and re-deployment of your setup.
How do I declaratively deploy Hasura?
With GitHub deployment on Hasura Cloud you can link a GitHub repository to your Hasura Project to automatically deploy Metadata and Migrations from within a given directory to the linked project. Alternatively, you can use GitHub Actions or a similar CI/CD service to build a custom deployment pipeline for your Hasura instances.
How can I preview changes to my Hasura instance?
With Preview Apps on Hasura Cloud you can automatically create an app on Hasura Cloud for every pull request you make to your GitHub repo enabling quick and easy testing of changes as you work.
How would I work collaboratively with my team using Hasura?
Using Projects in Hasura Cloud you are able to add collaborators and assign each different access permissions on your instance. Since the Hasura Metadata and Migrations can be committed to version control, you can also use the user permissions systems of a version control host (eg: GitHub) in order to control how your team collaborates on your Hasura Project.
How do I connect business logic or extend the GraphQL schema?
Hasura provides ways to connect existing or new business logic and for extending the generated GraphQL schema with extra CRUD functionality, eg:
REST APIs via Hasura Actions:
If you have new or existing REST APIs that serve domain data or logic, you can easily connect Hasura to them and extend the GraphQL schema that Hasura exposes. This is useful not just when you have legacy APIs that contain a lot of transactional or application logic, but also when you want to build and serve custom logic with cloud-native code deployed as containers or serverless functions.
- Read more about Hasura Actions.
Hasura Event Triggers:
Whenever there’s a change in the upstream database, Hasura can capture that change as an event and deliver that to a HTTP webhook that can process that data change event and react to it asynchronously. Apart from attaching specific pieces of logic to events, this is especially useful if you’re thinking about building end-to-end real-time and reactive applications.
- Read more about this architecture at https://3factor.app.
- Read more about Event Triggers in the Hasura docs.
- Go through a quick tutorial on how to set Event Triggers up at https://learn.hasura.io.
GraphQL APIs via Hasura Remote Schemas:
If you have a new or existing GraphQL service that extends the schema, say with custom mutations that incorporate your custom logic, or if you’d like to extend your overall GraphQL API with a “sub graph” that comes from a service that you may not directly own, you can use “Remote Schemas” in Hasura to bring in GraphQL services as data & logic providers to your GraphQL API.
- Read more about Remote Schemas.
Stored procedures / functions in the database:
Stored procedures and functions are a common way to write and store high-performance business logic, or transactional logic, that's close to the data. As a part of the GraphQL API that Hasura exposes over databases, Hasura allows you to expose stored procedures or functions as fields in the GraphQL schema. This is a great way to bring in existing business logic that maybe in your database, or to write custom, high-performance logic if you’re familiar with databases!
- Read more about custom functions.
Choose one or more of the methods above depending on where your existing business logic is; and where you want it to be in the future!
Can I use REST instead of GraphQL APIs?
Yes. Hasura 2.0 added support for REST APIs and allows users to create idiomatic REST endpoints based on GraphQL templates. Read more here.
Can Hasura integrate with my authentication system?
Hasura believes authentication should not be restricted to a particular provider. Therefore, authentication is handled outside of Hasura and we make it easy for you to bring in your own authentication system. The most favored mechanism is via JWT. Hasura can accept JWT tokens from any standard JWT provider. For extremely customized authentication systems, Hasura also supports auth webhook that allows you to read through cookies or tokens that might have a custom format. We have guides for some of the popular authentication providers. Read more here.
Does Hasura also automatically cache queries or data to improve performance?
Query response caching (available on Hasura Cloud & Hasura EE) can be enabled by specifying which query to cache using the @cached directive. Read more about caching here.
How do I limit what data my users can see?
Hasura's authorization system allows the creation of user roles which can then be assigned fine-grained permission
policies for each of the
Hasura implements role-based access control (RBAC) by automatically publishing a different GraphQL schema that represents the right queries, fields, and mutations that are available to that role.
For attribute-based access control (ABAC), session variables can be used as attributes, and permission rules can be created that can use any dynamic variable that is a property of the request.
Does Hasura have other security features, specifically for GraphQL in production?
Hasura has multiple security features to best utilize the power of our GraphQL Engine. Features like service-level security, authentication & authorization, allow lists, rate, and response limiting are present. Learn more about Hasura security here.
How does the compiler approach provide superior performance?
Typically, when you think of GraphQL servers processing a query, you think of the number of resolvers involved in fetching the data for the query. This approach can lead to multiple hits to the database with obvious constraints associated with it. Batching with data loader can improve the situation by reducing the number of calls.
Internally, Hasura parses a GraphQL query gets an internal representation of the GraphQL Abstract Syntax Tree (AST). The GraphQL AST is then converted to a SQL AST. With necessary transformations and variables the final SQL is formed.
GraphQL Parser -> GraphQL AST -> SQL AST -> SQL
This compiler-based approach allows Hasura to form a single SQL query for a GraphQL query of any depth.
How does Hasura scale vertically and horizontally?
Hasura Cloud lets you scale your applications automatically without having to think about the number of instances, cores, memory, thresholds etc. You can keep increasing your number of concurrent users and the number of API calls and Hasura Cloud will figure out the optimizations auto-magically. Hasura Cloud can load balance queries and subscriptions across read replicas while sending all mutations and Metadata API calls to the master. Learn more about Horizontal scaling with Hasura, here. Additionally, Hasura Community Edition can be scaled horizontally by adding more Hasura instances to your deployment.
Hasura allows analyzing queries to identify the slow running calls and use Indexes to improve the performance. Learn more here.