Learn how Hasura can instantly turn your SQL database into a GraphQL API. https://github.com/hasura/graphql-engine

This video is NOT sponsored. 

#graphql #api #100SecondsOfCode 

🔗 Resources

Hasura https://hasura.io/
GraphQL https://graphql.org/learn/

 🤓 Install the quiz app

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

🔥 Watch more with Fireship PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T05:51:31.097Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
1be8577d-83d7-400b-b301-d58579fa1f07
31b364920c1e531e79f774d6614edd741887edcd5a3c02147e6b2ee2b50f918c
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Hasura.
Instantly turn your relational database into a GraphQL or REST API.
When building a full stack application, the end user likely needs to communicate with the database.
That means you need to build a secure API in the middle so the client can tell the server what it needs from the database.
But building the perfect API is easier said than done.
Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you.
Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app.
If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI.
And it can even help you configure relationships between tables.
In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data.
In some cases, you may want to extend the schema with your custom queries or mutations.
Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways.
In addition, you may want to trigger server side code when something changes in the database.
Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background.
But one thing Hasura doesn't handle is user authentication.
Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button.
Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end.
You might use something like Apollo to query, mutate, and set up real time subscriptions to your database.
In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database.
And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier.
This has been Hasura in 100 seconds.
If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments.
Thanks for watching, and I will see you in the next one.

Speaker 0: Hasura. Instantly turn your relational database into a GraphQL or REST API. When building a full stack application, the end user likely needs to communicate with the database. That means you need to build a secure API in the middle so the client can tell the server what it needs from the database. But building the perfect API is easier said than done.

Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you. Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app. If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI. And it can even help you configure relationships between tables. In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data.

In some cases, you may want to extend the schema with your custom queries or mutations. Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways. In addition, you may want to trigger server side code when something changes in the database. Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background. But one thing Hasura doesn't handle is user authentication.

Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button. Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end. You might use something like Apollo to query, mutate, and set up real time subscriptions to your database. In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database. And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier.

