Large language models (LLMs) provider GigaML has raised $3.6 million in seed led by Nexus Venture Partners, with participation from Y Combinator and Liquid 2 Venture, 8vdx and angels such as Garry Tan. Founded three months ago by Varun Vummadi and Esha ...

GigaML raises $3.6 Mn in seed round led by Nexus

San Francisco and Bengaluru-based Giga ML has raised $3.6 Mn in a seed funding round led by Nexus Venture Partners. Y Combinator, Liquid 2 Venture, 8vdx and prominent angels like Garry Tan (Y Combinator president and CEO), also participated in this round of funding.

Giga ML Raises $3.6 Mn To Help Enterprises Train And Deploy On-Premise LLMs

Bengaluru: Device intelligence platform Fingerprint on Wednesday said that it has secured $33 million ( ₹ 274.7 crore) in a Series C funding round, led by existing investor Nexus Venture Partners. The round also saw participation from California-based early-stage investor Uncorrelated Ventures.

Fingerprint Raises $33 mn in Series C Funding from Nexus, Uncorrelated Ventures

Venture capital firm Nexus Venture Partners, which bets on startups both in India and the US, has led a Series C funding round for Chicago-based device

Nexus leads $33 mn funding in US device intelligence platform Fingerprint

This article introduces a technique for using Hasura permissions metadata as a single source of truth to both manage access to database resources and control the front-end user experience.

Using Hasura GraphQL Permissions Metadata as a Single Source of Truth for Role Based Access Control

There are many web frameworks that support GraphQL API development, such as Apollo, Prisma, and Hasura. Apollo is a comprehensive and open-source platform with components like Apollo Server and ...

What are the best web frameworks for creating RESTful or GraphQL APIs?

Hasura Akther Rukmy has already held two solo exhibitions in popular art destinations abroad. She spoke to The Business Standard about her art and philosophy

Meet Rumky, the Bangladeshi artist making a mark on the int’l stage

Press Release Mayfield today announced that Sri Pangulur, a proven enterprise investor and operating leader, will join the team as the first dedicated partner to focus on investing out of the firm's Select/Spring funds which invest in new companies (primarily at

Mayfield Adds New Investor Sri Pangulur As First Dedicated Select/Spring Fund Partner

MENLO PARK, Calif.--(BUSINESS WIRE)--Mayfield today announced that Sri Pangulur, a proven enterprise investor and operating leader, will join the team as the first dedicated partner to focus on ...

Prior to Mayfield, Sri led the enterprise software investing practice at Tribe Capital and was an active angel investor before that. Some entrepreneurs he has partnered with include the teams from Apollo.io, LinearB, Docker, JupiterOne, Orum, Instabase, MindsDB, Abnormal Security, Hasura, HYCU, Nylas, Airbyte, Hightouch, and Oort.

Hasura

hasura

Adding Auth Flow Using SuperTokens into a React and Hasura GraphQL App

What is ETL 💭? is short for , three database functions that are combined into one tool to pull data out of one database and place it into another database. ETL e xtract, t ransform, l oad is the process of from a database. In this stage, the data is collected, often from multiple and different types of sources. Extract reading data is the process of from its previous form into the form it needs to be in so that it can be placed into another database. Transformation occurs by using rules or lookup tables or by combining the data with other data. Transform converting the extracted data is the process of into the target database Load writing the data In the sample apps given by hasura, serverless-etl app is one among them. I will be showing how to implement it using Next.js . This is the to the example given by hasura. link The main features of this app will be :- Add Book to the database From the database data is saved in an algolia index Search for the book in the algolia index How will we implement it ? We will be using graphql mutations to insert book details into the database and when something is inserted into the database an event is triggered which will update the algolia index with the inserted data from the database and this data can be retrieved from the algolia index when searched. That’s it! it is that simple. Pre-requisites: Algolia account Hasura GraphQL Engine (HGE) installation Now that you are ready, Lets begin! Setting up basic Next.js project and Graphql Engine First step is to create a next.js project using . This command will create a basic boilerplate for a next.js project on which we will be working on. yarn create next-app etl-example Add the packages and scripts which are not present in your package.json file from the gist below and install it using . yarn install Next setup a Hasura GraphQL engine using the the deploy option and note down the deployed url and create a file in the root folder with the following code one-click config.js replace the with the url of the deployed hasura engine. Add authentication headers in the config object if you have any. herokuapp-url Creating Book Table We will be having a single table name which will have the details of the book like title and author. For that we have to go to the Hasura GraphQL engine console and create the following table book book table Setting up Algolia Index Next step is to setup an Algolia Index, For that follow the instructions given below. Sign-up for Algolia account Go to the Dashboard, Click on tab on the left sidebar Indices Click on button New Index Name it as demo_serverless_etl_app Goto tab on the sidebar API Keys Copy the (we'll call this ) Application ID **ALGOLIA_APP_ID** Click on tab and then click button All API Keys New API Key Give description as server key Choose the index demo_serverless_etl_app Select under the ACL section Add records Click and copy this API key from the list (we'll call it ) Generate **ALGOLIA_ADMIN_API_KEY** Setting up webhooks For adding the data into the algolia index when some data is inserted into the database, we will be needing a webhook which will be triggered on data insertion and this webhook will add the inserted data into the algolia index. For having a single api endpoint there is no point of having a seperate server. What we can do is setup a node server and add the api endpoint for the webhook and route all other url’s to the next.js handler. For the node server we have to create a file named in the root directory and copy the content from below. The route will be used to trigger an event when data is inserted into the table to add it into the algolia index. Add your algolia APP_ID and the ADMIN_API_KEY in the empty space present in the code. server.js /webhook Building the front-end Next we will setup our page where we will take in the author name and book title which will be added to the database and also a search bar where you can search for any book. Create a file named inside folder and add the following code and also replace the algolia api variables with your values. index.js post Search Component The component provided by package will do the search magic automatically. You do not have to worry about coding all those searching stuff 😉. The component will render the searchbox and component will render the results of your search InstantSearch react-instantsearch-dom SearchBox Hits Deploy Now that wehave the server ready, deploy it anywhere for example and you will get a url for the deployed server note that down, let it be <SERVER_URL>. glitch Creating an Event Trigger Our next step is to create an event trigger on adding a new book to the database, for this go to tab in Hasura Graphql Engine Console and add a new trigger. Replace with Events <TRIGGER_URL> <SERVER_URL>/webhook. Trigger Now you can open <SERVER_URL> in your browser and see the magic! 😉 And that’s it, we have the ETL-demo ready🙌 . I haven’t added any stylings in the code. If you want to make it look more awesome, just add the required css and make it better 😎. Link to the gists :- , , index.js server.js package.json About Me My name is . I am an undergraduate student at the Indian , pursuing my B.Tech degree in Information Technology. Aswin VB Institute of Information Technology, Allahabad I love creating and learning new things which i always do when i have free time. I love to code in J . avaScript and Python You can follow me on and . Twitter GitHub

