►
From YouTube: Let's REST with NestJS - Kerren Ortlepp
Description
NestJS is a progressive Node framework written in Typescript. It's opinionated and has a tonne of features out of the box. I'm going to run through the pros and cons of using this framework over others that exist in the Node ecosystem and give a couple of real-world examples where we've found it useful in our business... And where we've found it to hinder our progress and introduce complexity.
It plugs in perfectly with Angular and follows a very similar structure in terms of the modular approach and dependency injection. I'll run through how we can share models between our backend and frontend projects (and the potential dangers around that) as well as how we wrap this all into Docker containers and ship it off to production.
If you're looking for a scalable Node framework for future projects or just trying to find how people bring up full stack applications in a couple of hours, this is a talk you don't want to miss!
This talk was recorded at the Jozi.JS meetup group on 20 June 2019.
https://www.meetup.com/Jozi-JS/events/261100011/
Disclaimer: The opinions in this talk are those of the individual and do not necessarily represent those of this channel, the meetup group, or its sponsors.
A
How's
that
everyone
today
I'm
going
to
be
speaking
about
Ness
chess,
which
is
a
node
framework,
that's
taking
off,
and
so
this
presentation.
The
goal
of
my
presentation
today
is
just
to
enter
you
to
what
Ness
chairs
is
I'm,
going
to
give
you
a
taste
of
kind
of
what
it
is,
how
to
use
it
and
then
I'm
going
to
show
you
a
couple
of
the
features
that
it
already
offers.
A
As
you
kick
off
and
start
using
it
and
then
finally,
I'm
gonna
run
through
a
couple
of
real-world
problems
that
we
face,
because
a
lot
of
the
time
when
we
look
at
a
tool
or
a
framework.
We
look
at
this
cool
thing
and
we
tell
tell
everyone
how
cool
it
is
and
everything
good
about
it.
But
we
never
speak
about
the
bad,
so
I'm
going
to
speak
about
a
couple
of
the
bad
things
that
we've
hit
when
using
it,
but
just
a
disclaimer.
A
None
of
the
bad
things
that
we've
hit
have
made
us
want
to
move
away
from
the
framework.
So
it
is
a
brilliant
framework
and
that's
why
I'm
going
to
be
speaking
about
it
today.
So
github
isn't
the
only
way
to
kind
of
see
how
a
framework
or
a
tool
is
taking
off,
but
it
is
definitely
one
way
to
check
it
out.
A
So
what
I
did
was
I
took
a
couple
of
well-known
frameworks
of
different
languages
and
a
couple
of
node
frameworks
as
well,
and
just
put
them
all
up,
so
you
can
see
there
the
top
three
lines:
that's
laravel,
which
is
PHP
rails,
which
is
Ruby
and
Express,
which
is
note,
and
then
I
took
a
couple
of
other
node
frameworks
that
are
relatively
well-known.
That's
happy,
Jas
foster
fire
and
sales
and
what
you
can
see
on
the
bottom
right
is
this
little
blue
line
and
that's
nest.
A
Yes,
and
it's
exponentially
taking
off,
so
you
can
see
that
there's
actually
quite
a
lot
of
growth
in
nest.
Yes
and
a
lot
of
people
are
interested
in
it
and
want
to
start
using
it,
and
if
we
look
at
kind
of
the
ages
of
these
different
frameworks,
you
can
see
that
laravel,
Ruby
and
Express
are
all
over
eight
years
old,
so
they
mature
frameworks
have
been
around
for
a
really
long
time.
A
If
we
look
at
nest,
you
can
see
that
it's
actually
just
over
two
years
old,
it's
already
overtaken
happy,
which
is
happy,
is
been
around
for
quite
a
while,
and
it's
catching
up
to
sales
and
sales
is
one
of
the
noid
frameworks
that
I
think
is
relatively
well-known.
It's
it's
wraps
up
a
lot
of
libraries
together
and
just
as
a
side
thought.
A
What
I
kind
of
described
as
a
framework
is
something
that
takes
a
number
packages,
puts
them
all
together
in
one
place
and
makes
them
all
speak
together
without
you
having
to
do
all
of
the
the
linkage
and
the
glue.
So
that's
kind
of
what
we're
what
we're
calling
a
framework-
and
you
can
see
that
nest
is
a
really
young
framework,
but
it's
getting
a
lot
of
starts.
So
that's
why
I'm
speaking
about
it
today,
there's
a
huge
amount
of
support
for
it
and
it's
been
pushed
by
pretty
big
names.
A
So
how
do
you
get
started
with
this
whole
thing?
So
they
have
a
sale
I
where
you
can
just
install
the
CLI
on
your
computer
and
you
create
your
new
project
and
it
automatically
installs
all
of
your
dependencies.
You
CD
into
it,
and
you
start
it
up
and
that's
it.
You've
already
got
and
a
REST
API
started
and
if
you
hit
the
root
end
point
you
get
hello
world.
A
So
it's
a
really
simple
thing
to
get
started
with,
and
now
what
I'm
gonna
do
is
just
run
you
through
kind
of
the
features
that
it
has
and
why
we
find
a
lot
of
value
with
that.
So
just
to
give
you
a
bit
of
context,
we're
a
startup
company,
we're
nine
people
and
we
have
to
move
really
quickly
because
we
service
small
and
medium
sized
businesses.
A
So
these
are
guys
that
want
to
test
a
kind
of
a
concept
out
and
see
if
it
works,
and
if
it
does
work,
then
they
want
to
move
quickly
on
it
and
if
that,
if
it
doesn't
work,
they
want
to
throw
it
away.
That's
the
first
thing.
The
second
thing
is
that
with
the
small
and
medium
business
once
they
have
proven
that
a
prototype
works,
they
often
don't
want
to
throw
that
away
and
start
over.
So
you
kind
of
have
to
build
it
right
from
the
start.
A
A
So,
for
example,
a
lot
of
hackers
in
the
room
and
stuff
would
probably
say
that
they
use
like
sublime
or
ver
more
something
as
their
editor
to
code
in
because
it's
like
it's
super
fast
and
all
of
that
stuff.
From
our
perspective,
we
say
we'll
rather
use
an
IDE
like
webstorm,
because
we'll
pick
up
a
lot
more
issues
beforehand
and
so
we'll
we
won't
be
pushing
problems
up
into
production.
That
way,
so
that's
kind
of
the
thought
process.
A
That
goes
through
our
mind
when
we
look
at
frameworks
and
that
products
and
stuff
to
use
so
one
of
the
things,
one
of
the
huge
benefits
that
we
see
in
in
Ness
chess,
which
I
think
is
a
controversial
topic-
and
some
of
you
guys
might
disagree-
is
that
it's
fully
written
in
typescript.
So
basically,
what
taps
script
is.
Is
it's
a
it's,
a
language
that
compiles
down
to
JavaScript,
and
that
means
that
we
can
already
compile
and
pick
up
compilation
errors
number
one
and
number
two.
A
It
introduces
a
lot
of
the
new
kind
of
JavaScript
protocols
and
java
scripts
I
can't
think
of
the
word,
but
it
basically
just
introduces
new
stuff
that
hasn't
gotten
into
JavaScript
yet,
but
it's
kind
of
it's
gonna
come
soon
so,
for
example,
decorators,
which
kind
of
which
make
your
code
a
lot
easier
to
read.
So
we
use
a
lot
of
that
and
we
use
async,
which
makes
your
code
your
node
code.
Look
a
sync
sequential,
not
asynchronous.
So
it
looks
like
it's
sequential
and
it's
easy
to
read.
A
But
actually
there
are
a
lot
of
things
going
on
in
the
background
and
stuff
like
that,
and
we
don't
have
all
these
callbacks
and
finally,
because
typescript
can
actually
just
run
JavaScript
code.
We
have
access
to
all
of
the
NPM
packages,
so
it's
not
lucky
as
done
it's
not
removing
functionality
from
using
node,
it's
actually
just
building.
On
top
of
that
another
thing
and
a
huge
strength
that
we
see
on
typescript,
is
it
almost
forces
you
to
tap
your
your
code
and
make
sure
that
you
know
what
objects
are
going
into
a
function.
A
You
know
what
to
expect
coming
in,
and
so
some
people
might
say
you
know,
use
you
can
use
node
and
you
can
use
yes
lint
and
you
can
kind
of
do
that
anyway,
which
is
cool
and
you
can.
But
in
this
case
it's
it
kind
of
forces
you
to
do
it.
So
there's
a
lot
of
strength
in
that,
because
then
everyone
coding
has
to
do
it.
A
So
it's
nice
to
kind
of
just
put
down
these
ground
rules
that
everyone
has
to
follow
so
that
so
that's
just
typescript
in
general,
when
you
go
into
this
project,
you're
going
to
see
a
lot
of
TS
files
and
the
first
three
TS
files
you're
going
to
see
is
app
service,
TS,
app,
app
controller,
TS
and
app
module
TS.
I'm
going
to
give
you
a
taste
of
what
the
code
kind
of
looks
like
this
code
on
the
screen.
Here
is
a
service
you
can
see
at
the
top
there's
a
decorator
that
says
at
injectable.
A
What
that
does
is
it
makes
this
piece
of
this
service
injectable
into
other
services
and
controllers
and
I'm
going
to
get
into
the
strength
of
injectable
stuff
in
a
moment.
But
basically
you
can
see
that
the
the
main
concept
from
this
is
that
injectable
above
the
class.
The
next
file
that
you
would
click
on
is
the
controller,
and
this
is
what
a
controller
looks
like
you
have
add
controller
as
your
decorator
and
inside
there
you
can
see
the
string
uses.
A
What
that
means
is
that
it's
now
created
the
rest,
endpoint
slash
users
and
in
the
function
below
you
can
see
an
at
get.
That
now
means
that
if
you
call
get
on
the
users
endpoint,
that's
going
to
call
this
function
and
it's
going
to
return
whatever
that
function
returns.
So
literally,
you
can
make
a
controller
put
in
your
endpoints
and
you
can
put
an
add
gate
function
and
you've
made
a
new
REST
API
endpoint.
It's
that
simple.
A
What
you
can
also
see
in
this-
and
this
is
the
important
part-
is
that
there's
this
private
read-only
service
user
service
in
the
constructor-
that's
the
injection,
so
you
don't
actually
create
the
user
service.
In
this
controller
it
gets
injected
into
the
controller
and
I'm
gonna
still
I'm
gonna.
Get
to
that
the
strength
of
that
in
a
moment.
The
final
thing
that
you're
going
to
see
is
a
module.
A
So
if
we
look
at
authentication,
they've
created
a
wrapper
around
passport,
which
means
that
you've
got
JWT,
authentication,
token
bear
authentication
and
a
number
of
other
things,
so
it
already
makes
it
really
easy
for
you
to
create
authentication
and
lock
down
your
API.
The
second
thing
is,
with
the
database,
the
use
an
RM
called
top
RM.
You
don't
have
to
use
top
RM,
you
can
use
whatever
you
want.
You
can
use
sequel,
oz
or
a
number
of
other
ones,
but
top
row.
A
M
is
the
one
that
they've
made
a
wrapper
for
so
it
makes
it
really
easy
to
create
entities
and
models
around
your
database
and
just
create
new
databases
and
everything
as
soon
as
you
need
them
so
for
rapid
development.
It's
it's
really
amazing
and
then
for
web
sockets
their
base
web
socket
platform
is
socket.
Io
again,
you
can
swap
that
out
with
whatever
you
want,
but
the
base
one
that
they've
created
a
wrap
around
a
socket
IO
they've
got
graph,
QL
support
and
their
documentation,
and
this
is
a
really
cool.
A
One
is
they've
created
a
number
of
decorators
that
you
can
decorate
your
functions
in
your
controller
with,
so
you
write
your
documentation
and
your
code
in
the
same
place,
and
you
can
create
your
examples
and
everything
and
when
someone
hits
that
Doc's
end
point
they
get
presented
with
swagger
Doc's
of
your
whole
API.
So
it
makes
it
really
cool
and
easy
to
make
documentation
for
a
fully
open
API.
So
that's
something
that
I
haven't
really
seen
in
a
number
of
other
places.
A
lot
of
the
time
you
have
to
comment
above
your
code
and
everything.
A
This
is
all
decorated
code
and
it's
a
live
API
documentation
that
someone
hits
on
the
browser
and
then
another
thing
that
they
offer
is
validation.
So
when
you're
using
frameworks,
you
often
see
that
when
traffic
comes
in,
you
create
a
validator
and
you
say:
okay,
cool.
This
email
must
be
a
string
and
it
must
exist
and
all
of
that
stuff,
they've
kind
of
broken
that
out
into
they've
abstracted
it
a
bit
more.
A
So
you
create
these
classes
and
you
specify
your
validation
in
the
classes
and
in
your
controllers,
you
just
expect
that
class
to
arrive
and
when
the
data
comes
in,
it
creates
the
class
and
it
validates
and
everything
automatically
and
it
returns
errors
automatically.
So
your
controllers
are
actually
quite
small,
they
don't
have
the
validators
in
them
and
it
makes
it
really
readable.
It's
it's.
A
It
makes
your
code
look
really
really
good,
and
when
you
go
into
those
classes,
you
can
see
the
kind
of
validation
that
takes
place
so
they've
done
really
well
with
that
sort
of
stuff,
and
the
final
thing
which
we
haven't
really
had
to
focus
on.
A
lot
is
macro
service
support.
So,
in
this
case,
you
don't
have
to
always
use
an
HTTP
protocol
to
communicate
between
two
different
services.
A
What
macro
services
does
is
it
allows
you
to
use
different
transport
layers,
so
what
what
you
can
now
do
is
send
commands
and
events
and
all
of
that
stuff
between
different
modules.
So
they
have
macro
service
support
and
currently
just
out
of
the
box,
you
can
do
Redis,
RabbitMQ,
mqtt
and
basically
a
number
of
other
things
that
are
published,
subscribe
or
event
based
paradigms.
A
So
they've
really
thought
about
not
only
the
HTTP
side
of
things
but
the
rest
of
your
your
system
and
how
you're
going
to
break
it
out
and
make
everything
a
module
okay,
so
those
are
kind
of
the
plugins
that
you
get,
and
on
top
of
that,
you
also
get
the
internal
functionality
that
Ness
provides.
So
the
three
things
that
I
would
talk
about
is
pipes
number
one.
A
If
you
want-
and
it
can
also
validate
that
data
for
you
and
throw
an
exception
if
it's
not
correct
so
number,
one
you're
making
sure
that
the
data
coming
is
in
is
consistent
and
number
two
you're
able
to
modify
it
as
much
as
you
want.
You
can
take
it
further
than
just
piping
one
little
piece
of
a
body.
You
can
pipe
the
whole
body
into
a
class
and
it
will
automatically
get
rid
of
all
the
keys
that
shouldn't
be
there.
A
It
will
automatically
make
sure
that
that
class
is
valid
and
will
make
sure
that
the
data
is
there,
so
you
can
check
stuff.
Like
is
this
ID
number
of
this
person,
a
legit
South
African
ID
number
is
the
cell
phone
number
that's
coming
in
an
actual
cell
phone
number
and
a
number
of
other
things.
The
other
thing
that
I
would
mention
is
gods,
so
you
can
do
orth
gods.
You
can
do
role-based
gods,
you
can
make
any
kind
of
god
that
you
want.
A
That
means
that
you
can
lock
down
your
APR,
not
only
using
authentication,
but
you
can
also
say
only
admin
users
can
go
here
or
any
people
that
have
permission
for
this
view
can
go
here.
So
there's
a
lot
of
stuff
that
their
offer
out
of
the
box
that
allows
you
to
really
control
what
people
have
access
to
and
lock
down
that
your
API
and
the
final
thing
is
interceptors,
and
this
one.
This
concept
is
really
cool.
A
What
you
can
do
is
intercept
incoming
traffic
and
outgoing
traffic,
and
you
can
just
modify
that
data
or
trigger
events
from
that
data.
So
an
example
would
be
that
you
log
every
incoming
event,
but
that's
kind
of
slightly
boring
another
one
that
you
could
do
is
maybe
you're
working
on
a
new
feature.
You
bring
that
feature
up,
and
you
just
want
to
make
sure
that
if
there's
ever
an
error
that
happens,
you
get
notified
immediately.
Just
while
this
new
features
up
and
running.
A
So
what
you
do
is
you
intercept
the
outgoing
traffic
and,
if
there's
ever
an
error,
you
trigger
a
slack
notification
to
yourself,
and
now
you
get
these
instant
notifications.
So
there
are
a
lot
of
things
that
you
can
do
with
Nestor,
and
this
is
literally
just
touching
the
surface
of
the
stuff
that
they
offer
out
of
the
box.
For
this
framework.
Another
thing
that
I
had
mentioned
before
was
top
om,
which
is
the
RM
that
lets
you
kind
of
create
your
data
based
models
and
all
of
that
stuff,
and
this
is
what
it
looks
like.
A
So,
basically
all
you
do,
is
you
put
an
entity
decorator
above
it
and
you
specify
what
the
table
name
is
and
then
you
can
put
in
all
of
your
columns,
and
this
is
it
now
when
you
NPM
start,
and
you
start
up
your
whole
application,
it'll
create
your
entities
on
the
database
and
can
let
you
start
querying
them
and
using
them
straightaway.
So
it's
so
easy
to
start
up
an
application
and
just
get
going
and
a
lot
of
applications
do
need
a
database
not,
and
a
lot
of
them
aren't
has
got
that
complicated.
A
They
just
need
a
three
or
four
entities,
so
it's
really
simple
to
get
get
going
with
that.
Another
strength
that
a
lot
of
people
mention
and
ok
so
before
I
before
I
mention
this.
How
many
of
you
guys
are
react
developers
like
react
framework
only
ok
and
angular
developers?
Ok,
ok!
Well,
that's!
Actually,
better!
Okay!
A
So
with
the
react
developers,
don't
let
this
put
you
off,
because
it's
not
something
that
it
would
hinder
your
your
progress
or
anything,
but
Nest
has
been
designed
around
the
the
processes
and
design
paradigms
that
angular
has
been
designed
by
around.
So
if
you're,
an
angular
developer,
you'll
probably
be
able
to
read
this
and
understand
all
of
the
concepts,
the
modules,
the
providers
and
all
of
that
stuff
straight
away,
because
it's
very
similar
to
angular
it's
it's
quite
cool,
because
what
they,
what
they've
done,
is
because
I
followed
their
paradigm.
A
A
lot
of
people
that
are
big
names
with
angular
are
pushing
nest
as
a
back-end
framework
as
well,
but
that's
the
disclaimer.
It
doesn't
mean
that
you
have
to
be
an
angular
developer
to
use
Ness
and
you
don't
have
to
use
angular
if
you
using
net.
So
if
you
are
reactive
elephant,
you
can
still
use
nest,
you
don't
have
to
worry,
and
so
sir
I
was
supposed
to
go
to
that.
Let
me
go
back
to
that.
So
one
of
the
other
things
that
I'd
mentioned
before
was
injection.
A
You
guys
saw
that
we
were
injecting
a
service
sensor
controller
and
when
you
do
testing,
you
often
want
to
mock
out
your
service.
What
these
guys
have
done
in
nest
is
they've
allowed
you
to
create
these
test
modules,
where
you
can
replace
services
with
mark
services,
so
you
can
kind
of
say,
cool
this
HTTP
service.
That
would
make
a
request
out
I'm
going
to
mock
out
that
request
and
I'm
going
to
return
a
failed
response
or
whatever
you
want.
So
it
makes
testing
a
lot
easier
with
this
dependency
injection.
A
So,
there's
a
lot
of
strength
in
the
way
that
this
system
has
been
designed
and
the
other
strengths
in
it
is
with
the
modularity
that
I
mentioned
before
you
can
literally
make
a
tiny
module
of
like
an
S
module
that
you
can
copy
and
paste
into
different
projects
and
stuff
and
reuse.
So
it
really
does
help
to
make
sure
that
you've,
structured
your
project
rights
and
that
you
can
reuse
what
you've
done
in
a
previous
project
in
your
new
one
and
as
you
keep
doing,
that
your
development
gets
faster
and
faster
and
faster.
A
So
the
real-world
problems,
I've
told
you
all
the
good.
Well,
not
all
the
good,
a
little
bit
of
the
good,
but
let's
just
chat
a
little
bit
about
the
the
bad
that
we've
hit
before
so
number
one.
When
you
start
up
this
project,
you
get
presented
with
the
source
file
and
it's
up
to
you
to
decide
how
you
want
to
structure
your
application.
That's
a
pro
no
con
for
assets
a
pro,
because
we
get
to
decide
how
we
want
to
structure
modules.
A
So
it's
always
good
to
kind
of
decide
what
that
process
and
protocol
is
going
to
be
before
you
start,
and
then
that
will
be
the
definition
from
that
point
on
another
problem
that
we've
kind
of
experienced
is
queue,
support
and
creating
your
own
CLI
that,
because
nest
is
in
typescript
and
typescript
lets,
you
use
any
NPM
package.
You
can
make
you
can
use
pretty
much
any
queue
and
you
can
use
any
CLI
platform.
You
want
the
problem
with.
A
That
is
that
again,
you
have
to
then
go
and
implement
the
queue,
queuing
logic
and
all
the
CLI
logic.
It
would
be
cool
if
you
could
just
install
a
package
that
would
give
you
kind
of
a
skeleton
and
you
just
fill
in
the
blanks
and
and
that's
that
you've
now
got
your
queue
system
and
you've
got
your
CLR
system
and
they
have
been
working
on
that,
for
example,
they
already
is
a
queue
plug-in
that
that
is
getting
quite
popular
with
the
CLI.
I
haven't
really
seen
much
of
that.
A
A
But
it's
flippin
annoying
is
circular
dependency,
so
you
have
two
modules:
module:
a
with
service:
a
module
B
with
service
B
and
C
so
service
a
uses
service,
B
service,
B,
uses
service,
C
and
service
C
uses
service
a
that's
your
circular
dependency.
So
when
your
module
starts
up,
it
takes
over,
send
it
says:
cool
you're
trying
to
inject
service
B,
so
it
tries
to
inject
service
B.
So
this
B
says
cool
you're,
trying
to
inject
service
C
or
tries
to
inject
service
C.
A
So
the
C
says
you're
trying
to
inject
service
a
and
now
we've
got
this
endless
loop.
So
that
doesn't
always
that
is
solvable,
because
what
you
do
is
you
kind
of
do
this
hack
thing?
Where
you
tell
nest,
it's
chilled,
create
the
service.
I'm
gonna
give
you
that
thing
that
you
need
later
down
the
line
and
you
use
forward
ref
on
that.
The
problem
with
that
is
that
it
does
kind
of
make
your
code
less
readable
and
you
can
avoid
it
by
putting
proper
design
principles
into
all
of
your
modules.
A
But
what
we've
experienced
is
you're
moving
so
quickly
when
you're
designing
things
and
you're
implementing
things.
You
often
don't
know
when
two
services
are
going
to
need
and
stuff
like
that
from
different
modules,
and
when
you
get
to
that
point,
it's
too
late.
Well,
it's
not
too
late,
but
you
need
to
do
some
refactoring
and
if
your
time
is
not
there,
you
can't
do
that.
A
Is
the
resources
like
for
a
lot
of
the
other
frameworks
that
you
use
out
there.
You
can
just
go
on
udemy.
You
can
search
for
that
framework
and
there
plenty
of
videos
that
you
can
watch
to
to
get
up
to
scratch
with
it.
Nest
is
quite
new,
so
the
community
hasn't
really
made
a
lot
of
resources,
yet
they
were
working
on
it.
I
think
an
s-video
or
udemy
course
just
came
out
like
last
week,
so
getting
there
and
I
think
everyone
is
contributing,
but
we
still
need
like
a
lot
of
support
and
community
involved.
A
So
that's
basically
it
thank
you
very
much.
If
you
guys
are
looking
to
get
into
nest
or
start
using
it.
All
you
have
to
do
is
go
to
the
docs
page
read
through
it,
you'll
see
so
much
functionality
and
stuff
like
that.
It
might
be
a
bit
overwhelming,
but
it's
also
very
refreshing
because
it
means
that
you
can
quickly
get
up
a
project
and
it
can
be
a
full
full
system
that
can
be
quite
complicated
and
it's
fully
scalable,
it's
reliable.
A
You
can
break
it
out
and
it
works
extremely
well
with
containerization
like
docker,
kubernetes
and
all
of
that
stuff,
because
it's
not--and,
like
a
node
docker
file,
is
pretty
simple
to
set
up
so
yeah.
It's
just
definitely
something
that
I
would
encourage
everyone
to
look
into
if
you're
ever
looking
at
using
node
as
your
your
framework,
and
you
want
to
start
working
on
a
back-end
API.
This
is
the
thing
to
look
at
cool
thanks.