Nest is a progressive framework for building server-side applications and APIs with Node.js. It leverages TypeScript and a powerful CLI to ship reliable apps quickly https://fireship.io/tags/nest/

#js #webdev #100SecondsOfCode

This video is NOT sponsored

🔗 Resources

Nest on Github https://github.com/nestjs/nest
Nest Docs https://docs.nestjs.com/

 🤓 Install the quiz app

iOS https://itunes.apple.com/us/app/fireship/id1462592372?mt=8
Android https://play.google.com/store/apps/details?id=io.fireship.quizapp

🔥 Watch more with Fireship PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font
2024-02-04T05:47:43.259Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
e1c16174-7530-413d-93fe-d8a6396609fe
4d600775ced11bd1d3b402edc414278af8e76106b8e3fd3b5aa7052ea0b1ce74
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
Nestjs is a Node.
Js framework for building scalable server side applications with TypeScript.
It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code.
It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation.
Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command.
That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code.
In the source directory, you'll notice a controller which is a fundamental building block of the framework.
It's responsible for handling incoming HTTP requests and returning responses back to the client.
To implement a controller, simply add the controller Xdecorator to a class.
Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera.
By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters.
In addition, Nest provides other decorators to control things like the status code and headers.
Then in the method itself, parameter decorators can be used to access the request parameters or body.
And finally, the return value from the method is the response body that gets sent back down to the client.
Xant.
What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity.
But there's more to Nest than just controllers.
A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed.
Any class with the injectable decorator can be injected in the constructor of another class.
For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller.
And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments.
This has been nestjs in 100 seconds.
If you wanna see more short videos like this, make sure to hit the like button and subscribe.
Thanks for watching and I will see you in the next one.

Speaker 0: Nestjs is a Node. Js framework for building scalable server side applications with TypeScript. It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code. It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation. Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command.

That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code. In the source directory, you'll notice a controller which is a fundamental building block of the framework. It's responsible for handling incoming HTTP requests and returning responses back to the client. To implement a controller, simply add the controller Xdecorator to a class. Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera.

By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters. In addition, Nest provides other decorators to control things like the status code and headers. Then in the method itself, parameter decorators can be used to access the request parameters or body. And finally, the return value from the method is the response body that gets sent back down to the client. Xant.

What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity. But there's more to Nest than just controllers. A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed. Any class with the injectable decorator can be injected in the constructor of another class. For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller.