How to implement ETL Application using Hasura GraphQL Engine And Next.js

Before you start this project, i assume that you have basic idea about Next.js and Hasura. In this blog i will be showing how to integrate Next.js and Hasura. What is Next.Js ? is a JavaScript framework created by . It lets you build server-side rendering and static web applications using React. It’s a great tool to build your next website. It has many great features and advantages, which can make Nextjs your first option for building your next web application. Next.js Zeit You don’t need any configuration of webpack or similar to start using Next.js. It comes with its configuration. All you need is to run and start building your application 😃. yarn run dev Now that you are ready let’s get started! How to setup a Next.Js app ? I hope you will be aware of create-react-app, just like that we have create-next-app which will do all the work which is required to setup a Next.js Project 😉. if you are using yarn or npx, there is inbuilt package to create a next.js app which are : yarn create next-app my-app npx create-next-app my-app if you are using npm then package should be installed and using that package a new project can be setup. create-next-app npm install -g create-next-app create-next-app my-app create-next-app As you see in the image with one command all the project files are prepared and ready to go. Once the project is setup the commands which will be required to start and build the project will be shown. To build the project run yarn build To start a local server run yarn dev To start a server in production run yarn start Now that we have our basic project ready, lets setup hasura graphQL engine. We can easily setup hasura-graphQL engine using the the deploy option. Once it is deployed you can go to the deployed url and you will have something like this. one-click Note down the url at the top of the homepage. //hasuragraphql-engine.herokuapp.com/v1alpha1/graphql Click on Data in the top bar and create a new table as follows author table Add a dummy data in the table Adding a dummy author Once hasura engine is setup, we can move onto connecting Hasura and Next.js. For that we have to install , and graphql-tag next-apollo react-apollo. yarn add graphql-tag next-apollo react-apollo Once the above packages are installed, create a config.js file in the root directory and add the following code Replace the uri with the url to which your deployed engine.This will configure with an to connect to a valid GraphQL server URL. withData httpLink Next task is to wrap your page component with component from so that appropriate data can be fetched while the page is Server Side Rendered. Query react-apollo GraphQL query const query = gql`query {author {idname}}` Wrap your component with Query <Query query={ query } fetchPolicy={ 'cache-and-network' }>{({ loading, data: { author:authors }}) => {return (<div><div>{authors.map((a, i) => (<div key={i}><h2>{a.name}</h2></div>))}</div></div>);}}</Query> Once these code are combined we’ll have something like this 👇. Run and your hasura-next.js app is up and running. yarn run dev Open in your browser and you will get the author that we created in the hasura engine in the homepage. //localhost:3000 Authors page And that’s it, it’s that easy to create a Next.js app with Hasura Graphql Engine 🙌 . You can extend it to include more features and a better look and feel. Deploy your app using which will give you the static version which can be deployed easily either using Github or Netlify . yarn build About Me My name is . I am an undergraduate student at the Indian , pursuing my B.Tech degree in Information Technology. Aswin VB Institute of Information Technology, Allahabad I love creating and learning new things which i always do when i have free time. I love to code in J . avaScript and Python You can follow me on and . Twitter GitHub

How to Integrate Next.Js and Hasura ?

