►
From YouTube: Static Site Editor GraphQL Overview
Description
Enrique gives us an overview of the GraphQL implementation of the Static Site Editor
B
A
Okay,
so
back
to
Italy
epic,
so
we
have
this
epic
work.
We
are
detailing
the
plan
that
we
are
going
to
follow
in
the
common
medicines
to
to
fully
adult
crack
you
on
the
circulator.
This
is
a
summary
right
now
we
don't
have
the
kid
lab
rat
here
API.
It
doesn't
provide
a
lot
of
features
that
we
need
to
implement
a
starry
separator
in
detail
when
we
are
submitting
changes
in
the
later.
A
A
They,
the
graph
to
your
API,
only
provides
functionality
to
to
create
a
branch,
but
we
cannot
create
a
community
or
create
a
mesh
request,
but
at
the
same
time
we
didn't
want
to
wait
until
all
of
those
API
are
implemented
in
the
in
the
backend.
So
we
saw
the
opportunity
of
adopting
the
power
client
early
in
the
in
the
client
because
we
can
create
wrappers
for
the
REST
API
that
we
are
using
and
in
that
way
the
transition
in
the
future
150
Isis
already
will
be
easier.
A
A
The
idea
is
that
we
can
we
can.
We
could
just
take
some
underlying
services
like
for
submitting
changes
and
creating
wrappers
in
viewport,
so
after
the
TV
Apollo,
what
we're
gonna
do
is
just
take
those
risk
wrappers
and
we
were
not
replacing
with
actual
a
gradual
api's.
So
we
are
working
well
according
to
work
working
on
creating
those
implementing
those
actual
api's
in
the
work
area
we
are.
When
are
we
replacing
them
in
parallel
in
the
injector.
A
A
So
when
we
implemented
the
first
iteration
the
the
empathy
for
the
service
elevator,
we
created
services
that
would
contain
all
of
the
implementation
for
submitting
a
change,
but
they
were
completely
separated
from
the
from
the
view
X
action.
So
we
clear
at
least
these
services.
There
is
us
of
the
content
changes
and
it's
making
a
lot
of
AP
at
the
first
API
calls
here
and
we
are
using
this
API
service.
A
A
That
is
going
to
take
more
time
and
here's
the
reason
so
I'm
going
to
the
to
a
main
component
and
a
main
page
here.
So
right
now,
we
are
just
like,
assuming
that
we
have
Oliver
API
available
to
submit
changes.
Here
we
are
passing
the
mutate,
the
mutation
with
the
data,
but
here
in
the
service
we
are
using
the
develop
your
API,
but
now
once
we
get
the
actual
graph,
you
grab
your
IP
from
the
back
end.
We
are
gonna
have
to
replace
this
service
computer,
which
is
a
you
know,
significantly
more
complex.
A
B
C
So
is
it
safe
Winston
sui
we
move
forward
and
we
add
more
functionality
where
we
find
a
graph
QL
endpoint
doesn't
exist.
Is
it
because
R
is
our
strategy
going
forward
even
once
we
have
kind
of
like
the
initial
graph
Kelly
integration.
Walden
is
a
strategy
going
forward
to
rather
consume
the
rest,
endpoint
and
and
then
up
to
updated,
while
once
the
graph
kill
endpoint
is
available,
or
should
we
try
and
have
to
graph
kill
any
points
available
ahead
of
time
for
us,
I.
A
Think
that
it
depends
on
the
cost
right,
but
what
we've
decided
that
we
are
following
right
now
in
the
study
site
later
is
that
we
are
relying
on
on
api's
that
represent
primitive
operations.
So
we
are
not
implementing
parking.
Api
is
that
that
are
like
creating
a
specific
operation
for
later,
like
submitting
a
change
or
maybe
parsing
a
markdown
document.
What
we
are
doing
is
creating
basic
operations
like
committing
a
change,
creating
a
massive
waste
and
then
in
the
client
we
can
combine
all
of
those
operations.
A
A
A
A
A
This
is
something
that
I
think
that
we
are
not
even
doing
in
indeed
lab
in
other
applications
that
are
using
graphene
gitlab.
We
are
using
put
the
Apollo
client
to
serve
the
local
estate
in
industry,
say
Theater,
so
there
is
data
that
is
not
available
in
the
integral
fuel
API
or
the
REST
API
that
we
are
receiving
directly
from
our
custom
controllers
in
the
backend.
A
We
are
defining
that
information
in
a
Kusum
up
data
type.
For
example.
The
data
is
coming
like
the
future
new
rail
from
the
8th
or
that
dice
sorry,
the
returnee
real
that
there
is
used
to
go
back
to
the
page
that
the
user
is
18
or
the
determining
if
they
contain
that
the
user
was
with
it
is
supported.
A
lot
of
data
is
coming
directly
from
the
from
the
from
the
from
our
custom
controller
in
the
background,
and
we
are
using
the
SQL
to
store
that
information
and
the
way
that
we
are
doing.
A
Even
directly
in
the
cache-
and
we
are
passing
like
custom
data
types
that
we
are
creating
in
the
client,
so
in
that
way
they
the
idea
is
that
there
is.
There
are
some
advantages.
The
main
advantage
of
using
Buicks
is
that
it
provides
like
a
single
source
of
truth
to
a
store
beta,
that
is
on
the
rich
client
that
is
only
available
for
every
client
side,
and
then
we
also
implementing
storing
data
that
is
coming
from
the
server.
A
They
did
not
grab
your
API,
but
at
the
same
time,
like
this
part
of
the
of
the
domain
of
the
domain
of
the
domain
of
the
same
type
Aitor
we
are
having
like
we
are
creating
an
operation.
We
have
to
return
them
where
Seaquest
they
commit
on
the
branch.
So
we
are
defining
all
of
those
types
and
then
you
were
just
like
returning
that
type
of
data.
Here
we
are
just
creating
like
like
using
client-side
the
client-side
features
of
the
paulo
client
to
store
data
to
some
domain
data,
use
it
directly
in
the
application
here.
A
A
I'm,
basically
we're
saying
hey:
if
this
query
is
asking
for
the
safe
contain
made
up
of
safe
content,
meta
object,
it
doesn't
have
to
go
to
a
server
because
that's
data
that
is
defined
within
the
client,
so
return
like
go
to
a
to
a
to
a
catch,
then
get
that
data.
But
it's
just
like
that
across
some
data
type
that
we
implemented
in
the
client.
C
A
Right
with
a
we
added
with
an
added
benefit
that
we
are
just,
we
are
not
like
limited
to
the
type,
a
schema
that
is
defining
the
server.
We
can
even
define
our
custom
types,
and
that
makes
our
core
our
code
more
organized
because
we
are
using
the
actual
metal
structures
that
we
need
to
implement
application.
So.
C
Hypothetically,
for
instance,
when
we
want
to
get
to
the
point
where
we
storing
a
user's
edited
state,
saying
local
storage
for
them.
If
they
come
back
that
they
can
receive
it
at
boot,
boot
time,
we'll
probably
fetch
that
data
from
local
source
and
then
attitude
to
the
Pala
providers
cache
so
that
and
then
just
query
it
from
from
the
Pala
client
cache.
That's.
A
That's
a
very
interesting
question
because
we
could
even
go
and
say:
hey:
we
can
implement
a
custom
resolver,
make
a
query
and
say:
I,
don't
know
local
storage,
storage
data
and
client
and
then
the
Apollo
client
will
be
a
smart
enough
to
know
that
we've
defined
a
custom
function
that
is
in
charge
of
interpreting
this
field
and
will
fetch
the
data
from
you
know.
We
can
implement
this
function
with
access
to
a
local
storage.
So
it's
gonna
be
like
a
facade
on
top
of
any
type
of
of
storage
that
we
are
trying
to
access.
Okay,.
C
A
A
A
Good
well
I
want
I
want
to
give
you
a
algorithm
of
the
of
a
Apollo
dev
tools,
but
idea
is
that,
when
your
reason
that
the
Apollo
dev
tools,
the
only
way
in
which
the
the
client
sorry
the
dev
tool
can
access
they,
the
type
they
look
out,
they
local
data
type
scheme
is
bypassing
this
type
definition.
But
right
now,
when
I
I
think
that
we
are
having
a
bug
in
our
Apollo
client
library,
like
we
have
with
very
sly,
boring.
Let's
go
there.
A
So
we
create
utility
to
initialize
the
Apollo
client
in
application,
so
we
have
like
a
consistent
way
of
doing
it
and
we
are
passing
type
definitions,
but
what
this
type
definition
is
expecting
here
is
a
string.
Norah
know
whatever
is
what
is
generating
based
on
this
data
type
definition.
So
right
now
we
cannot
use
they
dev
tools
to
to
inspect
and
look
local
data,
but
that's
something
that
we
have
to
do.
B
A
A
So
I'm
going
to
go
like
let's
see
like
from
this
point,
that
they,
the
most
high-level
part
of
the
query,
left.
That's
in
fact
how
that
query
is
resolved
in
the
in
the
client.
So
the
source
content
query
is
imported,
and
is
he
fine
in
one
of
the
equation,
the
graph
QL
directory?
So
here
is-
and
this
word
is
very
interesting,
because
the
fruit
field
of
the
query
is
a
is
a
project.
The
project.
A
The
projectile
and
this
a
query
that
we
are
making
directly
to
the
to
a
server.
So
when
we
are
saying
hey
graffia,
give
me
a
project
object
that
has
a
full
path
like
say:
get
lab
or
dot
here,
org
slash,
get
lab
graph.
Ql
is
going
to
wake
to
a
set
to
a
server
fetching
that
actual
project,
and
then
we're
saying
hey,
give
me
the
the
full
path
attribute.
But
then,
when
the
Apollo
client
sees
I'm,
saying
hey,
give
me
a
file
within
that
project.
A
With
this
first
pass,
we
are
not
providing
that
field
as
part
of
our
back-end
API,
so
we
have
to
implement
a
custom
provider
so
at
the
point
that
they
Apollo
client
reaches
this
path.
This
part,
what
it's
gonna,
do
you
say:
hey
we're
in
the
break
data
type.
Do
we
have
a
custom
function
that
is
in
charge
of
interpreting
that
specific
attribute,
and
then
we
are
passing
for
that
activity
default
resolver
and
what
the
file
resolver
is
doing.
B
A
A
So,
okay,
so
we
will
get
this
object
and
then
we
get
the
parameters,
the
search
path,
parameter
that
is
defined.
During
this
query.
We
use
this
service
again
and
the
inner
part
where
we
take
a
shortcut.
We
implemented
this
service
in
the
in
the
previous
iteration.
They
note
source
content
and
if
we
go
here,
you'll
see
that
we're
just
using
they
get
profile.
Rest
api,
we're
passing
parameters.
We
are
using
every
X
to
remove
the
to
extract
with
title
from
the
from
matter.
A
We're
gonna
do
a
much
better
job
on
this
iteration
and
then
we
are
just
like
taking
that
object
editor
by
the
rest
service,
and
we
are
returning
an
object.
We
are
type
metadata
where
we
always
have
when
we
are
like
a
soaring
look
data
in
the
in
the
Apollo
catch
in
the
public
I'll
plan
catch,
we
always
have
to
refined
I
specify
which
the
type
helix
and
then
we're
just
you
know,
expanding
this
object
and
passing
the
actual
data.
A
Yeah
I
think
that
was
like.
That
was
not
the
reason
that
we
could
speed
up
the
the
replacement
of
of
uux,
also
like
also
we
had
they.
They
really
great
opportunity
that
we
were
not
implementing
new
features
that
require
more
data
fetching,
and
we
were
just
focusing
on
implementing
that
we
see
with
ater.
So
since
we
like,
we
could
work
on
this
in
a
you
know,
isolated
way,
it
was
very
easy
to
replace
to
replace
us.
A
So
when
they
I
could
say
that
the
biggest
advantage
of
the
of
these
dev
tools,
so
we
can
come
here
and
we
can
explore
the
entire
eat
lab
rock
your
API
by
default.
The
if
dev
tools
will
identify
that
we
are
connected
to
that
to
that
endpoint,
and
then
we
can
start
like
exploring
the
legacy
or
API.
So
that
was
very
helpful
when
I
first
started
working
on
this.