►
From YouTube: Why You Should Maintain Type Definitions for Your JavaScript Project - Ethan Arrowood, Microsoft
Description
Why You Should Maintain Type Definitions for Your JavaScript Project - Ethan Arrowood, Microsoft
Speakers: Ethan Arrowood
TypeScript support is one of the most sought-after features for any popular open source JavaScript project.
Fastify, a fast and low overhead web framework for Node.js, strives to treat TypeScript developers as first-class citizens even in a library written entirely in JavaScript. Since TypeScript 2.8 the Fastify team has been able to write and maintain our own type definition file shipped directly from Fastify itself. This has enabled our developers to rely on a single dependency and trust what they are using is always up-to-date.
This talk will share some of the lessons we've learned thus far, and it will explore some of the interesting changes we are making in the v3 refactor.
A
Hello,
everybody
we'll
get
started
in
just
a
minute
here,
and
my
name
is
Ethan
Arrowwood
I'm,
a
software
engineer
at
Microsoft
pronouns.
Are
he
his
and
today
my
talk
is
going
to
be
on
why
you
should
maintain
your
type
definitions
for
your
JavaScript
project,
I'll,
be
covering
some
of
the
ways
that
I've
gone
about
it
so
I'll
be
diving
into
some
fun
with
fun
generic
work
that
I
got
to
do
then
I'll
talk
about
some
of
the
ways
that
you
can
support
your
custom
type
definitions
so
to
get
started.
A
The
project
and
the
context
for
this
talk
is
vasa
phi,
I'm
a
maintainer.
I
mainly
focus
on
the
types
crap
typescript
set
of
things,
but
fafsa
phi,
as
you,
some
of
you
know,
is
a
part
of
the
open,
J's
foundation
and
we
really
want
to
work
to
offer
the
best
developer
and
user
experience
on
all
facets.
A
Fasta
file,
like
I
said,
is
open
source
and
it's
entirely
written
in
JavaScript.
As
you
can
see,
it's
97.3%
exactly
and
the
JavaScript
chunk
of
this
is
the
same
JavaScript
that
you'll
run
when
you
consume
FAFSA
Phi.
It
is
not
compiled.
It's
not
built
the
es6
code
that
we
run
that
we
write
is
shipped
directly
to
you
when
you
download
our
package.
A
This
is
a
little
bit
of
what
it
looks
like
this
is
the
JavaScript
use
of
pacifies.
So
it's
a
lot
like
Express,
if
anyone's
familiar
with
that,
you
instantiate
the
server
to
find
some
routes
and
then
kick
it
off
and
though
my
talk
today
is
not
about
JavaScript,
but
about
typescript
and
fast,
and
here
at
fafsa
phi.
We
love
typescript,
even
though
it's
not
written
in
typescript,
and
this
is
because
we
see
the
natural
progression
of
projects
now
open
source
projects
nowadays
need
to
support
both
sides.
A
A
Yeah
no
worries
so,
while
we,
while
we
wait
who,
in
this
room,
writes
typescript
already
all
right
sweet
so
who
here
is
interested
in
writing
typescript
awesome
and
has
anyone
ever
written
their
own
typescript
definition
file
before
alright,
so
I
see
some
like
shaky
hands?
Okay,
should
I
read:
do
it?
Okay,
all
right!
No
worries
we'll
get
right
back
into
it.
A
Awesome
all
right
so
we'll
resume
from
here.
The
FAFSA
fee
definition
file,
I
just
asked
a
question
who
here's
a
written
one
by
hand
before
and
I
saw
a
couple
hands,
some
like
shaky
hands,
and
that's
because
normally
this
file
is
exported
when
you
run
the
types
of
compiler,
but
when
you're
writing
JavaScript
code,
you
don't
get
that
luxury.
So
you
have
to
write
it
yourself
in
the
recent
three-point-something
update,
they
actually
did
add
the
ability
to
export
type
definitions
from
J
stock,
but
that
happened
like
really
recently
and
I.
A
Don't
know
a
whole
lot
about
it,
so
so
we'll
kind
of
just
skip
over
that
detail,
but
just
know
that
typescript
is
working
hard
to
provide
this
kind
of
type
support.
Even
if
your
code
is
in
JavaScript
but
anyways.
When
you
write
a
definition
file,
you
need
to
ship
this
to
your
users,
so
it
needs
to
live
somewhere
either
in
a
repository
or
somewhere
else.
One
of
the
examples
of
a
somewhere
else
is
something
you
may
be
familiar
with
definitively
types.
A
This
is
that
classic
app
types
organization
that
you
might
npm
installing
from
and
definitely
typed
is
a
good
project,
except
it
has
a
big
flaw
that
turns
me
away
from
it
when
an
api
or
a
library
or
module
is
being
developed.
It's
not
necessarily
going
to
also
get
it's
definitely.
Typed
updates-
and
many
of
you
have
may
may
have
seen
this
when
a
brand
new
update,
especially
a
major
update,
comes
out
for
a
library
and
the
maintainer
x'
aren't
maintaining
that
definitely
typed
part
of
the
package.
A
Those
types
are
usually
out
of
date
and
the
type
script
users
get
left
behind.
But
if
you
ship
your
types
with
your
repo
within
your
actual
export,
then
you
can
sort
of
control
how
those
get
updated
and
also
be
have
more
safe
of
mind
that
you'll
be
shipping
valid
types
with
every
either
minor
or
major
release.
So
that's
what
we
do
at
FASTA
Phi,
we
ship
our
type
definitions
alongside
the
JavaScript
and
as
I
said
before.
A
We,
when
you
download
fafsa
file,
you're
getting
the
handwritten
JavaScript
code,
you're,
also
getting
the
handwritten
typescript
code
and
today
we're
gonna
dive
into
this
function.
At
the
bottom
of
the
screenshot,
it's
the
only
real
export
from
FAFSA
Phi
is
this
factory
function
and
this
function
definition
in
typescript
starts
out
a
little
little
bit
big,
but
we'll
break
it
down.
First,
there
is
an
options,
object
that
you
pass
in,
and
the
function
returns
a
FAFSA
Phi
instance,
but
it
also
has
this
big
block
of
generics.
A
Anyone
that
has
ever
done
a
strictly
typed
language
before
will
know
what
these
are
and
I
love
generics
I
didn't
use
to.
It
can
tell
you
that
much,
but
after
spending
a
lot
of
time
with
them,
they
are
really
powerful
and
there's
two
patterns
that
I
want
to
highlight
today,
and
that
is
generic
constraints
and
generic
defaults.
I,
don't
know
if
these
similar
things
are
in
other
strictly
typed
languages,
but
they
are
in
typescript.
A
So,
let's
break
this
down
this
first
line
here.
Raw
server
extends
Ross
over
base
equals
Ross
server
default.
This
is
actually
implementing
both
of
those
patterns
that
I
just
said,
constraining
and
defaulting.
The
constraint
here
is
raw
server
extends
raw
server
base.
Raw
server
base
is
a
list
of
types
in
this
case.
It's
HD
HTTP
sn2
server
types
that
are
given
from
nodejs.
A
You
can,
though,
enable
some
things
like
HTTP
in
HTTP
two,
and
the
reason
why
this
is
important
is
the
request
and
reply,
and
other
properties
will
differ
when
you
define
a
different
server
type.
So
in
this
line
the
raw
request.
We
have
that
similar
pattern
where
it's
extending
something
and
it's
equaling.
Something
except
this
is
something
now
is
an
expression.
As
you
can
see
by
this
blown
up
code,
it
is
a
ternary
expression
and
we're
checking
the
raw
server
type
again
and
we're
determining
what
the
request
definition
should
be.
A
Should
it
be
an
HDPE
incoming
message
or
an
HTTP
to
server
request
method,
and
this
is
that
power
of
generics
that
I'm
trying
to
highlight
in
typescript
is
by
just
defining
the
server
type.
We
can
infer
the
remainder
of
your
types
and,
if
you
see
back
on
this
definition
for
the
function,
we're
really
almost
abusing
this
raw
server
generic
we're,
passing
it
down
to
almost
everything,
because
at
the
core
we're
building
an
API
server
or
back-end
server.
So
that's
really
important
and
when
you
get
to
start
looking
at
some
code,
a
default
FAFSA,
Phi
server.
A
Is
this
simple?
We
don't
have
to
actually
pass
anything
if
you're
just
doing
with
HTTP
it
with
HTTP
and
if
you're
doing
HTTP.
All
you
have
to
do
is
pass
in
that
type
from
node
from
the
node
core
and
turn
on
the
HTTP
to
flag
in
the
FASTA
fiop
shion's,
which
I
want
to
go
down
more
because
the
inference
doesn't
stop
at
the
generic
level.
When
you
define
a
type.
This
is
the
FAFSA
Phi
server
options
type
within
the
property
itself.
You
can
use
these
expressions
to
determine
what
it
should
be
in
this
case.
A
We're
saying
is,
it
should
be
true,
or
should
it
be
false?
Now
in
FASTA
phi,
the
hb2
option
actually
needs
to
be
specified
if
you
are
using
an
h,
mq
server,
but
because
I
couldn't
how
to
make
the
HPG
property
optional
or
not
optional,
on
sort
of
a
like
expression
based
way
at
least
we
can
enforce.
The
user
is
passing
the
right,
boolean
type
to
this
property.
A
So
that's
that
for
the
sort
of
like
generic,
constraining
and
defaulting
that
is
available
on
the
FAFSA
Phi
server
part,
but
I
want
to
dive
into
one
more
fast
generic
example
here
and
we're
gonna.
Take
a
look
at
this
code,
jump
down
to
the
to
the
bottom
of
the
the
code
bite
you'll,
see
it's
server,
dot
get
and
I'm
passing
in
four
generic
properties.
Three
of
them
are
defaults,
one
of
them
is
custom.
A
Also,
one
of
them
is
the
body
and
we're
defining
a
get
route.
Why
would
I
ever
need
to
specify
the
body
of
a
get
request,
and
this
is
something
I
realized
after
building
the
type
system
that
maybe
there's
a
way
to
do
this
better
and
in
fact
there
is
named
generic
parameters
in
the
JavaScript
world.
If
you
ever
defined
a
function
that
has
like
eight
arguments
to
it.
Sometimes
it's
better
to
put
those
all
into
one
object
and
give
them
names.
A
You
can
do
the
exact
same
thing
in
typescript
with
generics,
you
can
make
a
singular
generic
object
with
named
properties
and
then
pass
in
your
types
or
interfaces
to
those
properties.
This
way,
when
you're
defining
a
route
that
has
some
sort
of
generic
property,
like
the
custom
query
string,
all
you
have
to
do
is
specify
the
query
string.
You
don't
have
to
specify
the
body,
the
params
or
any
custom
headers,
if
they're
not
being
modified.
A
So
those
are
the
three
generic
advanced
patterns
that
were
really
making
use
of
and
the
FAFSA
fight
type
system,
but
now
we're
gonna
switch
gears
into
how
we
can
support
a
custom
type
definition
system
and
everyone's
favorite
software
engineering
topic
is
testing
and
we
don't
worry,
we'll
get
to
your
second-favorite
when
documentation
just
a
bit.
There
is
this
library
called
TST.
It
was
originally
shipped
by
definitely
typed,
but
they
have
since
deprecated
their
version
of
it
and
a
new
author
Sam
has
created
this
API
and
it
is
wonderful.
A
It's
hasn't
it's
not
even
in
version
one
yet,
but
it
is
one
of
my
favorite
parts
about
doing
custom
types.
Is
you
can
now
write
assertion
like
tests
for
your
type
definitions,
so
you
can
actually
expect
a
type
to
be
returned
from
some
call
to
your
API
in
this
case,
we're
going
back
to
the
HTTP
server
example
we're
by
calling
the
default
classify.
We
expect
instance
with
these
types.
A
Similarly,
if
we
pass
in
that
HTTP
to
server
type,
we
expect
it
to
be
an
HTTP
to
server
and
at
the
bottom
line
you
can
see
the
expect
error
line.
If
you
set
that
property
that
also
had
that
expression
inside
it
to
false,
this
will
error
out
and
we
can
test
our
Lodge.
We
can
test
our
type
definition,
logic
and
I.
Think
that's
incredible,
because
testing
is
very
important
even
for
type
definitions,
and
this
is
something
I
didn't
consider
before
and
not
a
lot.
A
A
A
great
type
system
is,
is
fun
and
all
you
have
to
write
Docs,
but
the
best
way
to
learn
at
least
the
fafsa
fight
type
system
is
by
example,
and
I
think
the
best
thing
you
can
do
for
your
users
is
define
as
many
examples
as
possible
for
your
type
system
or
or-
and
I
should
say
you
should
include
a
detailed
api
guide.
It
doesn't
have
to
be
identical
to
the
guide
that
you
already
have
for
your
api,
but
rather
the
type
definitions
themselves
think
about
all
the
generic
properties
you
have.
A
You
should
tell
your
user
what
they
should
be
and
how
they,
how
they're
going
to
be
used
references
the
source
code
are
really
important,
especially
in
typescript
realm
I,
find
myself
by
find
myself
often
inspecting
the
source
types
and
being
like.
Okay
can
I
see
what
this
should
look
like.
What
is
it
expecting?
Maybe
if
you
have
really
good
API
guides,
you
might
not
have
to
provide
that,
but
it's
so
good
to
show
hey.
This
is
where
you
can
find
the
source.
A
And
so,
if
you're,
using
the
types
and
you
find
an
error,
it's
best
to
open
an
issue
or
even
better
yet
submit
a
PR
and
making
that
an
easy
process
by
saying,
hey,
find
something
wrong,
come
here
and
contribute,
it's
gonna
help
them
a
lot,
instead
of
them
having
to
dig
around
here
github
to
try
and
find
out
where
the
repository
is
or
how
to
open
up
a
valid
issue.
If
you're
interested
in
seeing
how
the
docs
are
coming
along,
I'm,
actually
actively
working
on
them
right
now,
there's
a
PR
open
on
our
FAFSA
file.
A
Repository
I
have
a
couple
examples
up
and
I'm
still
working
a
lot
on
trying
to
make
this
as
perfect
as
possible.
The
type
system
that
I've
defined
is
not
available,
yet
it's
it's
gonna,
be
in
the
next
branch
and
which
will
be
released
as
version
3
in
2020,
but
it's
there
and
you
can
poke
around
it.
A
That
can
that's
a
lot
of
effort,
but
I
find
for
me
it's
important
because
of
like
the
community
and
its
entirety.
Typescript
is
growing
that
there's
no
doubt
about
it.
So
if
you
want
to
support
this
growing
mass
of
developers,
taking
the
time
to
define
a
strong
type
system,
can
really
help
get
your
library
or
module
from
you
know
something
small
to
something
way
larger
than
it
has
been.
So
with
that
I
say.
Thank
you
for
coming
to
my
talk.