Hasura and React If you are reading this then it means that you’re probably on your way to know about Hasura and . Well if that’s the case then you just landed at the perfect location. You might be having all sorts of questions like, “What’s ?”, “What’s Hasura?” or more importantly, “Why are we using it?”. Well, fear not everything will be cleared by the time you complete reading this blog. So let’s get started! React graphql This tutorial assumes that you have basic knowledge of React framework. If you are total new to React, I would suggest going through the first before continuing further.The code samples given in as you follow are for main relevant part only, if you intend to copy the code then make sure to import relevant libraries and components also and export the Component created. Otherwise you can take a look at the for this blog. hello world app of React code repository What is Hasura? is a with BaaS components. stands for platform as a service. It allows developers, IT professionals, and business leaders to develop, test, and deploy the next generation of applications in the cloud in a secure, cost-effective manner that speeds time to market and increases competitive advantage. Hasura PaaS PaaS BaaS stands for Backend as a service. It is a model for providing web app and mobile app developers with a way to link their applications to backend cloud storage and APIs exposed by back end applications while also providing features such as user management, push notifications, and integration with social networking services. GraphQL, what is all the fuss about it? GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools. Hasura’s GraphQL Engine The Hasura GraphQL Engine is an extremely lightweight, high performance product that gives you instant realtime GraphQL APIs on a Postgres database. This can be used to quickly build new applications on Postgres or fast-track the move to GraphQL for existing applications on Postgres.It comes with a UI that lets you create and view tables on your database and make GraphQL queries using the embedded GraphiQL interface. What we will be building We will be creating a simple todo app which lets a user sign up or login and then manage todos by creating them, marking them as complete or deleting them if neccessary. User will also be able to see his all todos. Visit to see a demo of what we will be building. //reacthasuratodo.herokuapp.com/ Setting up developer environment Hasura GraphQL server node npm or yarn create-react-app Deploy your Hasura GraphQL engine to a server which will be used as an endpoint to make queries. Setting up a Hasura GraphQL takes atmost 1 minute. It can be easily deployed to Heroku via its one click deploy to heroku method. . Give your heroku app a name and click on deploy app.Your Hasura GraphQL UI will be live at appname.herokuapp.com Click here to deploy your Hasura GraphQL Engine to a heroku server Hasura One Click Deploy to Heroku To secure your Hasura graphql server, add an environment variable on Heroku and keep its value to something you can remember. This access key will be asked whenever you try to login on the Hasura Graphql server. HASURA_GRAPHQL_ACCESS_KEY 2. Install node and npm in your system. On a ubuntu based OS: curl-sL | sudo bash -sudo apt install nodejs //deb.nodesource.com/setup_8.x The above command installs both node and npm in your system. On Windows:Download the relevant package from and install it. here 3. Installing create-react-app (I’ll be using yarn instead of npm) create-react-app is a script developed by Facebook to setup a react app with all the neccessary directory structure and node_modules. Install create-react-app using the following command. yarn global add create-react-app This installs create-react-app globally on your system. Creating a react app Create a new react app using On successful completion of the command, you will see a similar output as in the image. Now open your code editor in the react app directory just created. create-react-app reacthasuratodo Setting up a React app Change your terminal present working directory to react app directory and run . Server will start and you should be able to see a welcome to react screen on . This means your react app is running fine. yarn start //localhost:3000 Live React app I’ll be using package for the styling so install the package using . Make sure to add the stylesheet in . Complete documentation for react-bootstrap package can be found . react-bootstrap yarn add react-bootstrap /public/index.html here Using auth0 as authentication for the todo app. auth0 is a universal authentication & authorization platform. Including auth0 in your react app includes the following steps:1. Sign up on and create a new application.2. Adding a callback url in auth0 console.3. Creating an Auth class.4. Creating history.js5. Creating a Callback component6. Creating routes7. Changing App.js to include auth urls8. Rendering routes instead of App js. //auth0.com Sign up on and create a new application for your react app. Provide a relevant name to your auth0 application and headover to settings tab to configure it with your react app.In settings tab under add as it will be the callback url on dev environment after authentication completes. //auth0.com Allowed Callback Urls //localhost:3000/callback Now install auth0 in your react app by executing .auth0 has a great written on their website to include auth0 in your react app. yarn add auth0-js react quick start documentation Create a new file in as . We’ll be creating an class which will handle the authentication. src/Auth/ Auth.js Auth Copy your auth0 from your auth0 application and paste it in . If you are following from auth0 docs then make sure to add in function and in function. This will store the user id in local storage. clientID Auth.js localStorage.setItem('sub', authResult.idTokenPayload.sub) setSession() localStorage.removeItem('sub', authResult.idTokenPayload.sub) logout() history.js Create a file and make its content as in image. Also change to include login, logout and home buttons. history.js App.js Auth.js and App.js Create a component which will be shown to user when authorisation is completed.Create a to include different routes on which different components will be shown and a route on which authorisation will take place.The content for all the files can be found on callback.js routes.js auth0 react quick start documentation. Writing queries in GraphQL There are 3 different types of queries in graphql, query, mutation and subscription. GET queries are completed by query while insert, delete and update queries are completed by mutation. Subscription listens to any change in event happening, for instance if a new entry is added to table then through subscription it can be notified. This prevents using a GET query all over again. Create a new table on Hasura API Explorer named . It will have the following fields:1. todo_id: Integer (auto increment)2. todo_text: Text3. todo_mark: Boolean4. todo_user: Text todos todo_id will be the todo number which will automatically increment on every new creation. todo_text will store the text of todo. todo_mark is a field which will be true if the todo has been completed and false in case it hasn’t been completed. todo_user will store the user id of the user logged in. Creating a table on Hasura Add table permissions so that every user can access only its data. Create a new user. role For chose Select as the field, make it to insert with custom checks todo_user _eq X-HASURA-USER-ID For chose and select all columns for access. select with same checks as ---- For chose and give access only to column. update with same checks as ---- todo_mark For chose . delete with same checks as ---- Writing a GET query Writing queries in graphql is easy, specify the table name then the fields you want to be in the response. If you want to do selective search then where and order_by can be provided after the table name specification. A sample query to get all the values in todos table is as follow: query {todos{todo_idtodo_texttodo_marktodo_user}} general format for a query is: query query_name {table_name (where, orderby or pagination expression)]{table fields in response}} Writing a mutation Mutation consists of Insert, Update and Deletions.General format for writing a mutation query is mutation mutation-name {mutation-type_table-name (expressions to identify row and changing data)affected_rows} A simple insert query for todos table will look like this: mutation {insert_todos(objects: [{todo_text: "Complete react app",todo_user: "auth0|20390123821398"}]){affected_rows}} A simple update query for todos table will look like this: mutation {update_todos(where: {todo_id: {_eq: 1}}_set: {todo_mark: true}){affected_rows}} A simple delete query for todos table will look like this: mutation {delete_todos(where: {todo_id: {_eq:1}}){affected_rows}} Now we are ready to create the frontend using react and query the db to create and utilise todos. Coding the frontend using React We’ll be using React Apollo Client to make interact with graphql server and make queries in React. Install apollo client using or . npm install apollo-boost react-apollo graphql --save yarn add apollo-boost react-apollo graphql There will be the following main components:1. One parent component wrapping all the components in apollo provider component.2. GetTodos component to display all the pending todos to the user.3. AddTodos component to add a todo.4. MarkTodo component to mark a todo as completed.5. DeleteTodo component to delete a todo.6. GetAllTodos component to fetch all the todos created till now for a user. The parent component.This component will act as a parent component for all other components, we’ll wrap the child component in an which will enable us to use apollo client to make graphql queries in the complete app. ApolloProvider requires a prop with a object. This allows us to make authorised requests. Import ApolloClient from apollo-boost and ApolloProvider from react-apollo. Create a ApolloClient object as followsTo use user authentication, pass the user access token in the headers as Authorization. This will let the Hasura know which user is sending a request to the graphql server. A separate authentication webhook needs to be deployed to allow token authentication. Deploy the webhook to heroku or any other service. It’s easy to deploy using heroku one click deploy. After that configure the environment variable in your Hasura Server to your deployed webhook url. Use for auth0 authentication. Home.js ApolloProvider client ApolloClient HASURA_GRAPHQL_AUTH_HOOK /auth0/webhook Home.js 2. will fetch all the incomplete todos from the database and display them to the user. This component requires the use of React Apollo’s Query component. We first need to write a graphql query to fetch all the incomplete todos from todos table. The method to write a query remains the same as explained above. In react, you need to enclose that query in . gql is imported from graphql-tag which let the apollo client know that the text enclosed within this text is a graphql query. To keep the code clean, we’ll create a and write all the graphql queries in it. GetTodos gql`` queries.js get incomplete todos query We’ll use this query to fetch all the incomplete todos. In GetTodos component, we’ll be using Apollo’s Query Tag. Create a Apollo Query and pass the graphql query in it as a prop. A function inside the Query component will check for the query’s current state (loading), error if present and the data on completion. The data will have all the todos in it, we’ll just iterate over the data and display the relevant content to the user. There should be an option to mark the todo as completed or delete the todo, so we’ll create those components and render along side the data recevied. Finally after all the todos are rendered we’ll give the user an option to add a new todo, we’ll create an AddTodo component for the same and render it next to the Todos shown to the user. query GetTodos component 3. AddTodo component will be used to send an insert request to the hasura graphql server to add a new todo entry in the database. This component will require the use of graphql’s mutation request and Apollo’s Mutation Component. Query to insert a new todo Here we will be using variables in the mutation query which will be received from Apollo’s Mutation component. This component will consist of a form which will take the todo_text input from the user and send that to the mutation query as a variable. Create a Mutation component and pass the name of graphql query in mutation prop. Inside a mutation is a function with 2 arguments, first one being the type of mutation and second being an optional data. Insert type of mutation requires todo_text and todo_user as a variable. Any extra data to be sent along the query is included in a dictionary. All the variables are included in a dictionary with variable name as key and its value as dictionary. This variable dictionary is assigned to a variables key in the extra data dictionary. Mutation changes the state of the database, this means if we add a new todo to the database then it should be shown to the user in the list of incomplete todos. This is achieved by refetchQueries. refetchQueries is a list of dictionaries with each dictionary containing the name of query to execute on mutation completion. We’ll refetch all the todos whenever a new todo is added to the database. AddTodos Component 4. MarkTodo component will be used to send an update request to the database for a particular todo to change its todo_mark value from to . false true Mutation Query for marking a todo as completed In the MarkTodo component, Create a Mutation component and pass the name of graphql query in mutation prop. MarkTodo component is similar to AddTodos except that AddTodo inserts a new entry while MarkTodo updates an exisiting entry in the database. Pass the id of todo as a variable to update mutation so that the todo_mark value can be changed in the database. Refetch all the todos on mutation completion. MarkTodo Component 5. In the same way as MarkTodo, we’ll create a DeleteTodo component. This will allow a user to delete the todo completely from the database. Everything will be same as in MarkTodo except that we’ll use delete_todos as type of mutation. Query to delete a todo DeleteTodo Component 6. Finally we’ll create a GetAllTodos component to show users all the todos he has created till now. It will consist of both completed and non completed todos. This component will use a GET query on the todos table and we’ll order the todos by most recently created non completed todos first. Using conditional rendering in react we can style the incomplete todos and completed todos differently. GetAllTodos Component and Query Run the server using . Head over to to test your app. yarn start //localhost:3000 And that’s it, it’s that easy to create a React Todo App with Hasura Graphql Engine. You can extend it to include more features and a better look and feel. Deploy your react app to Heroku or any other hosting service so that everyone over the internet can use it. You can find the source code for this blog here. _A react todo app using Hasura Graphql engine. Contribute to Anupam-dagar/react-Hasura-todo development by creating an…_github.com Anupam-dagar/react-Hasura-todo Keep Coding!!! Useful Resources used while creating the todo app:1. 2. 3. 4. Hasura GraphQL Engine Documentation React Apollo GraphQL Documentation Auth0 React Quickstart Official GraphQL Documentation About Me My name is . I am an undergraduate student at the Indian (A Centre of Excellence in Information Technology established by Ministry of HRD, Govt. of India), pursuing my B.Tech degree in Information Technology. Anupam Dagar Institute of Information Technology, Allahabad I love creating and learning new things when I don’t have an overhead of college assignments. I love to code in and . I am an and currently a in . Python JavaScript opensource contributor GitHub Campus Expert India You can follow me on , and . LinkedIn Twitter GitHub