And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments. This has been nestjs in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
Nestjs is a Node. Js framework for building scalable server side applications with TypeScript. It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code. It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation. Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command. That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code. In the source directory, you'll notice a controller which is a fundamental building block of the framework.
databases
programming
It's responsible for handling incoming HTTP requests and returning responses back to the client. To implement a controller, simply add the controller Xdecorator to a class. Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera. By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters. In addition, Nest provides other decorators to control things like the status code and headers. Then in the method itself, parameter decorators can be used to access the request parameters or body.
And finally, the return value from the method is the response body that gets sent back down to the client. Xant. What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity. But there's more to Nest than just controllers.
programming
A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed. Any class with the injectable decorator can be injected in the constructor of another class. For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller.
And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments. This has been nestjs in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and subscribe.
programming
Thanks for watching and I will see you in the next one.
Nestjs is a Node. Js framework for building scalable server side applications with TypeScript. It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code. It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation. Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command. That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code. In the source directory, you'll notice a controller which is a fundamental building block of the framework. It's responsible for handling incoming HTTP requests and returning responses back to the client. To implement a controller, simply add the controller Xdecorator to a class. Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera. By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters. In addition, Nest provides other decorators to control things like the status code and headers. Then in the method itself, parameter decorators can be used to access the request parameters or body. And finally, the return value from the method is the response body that gets sent back down to the client. Xant. What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity. But there's more to Nest than just controllers. A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed. Any class with the injectable decorator can be injected in the constructor of another class. For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller. And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments. This has been nestjs in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
Nestjs
nestjs
is
is
a
a
Node.
node
Js
js
framework
framework
for
for
building
building
scalable
scalable
server
server
side
side
applications
applications
with
with
TypeScript.
typescript
It
it
provides
provides
a
a
suite
suite
of
of
tools
tools
that
that
leverage
leverage
either
either
Fastify
fastify
or
or
Express
express
to
to
facilitate
facilitate
rapid
rapid
development
development
and
and
predictable
predictable
readable
readable
code.
code
It
it
supports
supports
REST
rest
and
and
GraphQL
graphql
APIs
apis
out
out
of
of
the
the
box,
box
or
or
you
you
might
might
use
use
it
it
to
to
build
build
a
a
full
full
stack
stack
application
application
using
using
the
the
model
model
view
view
controller
controller
pattern,
pattern
similar
similar
to
to
frameworks
frameworks
like
like
Laravel
laravel
or
or
Ruby
ruby
on
on
Rails
rails
and
and
it
it
contains
contains
a
a
ton
ton
of
of
built
built
in
in
modules
modules
to
to
work
work
with
with
databases,
databases
handle
handle
security,
security
implement
implement
streaming,
streaming
and
and
anything
anything
else
else
you
you
can
can
imagine
imagine
doing
doing
in
in
a
a
server
server
side
side
Acation.
acation
Nest
nest
has
has
its
its
own
own
very
very
powerful
powerful
command
command
line
line
tool,
tool
and
and
you
you
can
can
scaffold
scaffold
out
out
a
a
new
new
project
project
with
with
the
the
nest
nest
new
new
command.
command
That
that
provides
provides
a
a
code
code
base
base
preconfigured
preconfigured
with
with
Jest
jest
for
for
testing
testing
and
and
set
set
up
up
with
with
TypeScript
typescript
to
to
help
help
us
us
write
write
more
more
readable
readable
and
and
reliable
reliable
code.
code
In
in
the
the
source
source
directory,
directory
you'll
you'll
notice
notice
a
a
controller
controller
which
which
is
is
a
a
fundamental
fundamental
building
building
block
block
of
of
the
the
framework.
framework
It's
it's
responsible
responsible
for
for
handling
handling
incoming
incoming
HTTP
http
requests
requests
and
and
returning
returning
responses
responses
back
back
to
to
the
the
client.
client
To
to
implement
implement
a
a
controller,
controller
simply
simply
add
add
the
the
controller
controller
Xdecorator
xdecorator
to
to
a
a
class.
class
Then
then
inside
inside
the
the
class,
class
you
you
can
can
implement
implement
methods
methods
and
and
decorate
decorate
them
them
with
with
HTTP
http
verbs
verbs
like
like
get,
get
post,
post
patch,
patch
put,
put
etcetera.
etcetera
By
by
default,
default
this
this
will
will
create
create
an
an
HTTP
http
endpoint
endpoint
on
on
the
the
root
root
URL,
url
but
but
you
you
can
can
pass
pass
a
a
string
string
to
to
the
the
decorator
decorator
to
to
change
change
the
the
route
route
or
or
implement
implement
dynamic
dynamic
route
route
parameters.
parameters
In
in
addition,
addition
Nest
nest
provides
provides
other
other
decorators
decorators
to
to
control
control
things
things
like
like
the
the
status
status
code
code
and
and
headers.
headers
Then
then
in
in
the
the
method
method
itself,
itself
parameter
parameter
decorators
decorators
can
can
be
be
used
used
to
to
access
access
the
the
request
request
parameters
parameters
or
or
body.
body
And
and
finally,
finally
the
the
return
return
value
value
from
from
the
the
method
method
is
is
the
the
response
response
body
body
that
that
gets
gets
sent
sent
back
back
down
down
to
to
the
the
client.
client
Xant.
xant
What's
what's
awesome
awesome
about
about
Nest
nest
is
is
that
that
you
you
can
can
use
use
the
the
CLI
cli
to
to
automatically
automatically
generate
generate
more
more
controllers
controllers
to
to
keep
keep
your
your
code
code
organized
organized
as
as
it
it
grows
grows
in
in
complexity.
complexity
But
but
there's
there's
more
more
to
to
Nest
nest
than
than
just
just
controllers.
controllers
A
a
provider
provider
is
is
a
a
class
class
that
that
contains
contains
shared
shared
logic
logic
throughout
throughout
the
the
entire
entire
application
application
and
and
can
can
be
be
injected
injected
as
as
a
a
dependency
dependency
where
where
needed.
needed
Any
any
class
class
with
with
the
the
injectable
injectable
decorator
decorator
can
can
be
be
injected
injected
in
in
the
the
constructor
constructor
of
of
another
another
class.
class
For
for
example,
example
a
a
provider
provider
can
can
be
be
implemented
implemented
as
as
a
a
guard
guard
Xrd
xrd
to
to
handle
handle
role
role
based
based
user
user
authentication,
authentication
or
or
it
it
might
might
be
be
implemented
implemented
as
as
a
a
pipe
pipe
to
to
efficiently
efficiently
validate
validate
and
and
transform
transform
values
values
in
in
a
a
controller.
controller
And
and
lastly,
lastly
we
we
have
have
the
the
module
module
decorator,
decorator
which
which
allows
allows
code
code
to
to
be
be
organized
organized
into
into
smaller
smaller
chunks
chunks
where
where
it
it
can
can
be
be
lazy
lazy
loaded
loaded
to
to
run
run
faster
faster
in
in
serverless
serverless
environments.
environments
This
this
has
has
been
been
nestjs
nestjs
in
in
100
100
seconds.
seconds
If
if
you
you
wanna
wanna
see
see
more
more
short
short
videos
videos
like
like
this,
this
make
make
sure
sure
to
to
hit
hit
the
the
like
like
button
button
and
and
subscribe.
subscribe
Thanks
thanks
for
for
watching
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
In this video, the host discusses Nestjs, a framework for building scalable server side applications that supports various types of APIs and command line tools. The host also explains how to use the command line tool and implement decorators for the code, including a command line tool and a pipeline decorator. Finally, the host mentions that Nestjs is designed for creating smaller chunks for faster codeloading and encourages viewers to subscribe to their channel for more short videos.
NestJS in 100 Seconds
Nestjs is a Node. Js framework for building scalable server side applications with TypeScript. It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code. It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation. Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command. That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code. In the source directory, you'll notice a controller which is a fundamental building block of the framework. It's responsible for handling incoming HTTP requests and returning responses back to the client. To implement a controller, simply add the controller Xdecorator to a class. Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera. By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters. In addition, Nest provides other decorators to control things like the status code and headers. Then in the method itself, parameter decorators can be used to access the request parameters or body. And finally, the return value from the method is the response body that gets sent back down to the client. Xant. What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity. But there's more to Nest than just controllers. A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed. Any class with the injectable decorator can be injected in the constructor of another class. For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller. And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments. This has been nestjs in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
In this video, the host discusses Nestjs, a framework for building scalable server side applications that supports various types of APIs and command line tools. The host also explains how to use the command line tool and implement decorators for the code, including a command line tool and a pipeline decorator. Finally, the host mentions that Nestjs is designed for creating smaller chunks for faster codeloading and encourages viewers to subscribe to their channel for more short videos.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : NestJS in 100 Seconds 
        and a small summary : In this video, the host discusses Nestjs, a framework for building scalable server side applications that supports various types of APIs and command line tools. The host also explains how to use the command line tool and implement decorators for the code, including a command line tool and a pipeline decorator. Finally, the host mentions that Nestjs is designed for creating smaller chunks for faster codeloading and encourages viewers to subscribe to their channel for more short videos.
        [/INST]
        
        Generate the video : Nestjs is a Node. Js framework for building scalable server side applications with TypeScript. It provides a suite of tools that leverage either Fastify or Express to facilitate rapid development and predictable readable code. It supports REST and GraphQL APIs out of the box, or you might use it to build a full stack application using the model view controller pattern, similar to frameworks like Laravel or Ruby on Rails and it contains a ton of built in modules to work with databases, handle security, implement streaming, and anything else you can imagine doing in a server side Acation. Nest has its own very powerful command line tool, and you can scaffold out a new project with the nest new command. That provides a code base preconfigured with Jest for testing and set up with TypeScript to help us write more readable and reliable code. In the source directory, you'll notice a controller which is a fundamental building block of the framework. It's responsible for handling incoming HTTP requests and returning responses back to the client. To implement a controller, simply add the controller Xdecorator to a class. Then inside the class, you can implement methods and decorate them with HTTP verbs like get, post, patch, put, etcetera. By default, this will create an HTTP endpoint on the root URL, but you can pass a string to the decorator to change the route or implement dynamic route parameters. In addition, Nest provides other decorators to control things like the status code and headers. Then in the method itself, parameter decorators can be used to access the request parameters or body. And finally, the return value from the method is the response body that gets sent back down to the client. Xant. What's awesome about Nest is that you can use the CLI to automatically generate more controllers to keep your code organized as it grows in complexity. But there's more to Nest than just controllers. A provider is a class that contains shared logic throughout the entire application and can be injected as a dependency where needed. Any class with the injectable decorator can be injected in the constructor of another class. For example, a provider can be implemented as a guard Xrd to handle role based user authentication, or it might be implemented as a pipe to efficiently validate and transform values in a controller. And lastly, we have the module decorator, which allows code to be organized into smaller chunks where it can be lazy loaded to run faster in serverless environments. This has been nestjs in 100 seconds. If you wanna see more short videos like this, make sure to hit the like button and subscribe. Thanks for watching and I will see you in the next one.
        