This has been Hasura in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments. Thanks for watching, and I will see you in the next one.
Hasura. Instantly turn your relational database into a GraphQL or REST API. When building a full stack application, the end user likely needs to communicate with the database. That means you need to build a secure API in the middle so the client can tell the server what it needs from the database. But building the perfect API is easier said than done. Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you. Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app. If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI. And it can even help you configure relationships between tables. In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data. In some cases, you may want to extend the schema with your custom queries or mutations. Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways. In addition, you may want to trigger server side code when something changes in the database.
databases
networking
data management
data
Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background. But one thing Hasura doesn't handle is user authentication. Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button.
Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end. You might use something like Apollo to query, mutate, and set up real time subscriptions to your database. In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database. And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier. This has been Hasura in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments.
databases
youtube
streaming
multimedia
data management
Thanks for watching, and I will see you in the next one.
Hasura. Instantly turn your relational database into a GraphQL or REST API. When building a full stack application, the end user likely needs to communicate with the database. That means you need to build a secure API in the middle so the client can tell the server what it needs from the database. But building the perfect API is easier said than done. Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you. Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app. If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI. And it can even help you configure relationships between tables. In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data. In some cases, you may want to extend the schema with your custom queries or mutations. Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways. In addition, you may want to trigger server side code when something changes in the database. Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background. But one thing Hasura doesn't handle is user authentication. Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button. Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end. You might use something like Apollo to query, mutate, and set up real time subscriptions to your database. In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database. And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier. This has been Hasura in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments. Thanks for watching, and I will see you in the next one.
Hasura.
hasura
Instantly
instantly
turn
turn
your
your
relational
relational
database
database
into
into
a
a
GraphQL
graphql
or
or
REST
rest
API.
api
When
when
building
building
a
a
full
full
stack
stack
application,
application
the
the
end
end
user
user
likely
likely
needs
needs
to
to
communicate
communicate
with
with
the
the
database.
database
That
that
means
means
you
you
need
need
to
to
build
build
a
a
secure
secure
API
api
in
in
the
the
middle
middle
so
so
the
the
client
client
can
can
tell
tell
the
the
server
server
what
what
it
it
needs
needs
from
from
the
the
database.
database
But
but
building
building
the
the
perfect
perfect
API
api
is
is
easier
easier
said
said
than
than
done.
done
Front
front
end
end
developers
developers
love
love
using
using
GraphQL,
graphql
but
but
back
back
end
end
developers
developers
are
are
faced
faced
with
with
the
the
challenge
challenge
of
of
writing
writing
efficient
efficient
SQL
sql
queries
queries
that
that
resolve
resolve
the
the
GraphQL
graphql
schema,
schema
the
the
Hasura
hasura
engine
engine
eliminates
eliminates
this
this
problem
problem
by
by
automatically
automatically
generating
generating
the
the
schema
schema
and
and
resolvers
resolvers
for
for
you.
you
Just
just
point
point
it
it
to
to
your
your
Postgres
postgres
database
database
and
and
it
it
will
will
use
use
the
the
existing
existing
tables
tables
and
and
views
views
to
to
generate
generate
an
an
API
api
that's
that's
ready
ready
to
to
roll
roll
in
in
your
your
front
front
end
end
app.
app
If
if
you
you
don't
don't
already
already
have
have
a
a
database,
database
you
you
can
can
connect
connect
one
one
from
from
anywhere
anywhere
in
in
the
the
cloud,
cloud
then
then
add
add
tables
tables
and
and
rows
rows
to
to
it
it
and
and
manage
manage
all
all
of
of
your
your
data
data
directly
directly
from
from
the
the
web
web
UI.
ui
And
and
it
it
can
can
even
even
help
help
you
you
configure
configure
relationships
relationships
between
between
tables.
tables
In
in
addition
addition
to
to
databases,
databases
you
you
can
can
also
also
connect
connect
third
third
party
party
APIs
apis
to
to
your
your
schema
schema
to
to
create
create
a
a
single
single
source
source
of
of
truth
truth
for
for
all
all
your
your
data.
data
In
in
some
some
cases,
cases
you
you
may
may
want
want
to
to
extend
extend
the
the
schema
schema
with
with
your
your
custom
custom
queries
queries
or
or
mutations.
mutations
Actions
actions
provide
provide
a
a
way
way
to
to
implement
implement
custom
custom
business
business
logic
logic
in
in
an
an
external
external
server
server
or
or
a
a
serverless
serverless
function
function
to
to
read
read
and
and
write
write
data
data
in
in
more
more
complex
complex
ways.
ways
In
in
addition,
addition
you
you
may
may
want
want
to
to
trigger
trigger
server
server
side
side
code
code
when
when
something
something
changes
changes
in
in
the
the
database.
database
Like,
like
you
you
may
may
want
want
to
to
send
send
a
a
transactional
transactional
email
email
when
when
a
a
new
new
row
row
is
is
added
added
to
to
table,
table
Hasura
hasura
events
events
can
can
be
be
triggered
triggered
based
based
on
on
operations
operations
to
to
a
a
certain
certain
table
table
or
or
scheduled
scheduled
with
with
a
a
CronJob
cronjob
in
in
the
the
background.
background
But
but
one
one
thing
thing
Hasura
hasura
doesn't
doesn't
handle
handle
is
is
user
user
authentication.
authentication
Although,
although
you
you
can
can
easily
easily
connect
connect
to
to
your
your
favorite
favorite
authentication
authentication
service
service
and
and
provide
provide
a
a
role
role
session
session
variable
variable
when
when
the
the
user
user
makes
makes
requests,
requests
which
which
can
can
then
then
be
be
used
used
to
to
implement
implement
role
role
based
based
access
access
control
control
role
role
with
with
the
the
click
click
of
of
a
a
button.
button
Now,
now
because
because
the
the
API
api
is
is
created
created
with
with
an
an
industry
industry
standard
standard
like
like
GraphQL,
graphql
you
you
can
can
use
use
any
any
GraphQL
graphql
client
client
that
that
you'd
you'd
like
like
to
to
access
access
the
the
data
data
on
on
the
the
front
front
end.
end
You
you
might
might
use
use
something
something
like
like
Apollo
apollo
to
to
query,
query
mutate,
mutate
and
and
set
set
up
up
real
real
time
time
subscriptions
subscriptions
to
to
your
your
database.
database
In
in
other
other
words,
words
Hasura
hasura
is
is
kind
kind
of
of
like
like
a
a
middleman
middleman
that
that
doesn't
doesn't
care
care
what
what
you
you
use
use
on
on
the
the
front
front
end
end
or
or
where
where
you
you
host
host
your
your
actual
actual
database.
database
And
and
best
best
of
of
all,
all
it's
it's
an
an
open
open
source
source
project
project
that
that
can
can
be
be
self
self
hosted
hosted
or
or
paid
paid
for
for
as
as
a
a
fully
fully
managed
managed
service
service
with
with
a
a
free
free
tier.
tier
This
this
has
has
been
been
Hasura
hasura
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
see
see
more
more
short
short
videos
videos
like
like
this,
this
make
make
sure
sure
to
to
hit
hit
the
the
like
like
button
button
and
and
let
let
me
me
know
know
if
if
you
you
want
want
to
to
see
see
a
a
full
full
tutorial
tutorial
on
on
this
this
topic
topic
in
in
the
the
comments.
comments
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The speaker explains that Hasura is created to turn a relational database into a GraphQL or REST API, which allows users to communicate with the database and build a secure API. The front end developers love GraphQL, but back end developers face the challenge of writing efficient SQL queries that resolve the schema. The project is open source, flexible, and cost-free, and can be hosted or paid for.
Hasura in 100 Seconds
Hasura. Instantly turn your relational database into a GraphQL or REST API. When building a full stack application, the end user likely needs to communicate with the database. That means you need to build a secure API in the middle so the client can tell the server what it needs from the database. But building the perfect API is easier said than done. Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you. Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app. If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI. And it can even help you configure relationships between tables. In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data. In some cases, you may want to extend the schema with your custom queries or mutations. Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways. In addition, you may want to trigger server side code when something changes in the database. Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background. But one thing Hasura doesn't handle is user authentication. Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button. Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end. You might use something like Apollo to query, mutate, and set up real time subscriptions to your database. In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database. And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier. This has been Hasura in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments. Thanks for watching, and I will see you in the next one.
The speaker explains that Hasura is created to turn a relational database into a GraphQL or REST API, which allows users to communicate with the database and build a secure API. The front end developers love GraphQL, but back end developers face the challenge of writing efficient SQL queries that resolve the schema. The project is open source, flexible, and cost-free, and can be hosted or paid for.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Hasura in 100 Seconds 
        and a small summary : The speaker explains that Hasura is created to turn a relational database into a GraphQL or REST API, which allows users to communicate with the database and build a secure API. The front end developers love GraphQL, but back end developers face the challenge of writing efficient SQL queries that resolve the schema. The project is open source, flexible, and cost-free, and can be hosted or paid for.
        [/INST]
        
        Generate the video : Hasura. Instantly turn your relational database into a GraphQL or REST API. When building a full stack application, the end user likely needs to communicate with the database. That means you need to build a secure API in the middle so the client can tell the server what it needs from the database. But building the perfect API is easier said than done. Front end developers love using GraphQL, but back end developers are faced with the challenge of writing efficient SQL queries that resolve the GraphQL schema, the Hasura engine eliminates this problem by automatically generating the schema and resolvers for you. Just point it to your Postgres database and it will use the existing tables and views to generate an API that's ready to roll in your front end app. If you don't already have a database, you can connect one from anywhere in the cloud, then add tables and rows to it and manage all of your data directly from the web UI. And it can even help you configure relationships between tables. In addition to databases, you can also connect third party APIs to your schema to create a single source of truth for all your data. In some cases, you may want to extend the schema with your custom queries or mutations. Actions provide a way to implement custom business logic in an external server or a serverless function to read and write data in more complex ways. In addition, you may want to trigger server side code when something changes in the database. Like, you may want to send a transactional email when a new row is added to table, Hasura events can be triggered based on operations to a certain table or scheduled with a CronJob in the background. But one thing Hasura doesn't handle is user authentication. Although, you can easily connect to your favorite authentication service and provide a role session variable when the user makes requests, which can then be used to implement role based access control role with the click of a button. Now, because the API is created with an industry standard like GraphQL, you can use any GraphQL client that you'd like to access the data on the front end. You might use something like Apollo to query, mutate, and set up real time subscriptions to your database. In other words, Hasura is kind of like a middleman that doesn't care what you use on the front end or where you host your actual database. And best of all, it's an open source project that can be self hosted or paid for as a fully managed service with a free tier. This has been Hasura in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and let me know if you want to see a full tutorial on this topic in the comments. Thanks for watching, and I will see you in the next one.
        