Building a React Todo App with Hasura GraphQL Engine

I have been working on , and it’s been a great learning experience. One of the trickiest things I have had to deal with in GraphQL is handling complex user permissions. It used to be a hassle until a friend pulled my attention to Hasura. a GraphQL workshop is an engine that connects to your databases & microservices and instantly gives you a production-ready GraphQL API. Hasura open source Permission in Its Simplest Form Assuming you have the following model… And you are asked to ensure a few things: Only a logged-in user can create a post Only admin users can delete post(s) These are doable — you will need to ensure that your GraphQL resolvers handle the logic. Here is what this function that can be called from your resolver could look like: { isAuthenticated = isAuthenticated() (!isAuthenticated) { } Post.create(post)
} ( ) function createPost post const await if // return 401 return await To ensure only admin users can delete posts, you would have to check if the role or grants or permissions of the user has an admin value: { isAuthenticated = isAuthenticated() isAdmin = isAdmin(loggedInUserId) (!isAuthenticated && !isAdmin) { } Post.delete(postId)
} { userRoles = getUserRoles(userId); userRoles.includes( )
} ( ) function deletePost postId, loggedInUserId const await const await if // return 401 return await ( ) function isAdmin userId const await return 'admin' Let’s say you shipped this example to production, and your forum or blog or even hacker news clone is live — congratulations. You come back tomorrow to realize that users are updating other users' posts — bummer. This one is not so difficult to achieve too. You will need to check the id of the logged-in user and compare it with the foreign key user_id on the post that needs to be. If they match, the user can edit, if it don’t then a 401 should be returned: { (post.user_id !== loggedInUserId) { } Post.update(post)
} ( ) function updatePost post, loggedInUserId if // return 401 return We just saw an everyday CRUD permission strategy -- these kind of authorizations are not very difficult to achieve. Where things get tricky, though, is when you start introducing unique business logic. When Permissions Gets Tricky A few weeks later, you want to encourage engagement in whatever social/collaboration project you are working on. A great way to do this is to add a like, vote, or clap feature. Adding a voting feature is not just adding one more table with the correct relationships. There are standard rules for voting that you want to account for: Only logged in users can vote Post creators CANNOT vote on the posts they created A voter can only vote once on a given post Here is what this logic might look like: { isAuthenticated = isAuthenticated() (!isAuthenticated) { } (post.user_id === loggedInUserId) { } votes = Vote.all({ : { : post.id, : loggedInUserId
    }
  }) (votes.length > ) { } Vote.create({ : post.id, : loggedInUserId
  })
} ( ) function vote post, loggedInUserId // 1. Must be logged in const await if // return 401 // 2. Disallow votes for post creators if // return 401 // 3. Disallow multiple votes per voter const await where post_id user_id if 0 // return 401 // Finally, vote return await post_id user_id See how this is getting longer as our user requirements keep compounding. There are more opportunities for bugs to slide in. To make things worse, if we keep getting requirements like this, it becomes one hell of a pain to maintain. Imagine we decide to do what Medium does and add a clapping feature. Note that clapping is different from voting because users are allowed to clap more than once but not clap forever: { claps = Clap.all({ : { : post.id, : loggedInUserId
    }
  }) (claps.length > ) { } Clap.create({ : post.id, : loggedInUserId
  })
} ( ) function clap post, loggedInUserId // 1. Must be logged in // 2. Disallow claps for post creators // 3. Disallow more than 20 claps per clapper const await where post_id user_id if 20 // return 401 // Finally, clap (again) return await post_id user_id You can boast of a working app, but tell me how you feel about managing these few years down the line when more feature requests keep coming in. All-in-one with Hasura First thing, first — delete all these resolvers. Hasura is what I like to call Backend as a Service. It handles data management, relationships, schemas, authorization/permissions, and allows you to focus on custom business logic through its extensibility features. What this means for you as a developer is that you will spend more time building user experiences on the web and less time on handling repetitive tasks like CRUD, roles, etc. To see Hasura in action and use it for complex permissions, there are few things you need to setup. I won’t go through them in this article because I won’t be doing the official docs justice: or run Hasura . Deploy locally with Docker we have in the model diagram above. Create the tables to each other using foreign keys as shown the diagram Relate the tables Here is what a User → Post relationship should look like: Using Hasura for Permission Before we see what Permissions in Hasura look like, you need to remember one thing — HTTP is stateless. So for every query or mutation you send to a Hasura backend, you need to ensure that a session variable or JWT is available. You can set up an auth server or use something like Auth0. Either option you decide to go with, there is to guide you. We are not going to set up authentication just so we can get our hands on a session variable or JWT. We can mock these and use them for testing the API you have set up. a good doc on both It’s also good to know that Hasura permissions allow you to define access on both rows and columns. For example: User A should only edit user A’s post (row rule) User A cannot change the create-on date (column rule) So far, here are all the permission rules we had from the beginning of this article: Only a logged-in user can create a post Only admin users can delete post(s) Only logged in users can vote Post creators CANNOT vote on the posts they created A voter can only vote once on a given post 1. Only a logged-in user can create a post This one is dead-simple — we need to tell Hasura that before it tries to write/create a post, it should check for a session variable that has the user id to ensure that a user is authenticated. Authentication is useless if all your data is open to the public. So the first thing you should do before creating authentication and rules is to make your . Hasura API private Reload your localhost, and you should be asked to provide the secret you used in making Hasura private: To create permission, click on the Data menu in the navbar, then chose the table from the left that you want to add permissions to. Since we want to make sure only logged in users can create posts, we should be choosing the post table. Click on the Permissions tab and follow the screenshot below to create insert permission: We don’t need a custom check on the user for now. All we care about is whether a user is logged in before we can allow an insert. We don’t care which user it is. We have just defined row permissions, but we also need to set what columns the user can insert values in. We don’t want users editing the or the foreign key, . id user_id Save the permissions and create a user from the GraphQL menu. We need this user’s Id to create posts. Set the header to which is the only permission we have so far except for the admin. Notice that once you set this value, the operations you can run will be limited down to just mutation: x-hasura-role user insert_post 2. Only admin users can delete post(s) Deleting is as simple as just updating to : x-hasura-role admin 3. Only logged in users can vote The permission is just like what we had for creating posts: Inserting vote will now be available as an operation as long as the is set to : x-hasura-role user 4. Post creators CANNOT vote on the posts they created This permission will look slightly different. We have to update the userrole we created in the previous step, which allows any user to vote. We need to update it to use a custom check that ensures that the user_id column on the post table is not equal to the header value. is the authenticated . X-Hasura-User-Id X-Hasura-User-Id user For post table properties to be available in a vote permissions rule, you need to make sure that the relationship does NOT only stop at just . You also need to add an as well. adding Foreign keys object relationship Save the permissions and try to vote as the user that created the post: mutation MyMutation {
  insert {
    affected_rows
  }
} _vote( : { : 1, : 1}) objects post_id user_id You will get a permission error, but when you try as a different logged-in user, you will be able to vote: (Remember to add a user with a user id value of 2) 5. A voter can only vote once on a given post To make sure we don’t allow users to vote more than once on a particular post, we need to be able to count how many votes they have so far on that given post. We have two options: Use to write custom validation logic. With this custom logic, you can query and count. Event Triggers Use a Postgres View that aggregates rows based on the count of votes. You can then add a manual relationship to this view and use it to create permissions. I usually go with option 2 because the less code I have to write, the less chances I have to introduce bugs to my project. Start with creating a View. Go to the menu and click on . Paste the following SQL to create a View: Data SQL . (vote.id) ,
    vote.user_id,
    vote.post_id vote vote.user_id, vote.post_id; CREATE OR REPLACE VIEW "public" "vote_count" AS SELECT count AS count FROM GROUP BY Here is a screenshot to guide you: You should see that this adds a new Table (View) on the list of tables, called : vote_count To ensure it works, run the following GraphQL query twice: mutation MyMutation {
  insert {
    affected_rows
  }
} _vote( : { : 2, : 1}) objects user_id post_id Just like it appears here: Now you tale a look at the table you should see we have 2 votes tied to the same user and the same post: vote But where it gets interesting is when you take a look at the View: vote_count Now let’s add a relationship on the table to point to the view. Since Views are technically not Tables, we have to use a manual relationship on Hasura. A manual relationship tells Hasura to treat these entities as related even though they are not both tables. vote vote_count To create a manual relationship, head to the table, choose the relationship tab, and click . Next, fill out the form with the following value: vote configure With this view setup, you can use it to determine whether it’s ok for someone to vote by ensuring they haven’t voted yet. Since we already have the first permission rule that checks if the post does not belong to the user, we have to use an operator to add multiple rules. This operator is , which behaves like and operators in programming languages. _and The operator, as seen in box 1 is an array. Every item in this array has to resolve to true before permission can be granted. This makes sense because we want the following to be true before a user can vote: _and The user trying to vote did not create the post (implemented) Users can only vote once The second rule is what we will implement in the field highlighted in box 2. Before we do that, we need to discuss the possible cases: A user can vote if the count field in the view is less than 1. A user can vote if the user was never in the view. This might seem like we are saying the same thing, but we aren’t. If you are familiar with JavaScript, it’s like a variable having a value of vs . Case 1 is value 0; case 2 is value undefined. If you only account for 1, you would have an unhandled edge case, which will lead to a bug. We need to make sure that if any of these cases occur, the user should be able to vote. 0 undefined This is a classic or operator use-case in programming languages. We can use this operator in Hasura as well: Here is a complete breakdown of what is happening here: An and operator checks: That the voter is not the owner of the post That the operator resolves to true or The or operator checks either of these and if any is true would resolve to true: The user’s vote count is less than 1 (so 0) Or that the row is empty (_not) With this setup, clear the vote table and try voting as a different user from the one that created the post using the GraphQL query window. Notice the voting goes through the first time. Now try it again, and you will get a permission error. You just implemented some powerful permission strategies in GraphQL without a single line of code. I am not surprised; it’s 2020! This is just a tip of the iceberg on what you can do with permissions using Hasura. You can take a look at on what is possible. You can also explore scenario. the docs this Github-scale permissions Previously published at //dev.to/codebeast/handling-complex-user-permissions-in-graphql-538p

