►
From YouTube: GraphQL Custom Error Details with extensions
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
Yes,
so
to
this
presentation
is
about
the
merge
request.
I
did
lately
about
this
three
distinguished
Italy
error
when
it's
unavailable
or
and
I
took
it
actually
to
see
whatever
guitar
layers
there
is
and
we
will
be
able
to
see
what
is
actually
going
on
since
it
was
a
quick,
quick
win
and
it
will
specifically
be
more
about
more
about
graphql
custom
errors
with
the
extensions
since
not
the
whole
team
has
a
lot
of
graphql
experience.
B
I
thought,
maybe
that
would
be
interesting
for
the
most
for
most
people,
so
the
main
problem
was
yeah.
I
think
this
one
shows
it
the
best.
The
main
problem
was
that
when
Italy
was
actually
like
unavailable,
we
had
a
graphical
query
that
was
feeling
when
you
were
on
that
page,
just
so
just
the
main
project
page,
and
so
it's
failed
like
that
with
our
hair
error
500s
and
it
was
difficult
for
the
front-ended
parts
and
stuff
like
that.
B
So
what
so?
Yeah
since
it's
a
graphql
query
I
had
the
whole
thought
process
that
brought
me
to
actually
using
custom
graphql
errors.
B
And
I'm
gonna
explain
to
you
why
what's
what's
that
process
and
why
you
should,
when
you
use
graphql
it's
better
to
use
custom
errors
instead
of
putting
everything
in
the
message
in
the
in
the
message
or
error
message
or
instead
of
outputting
a
HTTP
error
code.
B
So
why
not
use
the
HTTP
error
codes
is
because
graphql
doesn't
always
work
with
HTTP.
It's
actually
transport
diagnostic,
so
you
could
in
theoretically
Implement
graphql
with
grpc.
That
would
be
done,
but
why
not
you
could
you
could
actually
like
the
the
implementation
layer
is
actually
doesn't
matter
to
graphql?
B
All
you
need
is
the
query
field
and
the
variable
field,
if
you
can
put
a
query
field
in
a
variable
field,
it's
enough
for
graphql
to
to
be
implemented
actually,
and
the
second
reason
why
you
should
not
use
HTTP
error
code
is
because
in
graphql
Salvation
is
individual.
It
means
every
resolver.
So
it's
it's.
Actually
each
field
that
we
see
here
in
graphql
has
a
resolver
and
name
also
has
a
resolver.
Heights
also
has
a
resolver
and
each
of
these
resolver
Works
actually
independently.
B
So
if
it's
a
reversity
hero,
the
hero
is
over,
it
generates
data.
Then
then,
out
of
this
data,
the
name
resolver
is
gonna.
The
name
resolver
is
gonna.
Work
on
the
data
that
was
generated
by
the
error
is
over
and
so
on
and
so
on.
So
what
might
happen
is
that
hero
passed.
It
had
no
problem
to
to
Output
the
data,
but
just
height
might
be
wrong.
You
know
so,
and
here
you
have
like
an
example
of
that.
That's
and
we
asked
for
a
hero,
called
jar
jar
and
we
asked
for
a
Jedi
called
Luke.
B
B
So,
just
in
those
case
where
you
can
actually
like
get
a
look
but
not
jar
jar,
it's
just
stupid
to
do
a
404,
not
stupid,
but
it's
not
appropriate
to
do
a
404,
because
maybe
just
this
height
field
would
fail-
and
this
might
happen
in
in
graphql-
and
just
this
height
Field
height
field
would
would
output
an
error.
I
cast
an
error
and
it
would
be
here
so
that's
why
here
you
have
an
example
of
the
wrong
way.
B
B
It
was
distinguished
from
all
the
other
errors,
so
the
first,
the
first
goal
of
the
ticket
was
was
let's
say
accomplished,
but
it
was
not
appropriate
for
everything.
It
didn't
give
the
whole
context,
and
it
was
not
appropriate
for
everything
that
was
happening,
and
here
is
the
right
way
so
yeah.
So
here
you
can
see
like.
If
you
look
closely
sorry
I
need
to
move
that
thing
around.
If
you
look
closely
like
you
can
see
that
project
could
be
fetched,
you
could
also
fetch
the
idea
of
the
project.
This
was
no
problem
you
could
be.
B
You
could
face
the
represent
the
repository
in
the
repository
and
its
type
name,
but
you
could
not
fetch
the
paginated
tree,
so
only
this
resolver
actually
failed
fails
when
Italy
is
unavailable.
So
in.
If
you
look
at
the
error
that
we
looking
at
the
error
details,
you
can
see,
the
message
is
just
standard.
You
can
see
the
path
of
the
error
which
tells
you
which
field
is
actually
failed
for
that
particular
error.
And
then
you
can
see
here
the
extensions
so
just
use
you
can
see
the
code
so
what
actually
happened.
B
Message,
Fields
in
the
error
object,
so
just
the
first
field
that
you
see
here,
which
would
like
kind
of
it's
the
standard
way
of
working
with
like
it's
the
naive
way
of
working
when
you
work
with
graphql.
It's
just
do
a
simple
message:
build
and
go
on
with
it,
but
the
problem
is
that
error.
Fields
can
be
generated
from
from
a
little
bit
of
every
everywhere
and
it's
usually
human,
readable
errors,
and
it's
not
meant
for
the
front
end
or
for
any
clients
to
be
parsed
easily.
B
Usually,
if
you
do
it
like
from
the
Inception
of
your
project
of
as
a
convention
that
you
say
like
in
the
message
field,
we're
only
gonna
put
error
codes,
it's
okay,
but
if
it's
not
the
case,
and
sometimes
it's
error
codes.
Sometimes
it's
not
like
in
those
two
examples
here,
it's
an
error
code.
You
could
do
that
then
here
it's
not
it's
better
to
just
use,
graphql
custom
errors
and
just
have
your
human,
readable
error.
B
So
people
can
understand
like
what's
going
on
and
having
your
your
error
codes
actually
in
the
extensions,
and
you
can
even
add
extra
stuff
like
the
status
of
the
error.
If
you
want
like
the
the
fields,
the
the
field
extension
is
actually
not
not
hard-coded
or
something
like
that,
our
hearts
types,
let's
say
so,
you
can
put
whatever
you
want
in
this
hash.
As
long
as
you
have
a
code,
which
is
the
only
convention
that
exists
for
for
that
extension,
then
it's
okay,
it's
okay!
You
can
do
whatever
you
want.
B
After
it
you
can
put
status.
You
can
put
error
details.
You
can
put
the
the
stack
Trace,
whatever
you
want
in
into
the
extensions.
How
to
implement
it.
You
can
see
here
is
actually
pretty
easy.
You
can
put
your
error
message
first
here
and
then,
with
with
the
hash
argument,
the
extensions
and
then
whatever
you
want
like
as
a
code,
then
you
can
add
some
stuff
here
as
well
and
yeah.
That's
it.
B
There
is
maybe
another
topic,
but
it's
another
topic
that
was
related
to
the
issues
or
the
grpc
errors,
but
I
will
post
it
for
you
guys.
So
you
can
see
like
because
I
didn't
know,
grpc
had
actually
statuses
and
every
bad
status
is.
If
you
and
every
battle
stat
every
bad
status
is
actually
has
a
status
quo,
then
you
can
see
actually
what's
going
on
in
in
the
in
the
server
in
the
grpc
server.
So
I
thought
this
was
interesting,
but
this
is
not
related
to
graphql
and
that's
it
for
me.
A
So,
first
of
all,
fantastic
presentation,
really
impressive,
I
learned
at
least
two
things,
one
of
which
was
I,
didn't
also
know
that
grpc
had
fixed
status
codes
and
when
they
send
us
the
status
code,
is
it
like
HTTP?
They
also
send
a
text
message.
Let
me
just
send
a
code.
B
I
mean
no
not
from
what
I've
seen
in
our
client
at
least
I.
Don't
know
how
it
works
in
the
in
the
back
end,
but
in
our
client
at
least
all
you
get
is
the
number.
So
then
you
have
to
check
into
the
the
the
page
that
I
showed
you
what
the
number
corresponds
to.
B
But
it
might
be
just
an
implementation
thing
and
I
actually
did
the
reverse.
I
put
all
the
from
the
number
I
I
put
the
message
into
the
into
the
graphql
error
into
the
error
of
Italy,
so
we
don't
have
to
look
it
up
and
every
time
we
have
those
type
of
errors.
B
A
Okay,
so
it's
more
of
a
comment.
Actually,
it
seems
like
this
is
great
information.
We've
got
here
and
I
really
I
can
see.
You
put
a
lot
of
effort
into
this
presentation.
Thank
you
very
much.
Would
it
be
worth
adding
this
to
the
for
some
version
of
this
to
the
graphql
page
in
into
the
git
lab
growth?
You
know
developer
page.
B
D
B
Yeah,
we'll
I
will
then
make
an
an
issue
and
then
I
will
contact
you.
So
you
can.
You
can
tell
me
where
this,
where
I
can
find
this
mysterious
people.
E
They
are
not
so
mysterious.
There
is
like
a
Channel
about
around
like
graphql
in
select,
so
you
can
join
that
and
I
believe
there's
even
like
a
handle
like
something
like
graphql,
like
experts,
or
something
like
that
in
GitHub.
So,
for
example,
if
you
wanna
suggest
adding
these
deck
extensions
to
all
of
the
errors
as
an
option,
you
can
ping
this
handle
and
like
people
who
added
themselves
to
this
list,
will
reply
to
you
so
I
think
it's
the
normal
usual
way
how
they
interact
about
some
changes:
okay,
okay,
nice.
C
Actually,
it's
a
nice
sketch
yeah
how
I
usually
try
to
find
an
expert
in
particular
field:
I,
open,
Team,
page
and
and
then
common
death
graphql
and
then
some
people,
yeah
I,
may
find
some
people
and.
B
C
D
D
No,
it's
a
shame
that
I
think
we
suggested
to
add
it
to
the
team
page,
but
the
that
wasn't
picked
up
on.
So
it
was
a
bit
of
shame
because
that
could
have
been
closed
and
actually
okay.