►
Description
GraphQL, Simplified - David Clements & Matteo Collina, NearForm
Use React? Use GraphQL? Love Hooks? Graphql-hooks is a new GraphQL client for React with a hooks-first API. It’s super fast and weighs only 1.9kB gzipped.
The motivation behind graphql-hooks was a barebones GraphQL Client, focused on speed and lightweight. Both Apollo and Relay have pioneered how to use GraphQL on the client. However, over the years they’ve grown in size and complexity. This has increased the barrier to entry for new developers excited to try out GraphQL.
In this workshop, David and Matteo will be demonstrating how quick and simple it is to get up and running with the graphql-hooks client and fastify-gql GraphQL server library to produce an easily maintainable and high performance fullstack GraphQL implementation.
A
This
might
be
our
last
time,
okay,
how
many
people
have
done
what
we
graphic
y'all
before
couple
cool?
How
many
people
have
worked
with
react
hoaxes
before
so
we
have
the
right
crowd:
yeah
yeah!
This
is
good
if
you
haven't
done
either
of
those
things.
Probably
the
person
next
to
you
has
so
feel
free
to
interact
yes
with
us
and
with
each
other.
A
C
B
Know
it's
deputy
Mike,
lamb
and
at
Mattel
Collina.
So
please
follow
us
on
Twitter.
Thank
you
and
so
bless.
I
would
say,
that's,
let's
start
Dave.
Let's
stop
yay!
So
welcome
everybody,
and
this
is
an
interactive
workshop.
So
you
suspect
to
do
some
coding.
Maybe
there
will
be
some
material
left
over
to
be
a
home.
Do
do
at
home
exercise
because
it's
a
short
format,
so
yeah.
A
B
First
thing:
we
both
work
for
near
firm,
so
check
us
out
we
out
of
the
booth.
So
if
you
have
any
out
with
your
JavaScript
application,
we
are
a
professional
services
company.
So
let's
talk
and
we
can
help
no
sort
of
ways.
So
please,
just
you
know
just
reach
out
so
a
couple
of
things,
quick
things
of
the
sitter
setup.
You
can
use
no
ten
plus.
So
if
you
have
no
12
is
fine
and
but
but.
A
A
A
B
A
A
B
A
A
B
A
A
A
A
So
here's
an
example
of
a
react
talk.
This
is
one
is
consist
conceptually
this
wise.
That
requires
some
levers.
Just
like
you
know,
for
talking
purposes,
so
you
say
we
have
a
library
that
has
a
used
API
hook,
so
the
use
API
hook
would
be
used
within
a
function
component
and
it
would
return
an
object
from
which
we
do
D
structure,
the
parameter,
the
keys,
error
and
name.
A
The
the
second
value
here
would
be
like
what
the
initial
value
should
be,
which
is
where
name
is
loading,
so
the
first
value
of
name
would
be
loading
so
when
it
renders
the
age
to
element
in
the
the
JSX
there,
it
would
first
say
loading
the
use
the
API
hook
would
go
and
query
the
make
make
the
asynchronous
call.
When
that
cool
resolves,
it
would
trigger
a
rerender
with
that
new
value
and
the
second
time
it's
called
the
use
API
hook
would
return
an
object
where
the
name
is
whatever
that
user's
name.
B
A
A
B
Graph
QL
is
a
data.
Query,
language,
okay,
it's
it's
it
was.
It
was
born
at
Facebook
a
long
time
ago
to
to
build
an
API
that
can
represent
the
entirety
of
Facebook
whatever
this
means,
what
is
useful
for?
Well
it.
It
has
some
very
a
lot
of
very
nice
properties
which
it's
it's
self
evolving.
It
can
evolve
it.
You
don't
need
to
version
it
and
it's
really
powerful.
It's
it
schema
based.
So
you
write
a
schema.
You
get
the
graphical
schema
and
then
you
provide
some
functions
and
called
resolvers
to
populate
that
data.
B
It
also
strongly-typed,
so
you
can
actually
define
your
types
and
everything
would
work
now.
It's
nothing!
It's
nothing
related
to
typescript.
Ok,
so
I!
Don't
worry
about
that
very
different
thing.
It's
also
self
documenting
which
is
for
me.
This
is
more
critical,
the
most
nice
feature
of
this
and
what
it
enables
at
create
a
mento
of
productivity.
So
you
can
actually
explore
the
API
using
some
tools
that
which
you
will
see
if
you're
not
familiar
with
them,
and
it's
actually
very
powerful
because
of
this.
B
It's
it
shortened
up
the
development
cycle
of
not
all
I
need
to
think
about
these
rest
api
blah
blah
blah.
Instead,
you
can
just
add
some
more
data
term,
some
more
some
more
something
more
into
the
schema
and
just
devote
the
day
it's
if
it
has
fewer
run.
It
provides
fewer
round
trips,
so
in
a
normal,
traditional
rest
application.
B
If
you
want
to
fetch
three,
the
data
for
for
your
app
needs
to
do
three
holes
over
HTTP
instead
of
doing
three
holes,
you
can
just
hit
your
graph
QL
and
point
only
once
asking
for
all
the
three
three
pieces
of
data
and
will
automatically
bring
it
back
to
you,
which
is
really
powerful
to
provide
a
better
performance
on
the
on
the
front
end
of
your
system,
and
it
also
provides
a
little
bit
smaller
payloads
because
of
all
of
this.
So
what
is
a
graph
QL
hooks
graph?
Ql
hooks?
B
Are
it's
a
library
that
we
have
written
an
ear
for
to
provide
a
smaller
version,
a
smaller,
a
minimal
way
of
using
graph
QL
with
hooks
with
reactives?
And
it's
you
know,
you
probably
use
familiar
with
Apollo
Apollo
is
kind
of
big
compared
to
what
what
you
are
aiming
to
do
with
real
with
graphical
hooks.
This
is
tiny
and
it
was
really
well
and
it's
it's
really
lightweight.
It's
a
few
kilobytes
to
add
to
your
to
your
bundle
compared
to
to
Apollo.
So
right.
A
A
A
A
A
D
B
A
B
A
B
So,
first
of
all,
the
goals
of
the
first
step
is
get
a
graphical
server
up
and
running
and
explored
that
server
using
graphic
graph,
iql
graphical
graphical,
yeah
graphical.
So
what
you're
going
to
use
we're
going
to
use?
Nodejs?
Okay,
it's
no
clusters
interactive!
So
maybe
it's
wrong!
You
have
the
wrong
conference.
You
want
to
use
another
language,
we're
going
to
use
FASTA
Phi,
hey
I'm,
Matteo,
I
kind
of
started
fast
if
I
with
Thomas
like
back
in
2016.
So
it's
a
long
time
ago,
I
had
some
ideas.
B
Near
it,
but
I
was
probably
it
was
part
of
it
of
the
original
ideas
about
all
of
this.
Please
check
it
out.
It's
sparked
opens
a
yes
foundation
and
so
on
so
you
know
trade-off
and
we're
going
to
use
react:
okay,
yeah,
it's
reactive,
so
and
we're
going
to
some
graphical
stuff.
So
you
can
check
yourself.
The
first
thing
you
do,
you're
going
to
the
exercise.
B
B
A
B
A
A
I've
already
installed
us,
so
you
should
see
that
should
be
your
end
result
after
you've
run
npm
run
watch
should
have
a
server
listening
one
two:
seven:
zero
zero
one,
three
thousand,
and
if
your
imp
in
that
it
will
be
this
hello
world
thing
and
you
can
list
users,
you
can
add
a
user
in
add
matteo.
Well,.
E
D
A
A
A
A
A
We're
requiring
faster
fire
gql,
which
is
a
module
written
by
Matteo,
we'll
go
into
details
on
that
in
a
second
don't
get
too
excited.
We
have
just
like
a
mocked
data.
We
don't
we're
not
using
a
database
of
this
it'd
take
too
long,
but
you
get
the
idea.
This
is
a
placeholder,
for
you
know:
data
storage
of
an
array
of
users.
A
We
have
two
schemas
which
we're
gonna
go
into
details
of
two
types:
yeah
ty,
key
Metro
tech,
yeah,
one
schema,
sorry
graph,
QL
types,
one
called
user,
one
called
Q
query:
query:
has
a
user's
key
with
an
array
of
types
of
user.
So
this
is
basically
saying
this
is
an
array
of
objects
with
the
names
which
are
strings,
which
is
the
describing
this
here.
B
A
And
then
we
have
resolvers,
which
is
basically
the
counterpart
that
you
give
to
us
to
fight
you
all
to
say
this
is
how
we
handle
a
particular
type
in
the
schema.
So
we
only
have
one
defined
for
queried
and
it
has
a
user's
method
which
corresponds
to
this
users
key,
and
we
return
the
user
list.
Array
from
that.
And
here
we
have
the
lip
lock
in
the
first
fi
plugging
that
registers
phosphide
gql,
with
our
schema,
where
the
resolvers,
and
notably
we
set
graph,
eql
or
graphical
to
true,
because.
B
A
D
A
B
One
of
the
greatest
thing
about
about
about
graphical
is
that
you
can.
Actually
you
know
what
you
can
say.
You
can
open
up
this
and
then,
if
you
start
typing,
you
automated
here
out
of
completion-
and
you
can
add
in
line
docs
to
your
you
can,
you
can
add,
in
line
dogs,
to
to
your
comments
to
it
to
your
error
solvers.
B
So
you
can
basically
said
I
want
users,
okay
and
so,
and
then
you
can
actually
say,
for
example,
and
then
you
can
specify
the
property,
the
properties
that
you
want,
and
you
say
name
again
and
you
close
note
that
if
you
open
dogs,
you
will
see
the
drop
of
the
route
types.
Those
are
the
ones
that
are
attached
to
the
query.
Object
so
that
you
know
it's.
You
can
actually
explore
this
and
search
it
and
navigate
it
completely.
So
a
graphic
graphic
well
graphical
is
fully
sub
the
scrappy.
Yes,.
B
B
B
So
you
might
want
to
check
this
out
if
you're
already
using
graph
you
out,
because
first,
if
I
drew
QL,
is
actually
fast
and
we
have
done
a
lot
of
distance
amount
of
research
and
I'll
talk
to
my
is
graph
ul
we've
done
last
year
at
this
conference.
Mattias
booth
and
myself
did
a
talk
called
graph
ul
accelerated.
If
you
are
interested,
you
might
want
to
check
that
out,
and
it's
a
pretty
goes
into
deep
into.
Why
and
how
we
have
optimized
it,
how
we
have
optimize
it
graph
you
out
yeah
this.
A
You
want
to
do
that
in
a
database.
It's
gonna
be
more
efficient,
so
this
is
actually
a
hard
problem
in
node,
because
we're
you're
trading
off
a
lot
of
different
things.
So
performance
is
very
hard
for
for
for
this
kind
of
thing.
So,
first,
why
gql
is
like
pretty
amazing,
but
the
one
thing
it
doesn't
have
yet
mateo
federated
Federation,
yeah
Federation.
B
B
Were
you
all
able
to
run
the
query
fantastic
one,
more
thing
that
first,
if
I
GT
l
does,
which
is
pretty
amazing
it
does
it
compiles
the
queries.
The
graphical
queries
into
JavaScript
functions
in
a
safe
way,
so
what
it
does
is
essentially
just
you
know,
take
your
graphic,
including
validates
it
and
then
compiling
it
down
to
a
really
fast
JavaScript
function
that
then
it's
evaluated
and
executed,
and
we
cast
that
function
so
because
of
that
we
can
save
a
lot
of
the
time
a
lot
of
time
that
is
spent
into
validating
the
query.
B
Yes,
and
no
so
it's
to
some
extent
it's
a
similar,
but
the
problem
is
that
persistent
queries
do
not
do
that
on
the
other,
so
that
the
implementation
of
persistent
we
did
not
do
that.
All
of
this
is
done
at
runtime,
so
essentially
is
cached
within
the
same
process.
So
it
is
slightly
different
technique.
It's
the
same
kind
of
concept,
but
a
different
technique.
So.
A
A
Okay
part:
two
I
think
we
gonna
make
it
to
part
three
yeah
so
part
2.
The
graph
QL
schema,
we're
gonna
update
the
schema
to
create
a
user.
So
we're
not
just
going
to
query
the
users,
we're
gonna
start
creating
users
and
we're
going
to
test
it
with
graphical
or
graphic
QL,
whatever
so
going
to
the
second
part
to
exercise.
So
you
have
to
run
NPM
install
again
run
NPM
run,
watch
again
same
pattern
and
go
to
localhost
3000.
A
D
A
How
she
really
liked
working
with
the
font,
this
big,
so
much
nicer
on
the
eyes
so
in
the
graphic
largess
in
part,
two,
we
still
have
the
user
list.
We've
got
some
to-do
items,
everything
else
I
think
is
the
same.
So
we're
going
to
start
editing
this
file
and
on
the
to-do
list
you
say
we're
going
to
add
a
mutation
type,
the
schema
we're
going
to
add
a
create
using
mutation,
we're
going
to
take
an
aim
parameter
and
we're
going
to
return
a
user
type
from
the
schema.
So
let's
do
that
so
graph.
A
B
One
of
the
key
things
off
of
the
SQL
is
that
you
have
this
type
subject
that
can
return
types
are
the
types
object
and
other
types
object
and
other
objects.
It's.
It
defines
the
relationship
between
things.
Let's
say
that
you
have
a
dog
that
you
have
a
type
dog
and
a
type
person
you
can
say
you
can
create
a
property
on
the
type
person
that
says
da
it
dogs
and
that
returns
the
dogs
for
that
person.
B
Now
these
will
colors
different
resolvers,
so
what
you
can
do
is
you
can
structure
your
code
into
in
a
way
so
that
all
this
all
these
various
concerns
are
separated
and
it
actually
works
pretty
well,
because
you
can
actually
think
about
different
features
on
your
application
and
implement
them
very
quickly.
Based
of
this.
A
A
A
So
obviously
some
of
you
probably
know
this,
but
we're
just
making
sure
that
we're
all
on
the
same
page
as
we
get
to
the
hook
spot
so
to
create
user,
we're
going
to
add
a
mutation
to
the
schema
and
and
to
the
counter
part
of
it
to
the
resolvers
in
our
graph
cure
Jaso
at
the
bottom
of
the
schema.
If
we
add
this
in
here
type
mutation
create
user
name
string
with
an
exclamation
point.
They
call
this
a
non
nullable
type,
okay,
otherwise
known
as
required.
B
D
B
Yes,
these
are
top
level
things,
but
here
now
you
can
make
things
a
little
bit
more
complicated
with
the
nesting
and
objects,
but
you
need
to
have
a
top
level
entry
point.
So
the
only
top
level
entry
points
that
your
application
can
use
our
query
and
mutation.
So
the
rest
is
known
top
level.
So
you
know,
but
I
could.
A
B
One
of
the
key
things
about
graphical
is
that
you
can
always
return
the
current
object,
so
if
you're
actually
create
query
or
mutating
something
in
a
big
tree,
you
can
always
refer
to
the
parent
object
on
that
on
that
chain,
and
that
is
that
underscore.
But
even
that
mutation
is
the
root
object.
We
don't
need
it,
so
we
call
it
underscore,
forget
it,
it's
a
little
bit
functional
style,
putting
it
as
underscore
so
I,
don't
know
if
you're
familiar
with
one
of
those
functional
language
we
put
underscore
when
you
don't.
B
So
you
typically,
you
use
those
objects,
a
lot
when
you
query.
So,
if
you're
feeling
a
big
graph
structure,
you
can
you
want
to
know,
for
example,
which
you
know
if
you
have
a
person
that
has
a
dog
you
want
to
know
when
you're
called
you
writing.
There
are
older
dog.
You
want
to
know
which
person
you
are
asking
the
dog
for
and
that
data
will
be
in
that
parameter.
Make
sense.
Okay,.
A
A
So
if
you
still
got
your
server
running,
go
or
if
you
haven't
you
to
start
it
with
NPM,
run,
watch
logos,
3000
forward,
slash
graphic.
You
are
that
HTML
and
make
sure
remember.
I
said
like
that
little
hidden,
almost
hidden
panel,
where
it's
like
your
variables,
make
sure
you've
got
that
ready
because
we're
going
to
use
that
in
a
second
now
has
everyone
been
able
to
load
the
graphical
graphical
UI
for
part
2,
okay,
I'm,
seeing
yes
as
I'm,
not
seeing
nose.
So
we
shall
proceed.
We.
A
B
D
A
B
E
B
Don't
concatenate
the
string
for
all
sorts
of
problems
like
sequel
injections
and
all
whatever
issue
you
can
imagine
query
variables
are
the
exact
same
thing,
so
you
use
them.
When
you
specify
parameters,
you
don't
concatenate
that
string
into
that
make
sense,
run
it.
Oh
wait.
Let's
run
it.
Oh
probably
I
mean
totally.
B
A
D
A
To
the
resolver:
it's
not
there
not
there
go
to
the
slides,
okay
yeah.
So
if
we
go
back
through
the
slides
for
a
second
go
back,
go
back
up
at
one
Ford
yeah,
you
see
it.
So
we
see
is
pushing
it
to
the
list
user
list
as
an
array
again
just
for
learning
purposes,
and
we
don't
recommended-
and
you
just
draw
an
array
for
your
state
and
in
your
process.
But
we
just
push
it
like
that
mutation
resolver
pools,
create
user,
yes,
and
for.
B
B
D
A
A
A
A
A
Everyone
there
yeah
npm
install'
is
fast
today
in
the
same
folder,
we're
gonna,
you
might
need
to
open
a
new
tab
or
you
might
need
to
control
C
and
then
run
NPM
wrong.
Watch
again.
Have
you
wanna
do
it,
but
we
want
to
do
NPM,
install
graph,
QL
hooks,
so
we're
gonna
bring
this
graph.
Your
hooks
librarian
right
now,
download.
B
B
G
A
D
D
A
D
D
D
B
B
Yes,
because
you
would
like
to
keep
your
sources
and
the
other
that's
a
standard
way
to
actually
encode
a
token
somewhere,
and
then
you
need
can
store
that
token.
Whatever
you
want
or
regenerate
it
refreshing,
it's
really.
It's
a
we're
very
well
done
standard
and
I
would
just
recommend
to
use
that
and
not
random.
A
The
next
part
is
in
the
same
file.
We
want
to
add
that
client
into
the
we
want
to
wrap
a
provider
all
right.
Does
anyone
know
how
react
providers
work,
rec
provider
in
context,
so
react
context,
is
essentially
a
way
to
do.
Sort
of
lateral
state
they're
happened
to
pass
properties
all
the
way
down
through
to
components.
A
G
B
A
A
A
F
A
A
B
A
Good,
all
right
so
also
unless
users,
yes,
we're
gonna,
use
the
youths
query
hook
from
graph
QL
hooks,
so
here
we're
importing
it,
as
my
lovely
assistant,
just
helped
to
display,
and
then
with
this.
This
piece
here
needs
to
be
inside
the
actual
component,
because
you
can
only
use
hooks
inside
of
components
else.
It
doesn't
work,
react.
A
I
mean
there's
this
very
good
reason
for
that,
because
they
actually
use
the
fact
that
you've
used
it
in
the
component
to
actually
track
the
state.
So
that's
why
you
can't
use
it
without
so
the
use
query
hook
returns
an
object
with
a
data
and
a
refetch
key.
The
data
key
is
the
the
data
that
is
fetched
by
the
query
and
we
do
an
assignment
as
we're
destructuring
that
object.
A
A
A
B
Yes
right,
the
key
traffic
evolving
graph
QL
is
I'm
writing
SQL,
applique
based
application
is
that
you
do
not
change
things.
You
just
just
add
more
properties,
more
solvers,
more
types.
You
do
not
remove
anything
in
this
way.
All
clients
can
still
work.
So,
for
example,
if
you
write
a
mobile
app,
you
can
actually
have
used
different
graphic.
B
You
out,
you
can
use
the
same
queries
but
with
different
properties
and
then
your
multiple
versions
of
that
app
being
servers
the
same
graphical
and
point,
even
if
you
have
more
types
and
more
queries
to
support
new
features,
so
you
don't
need
to
it's.
Essentially
it
shows
one
of
the
problems
of
REST
API
that
you
have
those
nice
version
numbers
in
those.
The
REST
API
is
I,
don't
know
if
you
love
them,
but
whatever
I
like
them,
I
like
those
version
numbers,
okay,.
A
So
I've
put
it
into
I'm
in
the
right
place.
Let's
do
this
yeah,
so
I
put
it
into
the
list.
Users
j/s.
Well,
so
we
have
import
you
squared
from
graphical
hooks
at
the
top
and
then
within
our
exported
list
users
function
component.
We
at
the
very
top
of
that.
We
have
this
cool
to
use
query
and
as
we're
just
discussing,
we
pass
in
the
list.
Users
query
constant
into
the
youth
query
hook,
and
so
what's
going
to
happen
is
what
we
need
to
do
some
more
set
up.
A
But
what
what
can
happen
then,
is
that
use
query?
Can
asynchronously
call
the
server
as
I
was
talking
about
earlier
with
the
use,
API
I
concept
concept,
the
initial
state
will
just
be
a
data
with
an
empty
users
array
when
that
query
resolves
it
can
re
render
that
list
users
component
with
that
with
that
state
Mayson.
So
far,
has
everyone
got
this
down?
Yeah
cool.
A
B
A
A
A
E
A
B
A
D
B
A
A
A
So
we
got
this
remember
we
got
this.
Create
user
function
that
we've
destructured
as
from
the
first
element
of
the
user
mutation
hook,
we're
now
gonna
use
that
it
returns
a
promise.
So
we
can
await
the
results
of
that
in
our
create
new
user
function
right
here,
which
is
in
turn
used
in
this
onclick
handler.
So
we
await
the
create
new
user
function,
passing
variables
pass
in
name
which
we're
getting
from
the
use
state
hook
here.
A
Initially,
that's
going
to
be
set
to
nothing,
but
we
can
set
the
name.
The
name
is
set
in
the
the
info
field
here
when
you,
when
you
had
name
so
this
variables,
property
that
you
that
you
passed
to
create
user
an
object
with
the
property
variables.
It's
saying
I
want
to
set
the
variable
of
my
mutation,
which
is
name
right
so
that
that
gets
passed
in
on
the
on
the
server
side,
similar
to
how
we
did
name
Bob
in
the
the
query
variables
panel
that
we
had
to
lift
up
same
thing.
A
D
C
B
So
it
does
not
that
refer.
You
know
that
it's
a
memo.
The
data
is
memorized
automatically.
So
we're
not
referring
the
you
calling
the
graphical
API
and
it's
every
time
we
are
just
calling
it
once
and
then
cased
cast
data,
and
when
you
call
the
fetch,
you
actually
fetch
get
the
data
again.
Otherwise,.
A
C
G
A
Great
questions
guys
loving
it.
That
name
is
the
set
state
function,
which
is
just.
This
is
just
a
normal
reactor
called
you
state.
If
you
know
about
hooks
you'll
be
familiar
with
you
state,
it's
kind
of
a
core
piece:
it
returns
an
array
with
the
the
value
of
the
state
and
then
an
updated
function.
We
call
it
set
name
because
we
can.
A
D
B
B
A
D
A
B
A
A
D
D
D
A
D
C
B
A
Because
it
can
process
Jas
doc,
so
that's
completely
opt-in
and
you
can
just
apply
it
all
to
that
at
anytime.
You
want
to
be
on
that,
like
I,
think
it's
valued,
you
could
use
that
in
that
way,
you
could
use
J
a
stock
with
typescript
to
help
you
with
any
the
graphical
kind
of
typing
or
anything
like
that
works,
but
and
I
like
that,
because
it's
totally
opt-in,
but
if
you're
using
typescript,
then
why
not?
There's.
A
A
Graph,
you
well
as
well
as
I
said:
I,
wouldn't
I,
wouldn't
I
would
use
it
when
I
had
no
other
choice,
because
as
soon
as
you
start
using
it,
you
have
overhead
so
like
when
I'm
green,
fielding
I'd
say:
don't
do
graph
QL
until
you
get
to
this
place,
where
you
kind
of
think.
Okay,
the
complexity
here
is
running
a
little
bow
control.
A
So
now
we
need
to
use
graph
QL
unless
the
project,
your
green
fielding,
is
a
back
end
project
where
with
no
front
end
component,
that
the
organization
is
separated
in
such
a
way
that
the
front
end
team
never
wants
to
interact
with
the
back
end.
There's
no
full
stack
say
there
might
be
a
mobile,
T,
U
and
out.
In
that
case
it
makes
sense
new
graphical
front
start,
because
then
they
can
always
define
exactly
what
they
want.
G
A
E
B
B
B
B
B
B
A
couple
more
things
that
are
interesting
in
this
workshop,
so
I'm
going
through
them
very
quickly.
First
of
all,
it's
you
know
to
be
some
pagination.
How
to
implement
pagination
in
this
is
a
concept
it
needs
to
implement
Avenue
everywhere,
and
you
need
to
drink
reinvent
the
wheel
with
a
graphic
you
out
to
some
extent.
So
you
know
another
way
of
doing
pagination,
so
please
check
it
out.
I'm,
not
going
I'm
going
very
quickly,
so
I'm
just.
B
B
Five
is
caching
again
very
important
by
piece,
unfortunately
draft.
Well,
it
cites
a
poll
or
nice
things
about
HTTP
caching,
so
you
might
want
to
do
some
different
things
for
caching.
You
know
it
hasn't
died.
Some
side
effect,
so
I'm
not
going
to
go
through
that
much,
but
there
is
some
some
caching
and
so
forth,
and
if
you
want
to
go
forward
that
is
server-side
rendering,
which
is
pretty
important
part
if
you're
writing
react,
applications
v.