How To Handle Complex User Permissions in GraphQL

The open source gives you high performance GraphQL APIs over Postgres. Deploy it to the Heroku free tier in 30 seconds. Hasura GraphQL Engine Get started with GraphQL in just 30 seconds with Hasura GraphQL Engine on Heroku At , we have always been huge fans of Heroku’s git push based deployment workflow. All of our engineers have, at some point, had side projects running with Heroku, and one of our most popular open source projects, , brings the Heroku workflow to a Kubernetes cluster. Hasura Gitkube Our aim with the Hasura GraphQL Engine is to help you setup a GraphQL server with the least amount of friction, so that you can start building applications without any setup. With that in mind, we present the Hasura deployment on Heroku’s free tier. 30 seconds to GraphQL zen! Basic deployment of the Hasura GraphQL Engine on Heroku Importing your own data In case you already have data, Hasura allows you to import it and begin using GraphQL queries instantly. Here’s how: Import your existing Postgres database and get GraphQL APIs with Hasura (For this demo, we used the freely available ) Chinook data set Bonus: Connecting your existing Heroku Postgres We designed Hasura to allow developers running existing Postgres based applications to migrate to GraphQL without having to write any backend code. If you are already running on Heroku Postgres, Hasura can connect directly to give you GraphQL APIs. You can get step-by-step instructions . here Architected for high performance While designing Hasura, we had two objectives: Hasura should be able to run anywhere, from your local machine to the Heroku free tier to a server on Amazon, Google or Microsoft. You should be able to extract maximum performance/dollar. Consequently, we optimised Hasura for low memory footprint & low latency. Hasura GraphQL Engine gives you ~600 req/s while consuming only 50 MB of RAM on Heroku’s free tier We have written about the design decisions involved in . this blogpost 🎉🎉Hasura GraphQL Engine is open source!🎉🎉 We have just open sourced the Hasura GraphQL Engine. Check out the complete repo on , and let us know your thoughts! We would love to hear from you- we are very active on our . Github discord server Hasura gives you instant GraphQL APIs over any Postgres database without having to write any backend code. If you would like to stay updated on all things Hasura, you can sign up for our newsletter .

Getting started with GraphQL APIs on Heroku

How I Landed 4 Jobs and Earned $25K+ With Technical Writing

How to Secure User Authentication in React With Clerk

Serverless Databases in 2024: The State of Serverless Solutions for Modern Apps

Today is the first day of the WunderGraph launch week, it's our first launch week actually. We have a lot of things to share with you, like Open Federation, Cosmo, and more... What excites me the most is that today marks the beginning of a new era for . For a very long time, the GraphQL ecosystem has been dominated by a single company. However, this is about to change through two initiatives and the ecosystem that will emerge around them. GraphQL The first step is , an MIT-Licensed specification to build federated GraphQL APIs. The goal of Open Federation is to enable the GraphQL ecosystem to build federated GraphQL APIs without having to rely on Apollo's proprietary technology. It's a drop-in replacement for Apollo Federation, it's open source and free to use for everyone. Open Federation Most importantly, we're not announcing Open Federation alone. Open Federation is a joint effort by WunderGraph, Grafbase, Escape Tech, Neo4j, TailorTech, Sibipro, Soundtrack Your Brand, Travelpasses, and many more. The second step is , a specification for composed GraphQL APIs that goes way beyond what Apollo Federation offers, like support for composing not just GraphQL APIs, but also REST(OpenAPI), gRPC, AsyncAPI, and more. GraphQL Fusion . GraphQL Fusion will live under the GraphQL Foundation The goal of Fusion is to enable the composition of GraphQL APIs with a diverse set of vendors and technologies. Fusion is a joint effort by ChilliCream, The Guild, Hasura, IBM, Solo.io, AWS AppSync, and WunderGraph. Instead of every vendor building their own proprietary composition technology, we're building a single open-source specification that everyone can implement, so that we can all work together to build a better GraphQL ecosystem. For today, we're focusing on Open Federation, but stay tuned for more information about GraphQL Fusion. You'll definitely hear more about it during the GraphQL Conference by the GraphQL Foundation. We'll be there as well, so make sure to say hi at our booth. The History of Open Federation I'm the creator of graphql-go-tools, a GraphQL library for Go that is used by many companies to build GraphQL Gateways and other GraphQL tools. I've been working on this library for more than 5 years now and it has been a great success. Almost 3 years ago, I started adding support for . As excited as I was about the idea of Federation, the community was not ready for it yet. I added support for Subscriptions years ago, but demand for it was very low, so my focus shifted to solving other problems. Apollo Federation to graphql-go-tools Fast forward to 2023, and suddenly things have changed fundamentally. The GraphQL ecosystem has grown a lot and the demand for Federation has increased significantly. At the same time, Apollo started closing down their open-source ecosystem with license changes, price increases, and more. All of this led to a lot of people reaching out to us and asking for help. Some of them, like TailorTech, were even willing to sponsor the development of a Federation v2 compatible Gateway and composition tooling for graphql-go-tools. Big enterprises helped us a lot with testing or providing GraphQL schemas of their federated Graphs to test our implementation. But there was a problem we had to overcome first. What actually is Apollo Federation? This might sound like a silly question, but it's actually not. At this point, we should all have some high-level understanding of what the Federation is. But have you ever looked at the details, like the specifications? Here's the of Apollo Federation v2. It's nine Directives and one Scalar, that's it. No comments, no explanations, no examples, nothing. It's everything but a specification and it actually leaves all the important questions unanswered. "Specification" For example, how do you actually implement a Federation Gateway? What is the Gateway supposed to do? What are the rules to validate a federated GraphQL schema? How do you actually compose federated GraphQL APIs? What are the rules to check if two or more subgraphs are compatible? In comparison, the GraphQL Specification describes in a lot of detail how a GraphQL Server should behave. It contains numerous examples for validation and execution rules, as well as descriptions of basic algorithms like how to merge selection sets or how to execute a GraphQL Query. If you want to understand Apollo Federation in detail, you have to read a lot of documentation in different places and even then, you'll still have a lot of questions. You might be able to reverse-engineer the behavior of the Apollo Gateway and Router, but even if you do, there are still some behaviors that seem random and are not documented anywhere. So we asked ourselves, how can we build tools to compose subgraphs and a Router / Gateway to resolve federated GraphQL Queries without having a proper description of "our understanding" of Federation? The birth of Open Federation That's when we decided to start writing down our own understanding of the Federation. By writing down all our knowledge, you're able to criticize it and help us improve it. If you find gaps or mistakes, we can collaborate to find a common understanding of what Federation is, how composition works, and how a Gateway should behave. From that point on, multiple vendors can implement the same specification so you're free to choose the best solution for your use case. You're not locked into a single vendor anymore, you can switch to a different vendor at any time. You can even if you want to. In addition, you can suggest improvements to the specification and actually have an impact on the future of federated GraphQL APIs. build your own Gateway The goals of Open Federation We don't believe that there's a future for proprietary API Composition solutions. It's very unlikely that a single vendor with a closed-source solution is capable of serving the market with the best possible solution. We've seen the opposite in the past with OpenAPI. Before OpenAPI, there were many proprietary custom solutions to describe and manage . However, OpenAPI has become the de-facto standard for REST APIs and is supported by many vendors and tools. It's a great success story and has led to a lot of innovation in the REST API space. REST APIs We believe that Open Federation can have a similar impact on the GraphQL ecosystem. An open specification will make federated GraphQL much more accessible and attractive to a lot of companies and therefore will lead to a bigger adoption of GraphQL in general. This in turn will attract more vendors to the GraphQL ecosystem, which will lead to more innovation and healthy competition. After all, it's in the best interest of the GraphQL ecosystem to have a diverse set of vendors and technologies. By standardizing the composition of GraphQL APIs, vendors can focus on their strengths and collaborate with complementing solutions. The key is Composable Architecture and interoperability. Different implementations of the specification can focus on different use cases and technologies. One vendor might focus on a Gateway that is optimized for performance by using Rust or Go, while another vendor might optimize for extensibility, e.g. by writing the Gateway in NodeJS. At this point, you might be wondering, what's the difference between Open Federation and Apollo Federation? What's the difference between Open Federation and Apollo Federation? Apollo Federation is not a complete specification. It's a set of directives that, if used correctly on a subgraph, will make it compatible with the Apollo Gateway and Router. Open Federation builds on top of the same directives to specify subgraphs. It's a specification that describes in detail the rules to compose subgraphs, and how federated GraphQL requests should be planned and executed. Open Federation can be seen as a drop-in replacement for Apollo Federation, just that it's way more specific, open source, and free to use for everyone. What's the relationship between Open Federation and GraphQL Fusion? For a lot of use cases, federated GraphQL APIs will be more than enough, and there's no reason not to adopt or use Open Federation. However, there will be use cases where you want to compose not just federated GraphQL APIs, but also REST APIs, gRPC APIs, AsyncAPI, and more. This is where GraphQL Fusion comes into play. Conclusion Federated GraphQL is a mature technology and has been used in production for years. GraphQL Fusion is still in its early stages and will take some time to get to the same level of maturity. We bet on both technologies and believe that they will complement each other very well. Time will tell if both technologies will live alongside each other or if one will eventually dominate the other. What matters most to us is that we're standardizing the composition of APIs to build a better GraphQL ecosystem. Also published . here If you haven't already, make sure to check out and have a look at the specifications. We're looking forward to your feedback and contributions. Open Federation

Stories, News & Mentions about HASURA

Hasura’s Stories on HackerNoon

Hasura's News & Mentions