All language subtitles for [English (auto-generated)] Complete MERN Beginner Course (TypeScript, Authentication, Deployment...) [DownSub.com]

mobile development is for children all

the cool people are doing web

development so in this free course we

will learn how to build a moon app from

scratch Merin stands for mongodb Express

react and node and those four together

make a very popular text deck to build

full stack web applications full stack

means that we are building both the

front end which is the part that you see

on the screen in your web browser and

the back end which is the server that

your website communicates with and the

server on the other hand has a

connection to the database and so on but

we will learn the details of this

throughout this course we will also be

using typescript in this course instead

of vanilla JavaScript typescript is a

superset of JavaScript so it's basically

a like a layer on top of it you can use

it anywhere you can use normal

JavaScript but it adds strong typing to

the language because if you build a

medium size or a larger project in pure

JavaScript than you are a lunatic

because a normal JavaScript you don't

have types and you can basically put

every value into any variable at any

time and it's just a matter of time

until this whole thing explodes into

your face typescript is absolutely

Superior it's an awesome language and

this is why we will use it in this

course so before we continue let's take

a look at the project we will actually

be building here now as you can see the

project is relatively simple but it will

build a full Foundation that you need to

build your own burn applications and I'm

actually not a fan of these tutorials

that adds too many features because

usually no single topic is explained

really properly the tutorial is really

bloated and lengthy and no one actually

finishes it so I like to focus on the

important parts make sure that you

understand these Concepts and then you

can add more features on top of it later

the goal of this course is to actually

have you finished the project and we

will even deploy it to real web server

so you can run it on the internet and

not just your local machine we will do

that in the second video I will talk

about this later and if you ever had

trouble understanding the moon stack

then this video will fix it because I

will explain all the concepts that you

need to know properly and as you can

already tell we are building a Tinder

clone no just kidding we are building a

note-taking application and it will

teach you all the crud operations so we

will learn how to create newer nodes

and add it to the database and the

screen we will learn how to update

existing notes

how to delete nodes and of course how to

display all these nodes on the screen we

will also do some other stuff like

simple form validation which is

important so for example this title

field here is required and only when we

actually type something in we can save

this node when we update a node this

little text down here changes from

created

to the last updated timestamp we will

learn how to navigate between different

pages using react router Dom and for the

UI we will use bootstrap which is a

package that you can use for example

with react

that gives you a different UI components

and design features

and I know that Tailwind CSS is very

popular at the moment but I still prefer

bootstrap because I think it's easier to

use it already brings stuff like modal

dialogues for example that you have to

build yourself when using Tailwind

like this it's completely free it's in

my opinion just easier to use and if we

use CSS modules which we will do in this

course then we don't have problems with

clashes between different CSS classes so

this makes the organizational of the CSS

pretty simple in my opinion but if you

don't know what any of this means don't

worry we will learn all of this

throughout this course

so the navigation bar up here these

buttons this model dialog that opens

when we click a node all of this comes

from bootstrap and we will also make our

layout responsive so that when the

screen size changes the layout changes

which again is made easier by bootstrap

so as you can see here at the full size

we have three columns of nodes but when

the screen gets smaller we have only two

and then eventually we only have one

column and also the menu up here

collapses and as you can see this is a

really nice view for displaying this

website on a mobile phone

so it's completely mobile responsive

which bootstrap again makes pretty easy

in my opinion entry will learn some CSS

tricks like fading out this text here

when the note gets too long

so some of these little tricks and of

course this Harbor Shadow effect and

since this is supposed to be a full

Foundation to build your own Moon apps

we also handle authentication in this

course using sessions and cookies so we

can log out of our current account which

makes all our nodes disappear and we can

log into a different account or create a

whole new one

so because of my insane creativity I'm

gonna call it ASD ASD the email will be

similar and the password is ASD ASD okay

this is a password suggestion this is

not my actual password just making sure

that I'm not leaking my personal data

here anyway we can create a new account

or this email address already exists so

we also have validation for this on the

back end

so let's choose a different email

address

and try it again

and we have our new account yeah let it

go man

which doesn't have any notes here so

let's add a new note

here as well

which now belongs to this account when

we log out and into our other account

we won't see this node because each node

is tied to a particular user isn't that

amazing and again this is the foundation

for you to later build more stuff on top

of it this is the important pieces now

we will talk about all these different

features later in more detail and if

you're wondering why I use cookie

sessions here instead of JWT tokens I

explain my reasoning behind this

throughout the series but it's a nice

and easy way to handle user sessions and

it doesn't have some downsides that jwts

have and after we have finished our

project here we will deploy everything

to a real web server only node which is

a hosting provider you will find the

second video only notes Channel and I

will put a link to it into the video

description below after you have

finished this make sure to also watch

the second video it will not be as long

we will just deploy this whole thing and

then you will have a real full stackdap

application on the real web hosting then

you can connect it to a domain and then

you have your own website for your

portfolio or you can build your own and

project out of it whatever you want

entry note was also so nice to provide a

free credit for my viewers so you can go

to leno.com coding and flow and you get

a hundred dollars free credit available

for 60 days again I will put a link to

this into the video description below

together with the link to the second

video where we deploy everything now

let's talk about the prerequisites of

this course because this is not a foia

beginner course we will not learn the

absolute JavaScript Basics so we will

not learn what the for Loop is or what a

variable is I assume that you already

know that but you don't have to know

JavaScript for that to be honest if you

know any programming language you will

be able to follow along because they're

very similar and I will explain the more

advanced language features that we will

use I will also explain how typescript

works and we will install everything

together if you know a language like

kotlin for example also I think Swift is

similar or Java then it will be very

easy for you to understand typescript

because

the same thing at the end it's very

similar we will also be using

asynchronous JavaScript features so

promises and async and the weight and I

will again not expand this from scratch

but you can just follow along in my

opinion because these features are very

straightforward and when you don't

understand something either just follow

along or Google it which is even better

and again if you know kotlin for example

then async await is very similar to

kotlin coroutines and there are similar

features in other languages as well the

same goes for HTML and CSS I don't

expand everything from the absolute

ground up but you just need to follow

along and unless you are a complete

beginner and have never touched any

programming language then I think you

will be able to understand everything

and whatever you don't understand just

Google it I'm also a fan of not learning

everything from the absolute Basics

upwards because I think it's a boring

approach to learning programming I much

rather create a project and be okay with

not understanding in every detail at the

beginning and then you can still fill in

the gaps later for example I never

formally learned CSS I never learned the

basics of it but I built actual projects

that use CSS and when I later was

wondering what a specific keyword or

feature meant then I Googled it and

learned it when I actually needed it I

think that's a much more fun approach to

learning programming than going through

these beginner courses where you spent

three weeks just learning the

fundamentals of CSS that's super boring

we will also install all the necessary

software together so we will install

node.js all the necessary packages we

will set up our mongodb database you

don't need to know anything about it and

if something is unclear either Google it

or you can also leave a comment below

and ask other people or ask me I'm

reading all of my comments basically I

don't respond to all of them but I read

all of them just one more learning tip

for this course instead of just

following along everything step by step

I recommend that you build a project

that's slightly different for example

create a slightly different layout use

different data types maybe even don't

build a node app like I do here maybe

build a to-do list app so that you use

the same Concepts that you learn here

but you apply them in a slightly

different way I really like this

approach because it forces you to

understand what I'm explaining here and

not just blindly follow along if you are

a beginner and it's too difficult for

you then you can also just follow along

step by step no problem it's just a

little learning tip I also want to

quickly explain how a react Works

overall so let's take a look at the app

again when you use a react website then

you will notice that it feels more like

a mobile app almost rather than a

classical website for example when we

navigate to a different page you'll

notice that the navbar here at the top

stays in place and it doesn't reload so

we are not actually reloading the whole

page because a react app by default is a

single page basically and all the

contents within the single page are

loaded by JavaScript script this is why

when we switch back to the node screen

you see this progress Bar for a short

moment this is because we are not

actually getting the full page sent from

the server we are only getting the shell

which is this page with all the static

elements but without the data that we

are loading from the server so without

our nodes

and then with JavaScript code we are

loading these nodes and this is why we

see a short progress bar and then all

this pops up here on the screen just

like a normal app our code is sending a

HTTP request to the server and it gets

back Json and then turns it into these

nodes which you can see on the screen

you don't need to understand this right

now we will take a closer look at this

later but if you're coming from mobile

app development for example then this

will feel very familiar to you because

react websites are basically apps on the

internet now since JavaScript is used to

load the data this also means that react

apps by default don't work without

JavaScript so in the Chrome developer

twitch we can actually disable

JavaScript

reload the page and you can see this

little text here you need to enable

JavaScript to run this app but this is

usually not a problem because about 98

of all websites on the internet use

JavaScript so it's very aware for our

client to not have JavaScript enabled

because it's required to view almost any

website on the internet so let's turn

this back on here

and then we can see our website again

now the so-called client-side rendering

approach where the website loads more

data from the server after it is already

displayed in the browser has benefits

and downsides you can Google them and

read up on them if you want and there

are also Frameworks that combine the

best of both worlds for example next JS

which is another framework on top of

react where you have more control over

what data you will load client-side and

what pages you load servers out where

all the data is already in the page that

comes from the server I'm a huge fan of

next JS it's my favorite framework for

my own projects but it's quite an

advanced framework and again it's built

on top of react so you should learn

normally react before putting hands on

xjs and this course here will teach you

all the foundations that you need to

know okay and now the actual course

starts and we will focus on the back end

first so we'll build the server and the

endpoints first then we will build our

react website and connect everything

together I will also put a link to the

project on GitHub into the video

description below so you can check out

the code there and then I wish you a lot

of fun and don't forget to like this

video please and share it with someone

that could need it it really helps the

channel and it makes it more interesting

for me to create more free courses in

the future so it's a win for both of us

alright have fun

all right in order to write code we need

a code editor and a very popular choice

among web developers is Visual Studio

code or short vs code which is a free

code editor by Microsoft you can use

this one you can use a different one

it's up to you if you want to use vs

code just go to a

code.visualstudio.com or type the S code

into Google download it install it the

installation process is not difficult

next we need node.js installed node is

the n in the mirn acronym and node

allows JavaScript code to run in a

server environment so normally a

JavaScript is meant as a language for

web browsers so it only runs like in

like Chrome for example but node.js

brought JavaScript to a server so we can

write our backend in JavaScript tool so

again this is of course completely free

you can go to nodejs.org or just type

node.js into Google and here we want to

download the latest ATS version ATS

stands for long-term support and it

basically means that you can use this

version for many years without having to

update it alright so we click this and

download this and when it's finished

downloading we click to install our file

okay so now we just have to follow this

wizard here

next we read all the license agreement

okay I've read everything next

then we can keep this as it is

next we can keep the defaults here as

well

add to path yeah looks fine to me

particularly important is the node

package manager which we later need to

install packages and stuff like that but

the default options here are shuts the

files

we click next again

this option here should not be necessary

for us so we can skip this click on next

and then install and then we wait until

this is finished

all right looks like this succeeded so

we click on finish

and to check if this actually worked we

want to open the command line

so when Windows just hit the Windows key

and type CMD and on a Mac it works

similarly you probably already know how

otherwise Google is and if you use Linux

then you are a nerd anyway and you

probably use the command line all the

time we just want to check if note was

installed properly so what you do is we

type in node minus minus version

and this should show us the latest

version here we installed if it says

something like node is not a recognized

keyword or command then try to install

it again maybe restart your computer

maybe this helps otherwise Google

installation instructions or leave a

comment below so others can help you but

if you followed along it should have

installed it properly and when we type

in npm dash dash version then it should

show us the version of npm that we

installed which is again the node

package manager okay we can close this

close this here as well

before we start building our server

let's first understand why we need a

back-end server in the first place in

short we use a back-end server for

everything that we can't trust the front

end to handle because whatever code we

are right for the front end in our case

our react code later is loaded into the

web browser and everyone who is a bit

technical or a programmer is able to

actually look into this code even though

it will be minified they can look into

it and they can Tinker with it which

means that we can't put anything secret

or critical in there for example we

can't put the credentials for our

database into this code because users

would be able to see this if they

inspect the code we also can't trust

form validation on the front end because

even though it will be enforced if they

use the website the normal way as it's

intended they can still change it by

tingering with the code and this way

circumvent the restrictions we set up

the back end our server on the other

hand is like a black box that people

can't look into because it runs on a

different machine it doesn't run in the

browser and the only way to get data

from the server is by sending a message

there sending a request and saying Hey

zobo I want this piece of information

and then the server says okay but do you

have the correct credentials for that

are you authenticated then the front end

can send the password or whatever

authentication method we use as an

example and then the server ultimately

decides if it fulfills the request or

not but users can't go into our server

and change code there or anything like

that for Outsiders it's just a black box

so to summarize our front end can't

contain anything that's critical or

anything that's secret as all goes into

our backend the front end is only the

user interface that communicates with

the backend but it's not safe it's not

secure

all right now let's set up our node

server and the first step is to create a

folder somewhere on your computer where

you want to save this project that's up

to you and in here we create another

folder

which I'm gonna cut back end

this will contain the code of our node

backend project we go into this folder

and in here we want to open the command

line

on Windows you do this by holding shift

down and then right clicking and then

open Powershell window here depending on

your configuration this might open the

older command line but it doesn't matter

both are fine for what we want to do

if you are on Mac or Linux you will also

have a command line available just look

up how you open it if you don't know how

to do it there are instructions in

Google

okay let's make this here A bit bigger

so we can see everything

and in here we type in npm

in it

Dash wire and whenever we write

something in the command line you have

to write it the exact same way as I do

or otherwise it won't work the command

line is not very forgiving okay we type

this in and press enter

and it looks like it did something it

created this package file here we don't

see the file extension here in Windows

right now but this is a Json file so the

full name is package.json next we want

to open this project with this file we

just created and we could be old boring

Boomers and open it through the escort

but cool modern people open projects

over the command line so we stay in here

because as you can see we are still

inside this backend folder that's

important and then we could type in code

and then space and period so code Dot

enter and this opens this project in vs

code

now if this window here pops up we want

to trust this project but this might not

pop up for you and here's our

package.json file which we created a

moment ago

this package.json file is basically the

configuration for our project where we

will also later have all the

dependencies listed that we need all the

packages that we use now since we typed

in dash wire it used the default

settings for all this meta data here and

actually this stuff or most of it is

only important if you want to release a

library if you want to release a package

for our server project that we use

ourselves this is actually not important

we don't need a description and the name

and version doesn't matter keyword

authors you can fill this out if you

want but you don't need to we also don't

need to specify a license because no one

else will have access to our code and

now it's actually time to install our

first dependency oh that's exciting our

first dependency will be typescript

which we have to install in order to use

this language instead of JavaScript so

we want to open a command line again and

we can do this directly inside the S

code as well so we click up here on

Terminal and on new terminal and here

next to it you can see the shortcut for

me it's Ctrl shift ER if you're not a

German you probably don't have an ear

can you use whatever shows up there okay

now we have a terminal here and now we

type in npm install

dash dash save Dash Dev like this

just type it the exact same way

typescript or lowercase

enter

and this installs typescript in this

project

and as we can see this new entry here

popped up in our package.json under this

Dev dependencies queue dependencies are

just packages that we use for our

project for example later bootstrap is a

dependency as well for our layout all

these different libraries that others

have made for us and that we can use and

there are two types of dependencies

normal dependencies and Dev dependencies

def dependencies are the ones that we

don't actually need in production we

only need them while we are writing the

code so we put this into the separate

key here so that we later save space

when we deploy this project to

production because those ones here will

be skipped those are only for

development okay down here it also says

new Metro version of npm available it's

always good to update this so let's copy

this command here

and type it in

you can paste it with a right click and

press enter to install the latest

version of npm

we also see that it created two new

entries appear in our file directory one

is the package log Json which is related

to the package.json we don't have to

worry about this this is generated

automatically and node modules contains

the packages that we install the

dependencies which is typescript in this

case but there will be more in there

later alright and a typescript project

needs a typescript configuration file

which contains some information on how a

typescript should behave otherwise it

won't work so we go into the terminal

again and we type in npx this time it's

not npm it's npx and the difference is

that npx doesn't install packages it

executes packages basically that's all

we need to know so we type in npx TSC

which is short for typescript but we

have to type in TSC not typescript it

might be short for typescript compiler

I'm not sure actually just type in npxts

here dash dash init

enter

and this creates a new file for us which

is this tsconfig.json here let's open it

and take a look in it a lot of scary

stuff most of the options in here are

commented out so they are inactive

because they are optional and the ones

here if you want to know what they are

for you can read up on them we don't

have to change anything in here right

now it's all set up properly for us but

we have to make some changes here later

then we will get back into this fire

okay now it's time to install Express

and express is the e in the moon stack

it's the framework that allows us to

build the server basically so node.js is

just the foundation where the code runs

on and expresses the actual library that

allows us to write the server code and

the endpoints and everything so again in

the terminal we type in npm so not npx

this time npm again

install and by the way there's a short

form for install which is just I let's

use this in the future without safe Dev

this time because this is not a Dev

dependency

that goes in here like typescript it's a

normal dependency which we need in

production

and then we type in Express

enter

and this installed Express here under

this dependencies keyer for normal

JavaScript project this is enough in a

typescript project we often have to

install also a package that contains the

type so that our code works properly and

typescript knows what types the

different variables and functions have

so once again we type in npm I for

install

types are def dependencies because we

don't need them in production so again

dash dash save Dash Dev

add types slash Express type it the

exact same way I did and press enter

again

which adds another entry in the dev

dependencies the express types

now this always installs the latest

version of these dependencies if you

watch this tutorial sometime in the

future then these version numbers will

be higher than the ones you can see on

the screen and sometimes when these

packages get updated things break

especially when the number here at the

very front changes if this happens some

things I show in the tutorial might stop

working because they change this

meanwhile then the best way for you to

go about this is to Google the changes

you can read the release notes for the

dependency on GitHub for example and try

to implement the changes yourself if you

can't get this to work and you can't

figure out how to use the latest version

then you can always install the version

I used here in this tutorial so for

example instead of just npmi Express

you can also add at the end and add and

then the version number which in this

case would be

4.18.2 if you do it like this it will

install this exact version and

everything will work like it works in my

tutorial but again it's better for you

if you actually try to figure this out

by yourself

and now let's actually create our first

little server so here on the left side

in this file explorer we right click and

create a new file

TS stands for typescript if it was a

normal JavaScript file then it would be

dot JS but we are not peasants we use

typescript here alright and for now just

type exactly what I type here first we

have to import Express into this file

expresses the package we just installed

so we type in Port Express from

and then in quotation marks and in

JavaScript and typescript code we can

use single quotes and double quotes in

most situations it doesn't matter I will

use double quotes here just to keep it

consistent

and here we type in Express and

semicolons at the end of a line are

optional in JavaScript as well but it's

good to practice to add them so that's

what we're going to do here in the next

line we write const app with const we

create a variable that we can't change

the value of later but again those are

JavaScript basics

and then we can't express like this and

the app is basically our server this is

where we later at different endpoints

and everything

we also have to define a port

which is that to 5000 Port is basically

a connection point on a server and you

have to set this to a number some

numbers are occupied already so there

are certain numbers that people use by

convention like 5000 or 8 000 but a lot

of different ones will work you could

probably type in

4993 and it would work as well but you

will go fine with five thousand and also

some web hosting Services require a

specific port number so this always has

to go into a consideration react for

example users Port 3000 by default so we

want to use different ports for both of

them otherwise we can't run them

simultaneously on our local machine okay

and then below we take our app wherever

there again and car.get and between the

parentheses repairs a slash as a string

so in quotation marks

comma

and then we pass an error function here

which looks like this another pair of

parentheses Rec comma address those are

the two arguments that this function

gets passed

then we make a right arrow like this

with an equal sign and a greater than

symbol curly braces

and in here we can write the code of

this function so this is an error

function here it's like a function

without a name there's a similar feature

in kotlin and other languages as well at

the end of this get Curl here we put a

semicolon before we forget it and in

here we take this res

cow dot sent

and pass hello world as a string

semicolon

this is our first endpoint which we will

call in a moment and we will get the

string back but before this works we

have to start the server which we do the

following way

below we call app.listen

pass the port we defined up there 5000.

and another error function but this time

it doesn't take any arguments so it

looks like this

and this will start the server and this

is basically just a callback and in this

callback we want to show a lock message

just so that we can see okay we actually

started the server and there was no

crash or anything

so let's just write the log message in

here which in JavaScript we do like this

server running on Port colon

and then we append the port number at

the end again not the pulse port

okay nice and nvs code by default you

actually have to save your files it

doesn't happen automatically so I press

Ctrl s

and now we want to start this whole

Observer

and normally a note if you want to start

a file you type in node in the command

line and then the name of the file so

this would be server.ts

the problem is this only works with

JavaScript files because node doesn't

know how to execute typescript by

default it has to be compiled to

JavaScript first and we do this with the

following command npx again TSU enter

and this turns this typescript code that

we have in our project into JavaScript

code as you can see here on the left it

now created the server.js file and this

is the JavaScript version of our server

TS file this is automatically generated

we don't have to understand this this is

not how a human would write JavaScript

it's how the compiler reads it with

optimizations and everything we don't

actually have to understand this file

it's just interesting to take a look at

it because this is the file we now can

run

when we type in node

server.js this time

and as we can see it now says server

running on Port which is our own text

that we typed into the Callback

and here on Windows I also have to allow

access that's fine

okay and now our server is running on

Port 5000 and now you can just open the

web browser and type in localhost Colon

5000 into the URL bar

and this is now our server here it says

hello world congratulations you are now

a note back-end developer the tutorial

is over happy birthday

no I'm just kidding of course this is

just the beginning a real web server is

much more complex than what you have set

up here and by the way what we have said

up here let's close this is a an

endpoint for an HTTP get request if we

open a website in a web browser it will

do a get request if you have built apps

with networking features before then you

might know that there's also for example

post request to send data to a server

patch delete and so on we will use this

other HTTP methods later to modify our

nodes but yeah this is a get request and

this is how we set it up by a

culling.get on our Express app it's also

a good idea to organize our code better

because otherwise later when we compile

our code we have this huge mix between

JavaScript and typescript files

for now let's delete this we don't need

this right now we only need this when we

actually run our server later in

production

so we delete this and for organization

we create a folder in here which we call

sr0 which is short for Source that's the

source code of our project that's just a

naming convention

and we put the server TS file in there

everything that's configuration for our

project goes outside of source and into

a source we put actual typescript files

that contain the code for the different

endpoints and so on

and next we want to tell the typescript

compiler that it should put these

generated JavaScript files also into a

its own folder so our project isn't

clevered with it

so we open the TS config file again

and we search for the option

that's called out dir so output

directory we remove the comment here at

the beginning

so we activate this basically

and we are append dist here at the end

which puts the generated code into a

folder called dist which is short for

distribution and just because I have OCD

and let's align this here again properly

and save this file let's try running our

npx TSC command again but first we have

to stop our server while it's running we

can't add any commands here so we press

Ctrl 0 which stops our server no it's

not running anymore and again we try our

npx TSC

to compile our typescript code you don't

have to do this right now you can just

watch me do it

and now our code is properly organized

into this this folder here which mimics

the shape of our source folder and now

if we want to run this file we have to

type in node like before but this time

just slash server.js because it's inside

this this folder right so let's try it

again the server is running localhost

5000 it's still there nice oh he was the

old window

but of course it's annoying to repeat

this whole process every time we make a

change to our code every time compile

the project type in noise This Server

and so on so we can install some

dependencies that make this process much

easier for us so let's stop the server

again

and delete this list folder here because

we will only need this compiled code in

production

in development we will use something

different

the package we are used to automatically

restart our server whenever we make

changes to the code is called nodemon

and as you can see on the npm Page by

the weekly downloads it's a very popular

package if you want to learn more

details about this package you can check

out its page here but it's pretty

straightforward to use as you can see

here we install it as a Dev dependency

because we are only needed in

development

so let's copy this

and paste it into command line

and again it adds another entry in our

Dev dependencies here

now this only works with JavaScript by

default but luckily there's another

dependence here

that automatically works together with

nodemon to a transpile our typescript

code into JavaScript on the Fly

which is called TS node so again we want

to install this as well and here's the

command for that and by the way it is

minus D with an uppercase D is the short

form for dash dash safe Dev so we copy

this

paste it in here and style this as well

and now instead of compiling our server

TS file and then starting this server.js

file that's generated we can just start

our server TS file directly and we do

this by typing in npx nodemon to execute

nodemon and then our server TS file but

it's inside our source folder so we type

srz slash servo.ts

and this now starts our server fire it

works because we have TS node installed

which compiles the typescript code on

the flyer and not only that now if we

make changes to any file the server

automatically restarts so let's add the

comma here between hello world because I

think this is the correct way to write

it save it with Ctrl s and as you can

see down here it automatically restarts

our server

so now when I open localhost again we

see the new version we don't have to

compile anything manually it just works

but we can make this even shorter we can

go into our package.json file and add

the script here a script is basically a

shorthand to execute a command

to be called this script start

which is just a convention I think and

then in quotation marks we type in the

command that we want to execute and when

we do it in here we don't need the npx

we can just type in node mon

and the same as before srz server.ts

let's save this and try it out so I'm

gonna stop the server down here with

Ctrl Z and then I have to confirm it

with a wire short for yes and now when

we type in npm start we execute the

script here

which now starts not one the same as

before

nice we can also specify the main entry

point of our server up here for our use

case that's not necessary because on our

Productions over later we will just run

our server file directly but I think

some web hostings need this so it's

probably a good idea to still Define it

and our main entry point will be a

server.js file in the dist folder later

this is where our server is actually

started because nodemon NTS node are not

suitable for production use let's save

this again and there's one more thing we

want to set up in this part and that's

eslint so once again in the command line

we stop our running server

type npm install short I minus upper

Castillo short for safe Dev

eslint so we installed eslint to the dev

dependencies

enter

and there it is with the latest version

and then we type in npx

eslint dash dash init

which creates a new file which is a

configuration file for eslint but we

have to go through some short steps here

in order to set this up need to install

the following packages okay to proceed

we type in y for yes to install this

and then we configure this file and you

switch options with the arrow keys on

your keyboard how would you like to use

eslint to check syntax and find problems

that's reasonable

what type of modules does your project

use

JavaScript modules import export this is

what we use

which framework does your project use

react vue.js or none of these none of

these because we are in node here

does your project use typescript yes of

course

where does your code run browser or node

as explained earlier this is running

with node.js so we selected

what format do you want your config file

to be in and here we select JavaScript

again

and now it has to install some new

dependencies which of course we do which

package manager do you want to use npm

which we have been using all the time

and then it installs some stuff as we

can see some new dependencies pop up and

this newer.eslint rz.js file which is

the configuration for the excellent now

even though we selected node in the

configuration it adds browser column

true I don't know why I don't know if

this is a bug but

we should change this to node and save

this

and lint helps us find problems in our

code some of those problems are errors

where we just write invalid syntax and

we can't run our code at all but some of

these problems are just bad habits that

we should avoid because they can cause

problems later let's see an example of

this one such bad habit is circumventing

typescripts Knight safety or undefined

safety

so for example let's say the sport could

be undefined for example because we get

this value from somewhere else and we

don't know if this actually contains a

value or not this would work here

because this method can work with an

undefined Port but some functions would

complain and I would say hey we don't

accept and possibly undefined value here

we need a number and one way to affix

this is to actually check if the value

is undefined or not just with a normal

alt if statement but another way is to

attend a compiler hey relax we know that

this value will never be undefined which

we do with this non-nine assertion

operator which is an exclamation mark

behind the variable this way we tell the

compiler here we know that this port

number will always have a value but as

we can see here we don't actually know

this we can make mistakes this way this

is why it's a bad habit and eslint will

tell us that this is a bad habit by

running it so we type in npx eslint

then the dot which executes eslin in

this folder if I'm not mistaken right

now

dash dash exterior this way we Define

the extensions of the files that we want

to check and we want to check our DOT TS

files so this is what we type in we

press enter and now this checks our code

and as you can see it found one problem

forbidden online assertion this is just

a warning it's not an error so our code

would still run but this tells us here

this is probably not a good idea and we

should do something else with it so

let's change the spec

run it again and this problem will not

show up again now of course it's a good

idea again to create a script for this

so we don't have to type this out all

the time so now package.json file

let's add a lint command

again we don't have to type the npx this

time

just eslint

period

EXT dot TS

and then we can run this with npm run

lint

now why do we have to enter run now and

before we just typed npm start at node

npm Run start this is because start has

the shorthand so npm start is a

shorthand for npm Run start however for

other types of commands like lint we

have to type it out like this

npm run lint

let's add our

problem here again to see if it still

works

and yeah it works change this back

because we are not bad callers right but

it's still a bit annoying to always

execute this over the command line it

would be much nicer if the IDE or the

code editor would show us this directly

and there's an IDE extension for this so

here NBS chord on the left side we can

open this extensions tab

and it's already here under the popular

extensions eslint

and this extension will check our code

directly with our eslint configuration

so we don't have to execute this in the

command line so let's install those

and see if this changed anything make

this here bad once again and as you can

see now we have this yellows quickly

line and the eslint warning shows up

directly in our code

nice so this will save our behind in the

future of course you can check out the

other extensions as well there are some

really cool ones in there we will get

back to this later but for now we are

done with this now there's one more file

we want to add to our project and that's

the git ignore file if you already have

programming experience then you probably

already know what git ignore is it's a

file that defines other files and

folders in our project that we don't

want to commit to git this is important

for example if you want to push your

project to GitHub for others to see

because some folders are just big and we

don't need them so we save space and

bandwidth by not committing them but

there are also certain files that we

must not commit because they contain for

example database passwords and all these

files have to be added to a disk it

ignore file so we create a new file here

in our project outside of the source

folder and the name is dot that's

important it has to start with this dot

git ignore just as one word like this

now how do we know what we have to put

in there either we can design this

ourselves but there are templates for

this available on GitHub and as you can

see it's from github's web your own

account so those are basically official

files

we can copy this here copy raw contents

and you can either look this up yourself

or you can go to my GitHub project in

the description below and go into the

git ignore file there and copy its

contents

and then we just paste this whole stuff

in here and save it

this contains more than we actually need

but that's not a problem it's better to

have too much in here than too little

and accidentally expose stuff that we

don't want to expose

as you can see the node modules folder

is in here as well so if we Commit This

to get then this will be ignored and

it's not necessary because this contains

only the code of the packages we

installed but we can always install

these packages from our package.json

file here so here we have defined what

packages we need and later for example

when we pull this code on our web server

without the node modules folder we just

type in npm install and all the latest

versions here will be installed and this

node modules folder will be recreated

and the main reason why we don't push

this is just because it's a huge boiler

and we don't actually need it our eslint

and TS config files on the other hand

are pushed to GitHub because they

contain configuration that we want to

keep when we work in the team right then

everyone should use the same lint rules

and typescript configuration so those

are not in the skid ignore file because

we want to push them usually

okay the next step is to set up the

mongodb database and connect this to our

backend server but there's one more

thing I want to clarify before we start

with this and that is you might be

wondering is this what we are building

here a restful API is this a so-called

rest API and if not what's the

difference between a rest API and our

server that we are building here a rest

API is also a back-end server but it

fulfills certain constraints and rest

apis are usually servers that are

accessed by many different clients and

this is why they follow certain rules

one of those rules is that they don't

contain any state our server will later

contains States because users will be

able to log in and for each login there

will be a session in our database that

connects this user and lets the server

know that this user is logged in and

this is a violation of the restful

constraints because this is not a public

rest API we are building here it's our

own backend server for only our own

singer client by but you can build a

restful API with the exact same stuff we

are using here with Express and node the

same code the same endpoints you can

also use this to build a public API

maybe that's an interesting project for

you to build a public API that serves

some data that people can get from your

server just as an idea okay and now in

the next section we will install mongodb

okay the next step is to set up our

mongodb database mongodb is the m in the

moon acronym and it's the place where we

put our data later like our nodes and

also our user data and mongodb is a

so-called schema-less database which

basically means that we can put any data

into any document we want in any

combination and it will work that's the

opposite of a database like SQL where

you have a certain schema that you have

to adhere to and all entries within the

table basically have the same columns

and the same data types and if you want

to change this structure then you have

to migrate this table a schema-less

database is a bit like the wild west of

databases but it's also how firebases

database works for example it's also

schema-less so it's a very popular

concept and it works in many situations

it has downsides and benefits like

everything in life and if you want to

learn more about the differences then

you can look them up in Google but we

will use this here and again it's a very

popular choice and it works for many big

companies and to host this database you

basically have two choices you can

either self-host it on your own server

or you can use a service like mongodb

Atlas which is a hosting provider for

mongodb databases the benefit of using a

service like Atlas is that it takes care

of many things that you would have to do

yourself otherwise like scaling security

concerns encryption backups and so on so

I'm a fan of using these Services

because it saves us time the downside is

that in production we have to pay money

for this we don't have to pay money for

this tutorial because they have a free

tier but if you want to scale up of

course this costs money but I think it's

worth the convenience you get that's why

we will use mongodb Atlas in this

tutorial and to create an account there

we go to mongodb.com Cloud slash Atlas

or just type mongodb Atlas into Google

it's probably the faster way

and we click on startria and by the way

this is the most ugly button animation

I've ever seen but it's probably a rich

company and it works for them so maybe

we should take an example of that all

right so we have to fill out some data

here first name last name no company

and here I'm gonna use email address

that I've prepared just for recording so

we have a completely new setup which is

recording it's coding in floor punct.com

and we pick a secure password which I've

already prepared

all right we agree the terms of servers

and privacy policy which you can read if

you want and create an atlas account

and we have to verify our email so let's

do that real quick okay so I've verified

the email so let's go back to mongodb

account remove this part here from the

URL to get to the login screen

it locks Us in automatically otherwise

just type in your email and password you

just signed up with

and another queer thing about mongodb

Atlas is that they give you this back

end this UI to work with and you don't

have to do this over the command line so

let's start setting this up first of all

as they say here the current IP address

should be added to a white list

so let's do this by clicking on this

button here and it does this

automatically we later have to go to the

network settings again and add the IP

address of our server but not for now

and now we can actually create a new

database by clicking on this button

and then we have to do some setup here

we want to start with a free account so

we have to select the shared hosting

option later if you are in production

you can decide to use a dedicated or

serverless configuration most likely

dedicated but for now we use shared so

we click on Create and we have to do

some setup here we have to select where

our database will be hosted because

mongodb Atlas works together with these

big hosting providers you can select

whatever you want I'm gonna stick to

Amazon

a location for our database and it makes

sense to pick a location that's close to

the location of your deployment server

later I'm gonna stick with Frankfurt

which is here in Germany where I live

cluster tier m010 box is the free tier

which of course has some limitations but

it's enough for playing around and it's

also enough even for small production

projects

backup is not enabled in m0 clusters but

that's fine and termination protection

is a relatively new feature

it makes sense it just adds an

additional step before you can delete

your cluster which is always good to

have because you never want to delete

this by accident we can give it a name

the name doesn't really matter in my

opinion you can give it something

descriptive but I'm just gonna stick to

a cluster zero

and we click on create cluster and now

it charges your credit card with 120

dollars no I'm just kidding it's

completely free unless you upgrade to a

higher cluster and now we have to do

some more setup here how would you like

to authenticate your connection via keep

username and password so here we type in

our username I'm gonna call it Florian

and I'm gonna Auto generate a secure

password

copy it because we later need this in

our code of course and we create this

user

now the user is created here

we want to connect from a local

environment

and we already added our current IP

address to this list so there should be

enough and then we click finish and

close

and here is our shiny new database

can you smell that that's the smell of a

fresh database we can browse collections

but we don't have any yet but we want to

connect our code our backend server to

this database so we click on connect

then we have different options you can

connect over the command line with a

tool they have which is called Compass

but we want to click on connect your

application

and then we want to copy the string here

by clicking on this button because we

need this in our code

and then we open our code again and this

time I will open the project one layer

higher the last time we were inside this

backend folder and open the project from

here but now I want to open it from this

folder here where we can see the backend

folder the only reason for this is that

this way we have the back end and later

the front end folders both opened in vs

code you don't have to do this you can

also open them separately I do this

because I want to push them to the same

GitHub repository so you can look at the

code later this is also where there is

this dot get folder which probably

doesn't exist on your side it doesn't

have to you can ignore this so again I'm

going to open this by shift right

clicking to open the command line here

and then I just type in code

then the space and then a period

to open this folder

and we can close this

and this is what I meant now we open

this whole coding and flow Mount folder

here so we can see the back end and

later the front end both inside this

project view now our mongodb credentials

are of course data that we don't want to

give to anybody willy-nilly it's

sensitive data that's why it's a good

idea to also not push this information

into the GitHub repository in other

words we want to put it somewhere in the

file that's included in our git ignore

and the correct place for this kind of

stuff is the NF file which is included

in the skid ignore we pasted earlier and

in there you put environment variables

which can be configurational that

changes depending on where you run your

server for example on localhost or on a

real deployment but it's also the place

where people usually put sensitive data

like database credentials so what we do

is here in the root folder we right

click and create a new file which we

call.nf the same name as you can read

here on the git ignore

and in here we want to put our mongodb

connection string so we put a variable

in here that we have to give a name you

can color whatever you want I'm going to

name it mongoa underscore

connection underscore string and the

convention for this kind of constants is

to write them in our uppercase with

underscores but you can also use candle

case or whatever you want then an equal

sign and then we paste the connection

string we just copied and since this is

just one string without spaces we don't

have to add quotation marks here

we can if we want

but we can also keep it like this this

part here in front of the colon is our

username we just defined when we set up

our cluster

and we have to replace this part here

for the password I'm just going to paste

the password here because it's just for

this course I don't actually use this in

production but of course you should keep

your password secret and only share it

with team members or whoever is allowed

to know it and let's also put our port

number in here because this can also

change between deployments so you

usually want to put this into your end

file

so we just write Port equals and 5000.

then we save this with Ctrl s remember

in the S code by default you have to

save your files and by the way you can

see that node modules here is grayed out

now which indicates that this folder is

not pushed to a GitHub it might not be

grayed out on your side if you didn't

actually deploy this project to GitHub

just as a node and NF will later also be

grayed out on my side because it's

included in the git ignore file but I

did a little mistake we have to put this

end file into our backend folder not

here on the root folder because it

belongs to our backend code so let's

move it in here drag and drop very

simple

and now you can also see that it's

actually grayed out because now it

recognizes the git ignore file in the

same folder but this is only necessary

if you open this parent folder like I

did if the backend folder is your root

folder then of course the end file goes

in there so just put the end file in

your backend folder basically and now we

need to install another package that

allows us to load this end file because

nodes doesn't do this by default so we

want to open the terminal again but it's

important that we are inside the backend

folder

so we type in ZD and it should be the

same on Windows Mac and Linux backend CD

stands for change directory we go in

here and in here we want to install our

new package

so the same as before we type npmi

.nf

which is the name of the package that

allows us to load n files and if you

want to learn more about this package

there is a page for basically all of

them on this npm js.com website you can

basically read about any package here as

you can see it's a popular package as

well it shows us the configuration

options and so on but don't probably I

will show you how this works but first

we want to install another dependency

npm IO this one is called mongoose

and Mongoose is a object modeling for

node.js so it's basically a package that

makes it easier to work with the mongodb

database so it's less of an Arcane

language as the original as you can see

it creates these objects and types and

it's really cool

it has a humongous documentation which

can make you lose the will to live if

you see how much information is in there

but you don't have to know all of this

and I'll show you the stuff you have to

know of course in this course and just

as a reminder all the packages we

installed are inside our package.json

file here

they get added to the dependencies block

and by the way in the last video before

I push the code I swapped the order of

Dev dependencies and dependencies

because I think they should be at the

top but it's unnecessary the order here

doesn't matter okay and now let's go

into our server TS file again and start

this connection to our database so we

want to add two more dependencies here

at the top the first one is the dot nth

dependency we just installed and we

should import it as early as possible

that's why I put it in the very first

line this makes sure that our

environment variables are available when

the app starts so up here we type import

and then in quotation marks

Dot N slash config which is basically

all that's necessary to set up and

configure.nf in our nth file

and we also want to import Mongoose to

use it

so again import but this time without

the quotation marks here the same way we

imported Express because this up here is

actually just a shorthand over

writingimport.if like we did for Express

and then calling config on it by

importing it like this we are

automatically call this config I found

it somewhere in stack Overflow so

Mongoose will import the following way

import Mongoose and it auto completes it

by default isn't that amazing otherwise

type it out as you can see it here and

this allows us to use the Mongoose

package in this file here in the server

TS file and now we connect Mongoose to

our mongodb database the following way

and again I have this from the

documentation or other tutorials but you

can just follow my instructions here

we call Mongoose

dot connect

and as you can see we have nice Auto

completion in vs code and here we want

to insert our mongodb connection string

which is inside our end file so we copy

the name of this variable

and then we type process.nf to access

our environment variables

and the name of this variable

now this shows us a warning because this

environment variable could be undefined

but connect is expecting a string that

actually has a value we will take care

of this in a moment

here we call Dot then because connect

returns a promise which is basically an

asynchronous operation an operation that

takes a moment and brief dot then we can

Define what we want to do after this

succeeded now later we will use async

await which is some synthetic sugar

around promises which makes them a bit

nicer to use but we can't use async

already on the top level in case you're

wondering if you don't know yet what

this all means just follow along so

inside then we have to pass a function

so we add another pair of parentheses

then the right arrow as we did before

and a pair of curly braces

and we can also put a semicolon down

here and here we Define what we want to

do after this connection is exceeded

let's write a log message with

console.log

which says monk was connected

and we also want to start our Observer

here after our mongodb connection was

successful we could keep it like this

following one after another but if the

connection failed for some reason we

don't want to start our server because

it wouldn't work properly without the

database right so we can actually cut

this out and put it in here

and to let the code editor format our

code we can press shift alt F which

would align it properly okay but we also

added our port to the environment

variable files so we shouldn't be

getting it from here we should get it

from the process end here as well

so let's create a variable for our Port

so we don't have to repeat process.nf

all the time

we write it as a const because this

value shouldn't change

and the port is process dot NF dot port

and all uppercase

but again as you can see the value could

be undefined because we never have to

guarantee that we actually put these

values into our environment variables

now app.listen and console.log they

don't show a warning because they would

accept an undefined Port the code will

still run Mongols is not so forgiving

they want the real value now there are

different ways to handle this one way is

to do what I already showed earlier when

we took a look at eslint is adding this

non-nine assertion operator this will be

tell the compiler here we know that this

value is not neither please just accept

it as you can see here eslin doesn't

like this because it's a bit dangerous

but our code would run so let's try it

out let's save the file

enter an npm start

and if everything is successful we

should see Mongoose connected and then

server running on the port blah blah

blah we should also add a catch block

here after then so before the semicolon

actually

we call Dot catch

which is basically the opposite of the

dot then for promises so we have then

for when the promise was successful and

we have catch for when there was an

error and in here we can just call the

console.error but without the

parentheses because we are not actually

calling this function here we are

referencing it so catch will call this

error function and pass the arguments

that it gets and this argument is the

error itself so this way it will print

this to the arrow console which is

basically the same as console.log just

at its red text basically and a

different place where we can see it

depending on where we deploy it now what

happens if we forget to Define this

value here let's remove it for a moment

save this file

and try to render this without the valid

connection string

as you can see we get an error here the

UI parameter must be a string and

undefined and this is good we want to

crash we don't want our server to start

with an invalid configuration so it's

good that this actually crashes right

away

however if we delete the port here

and run this again with an undefined

port

then our server actually runs Mongoose

connected server running on Port

undefined and this is a problem because

this will not work but our code still

runs and there are situations where this

could be even more problematic where an

undefined value could do some real harm

and we don't know where it's coming from

so this is why eslint complains about

these non-known assertion operators we

should avoid them one way to handle this

would be to just have checks for each of

them like

this port with an exclamation mark in

front of it which basically means it's

false here which is the case if it's

undefined then we want to throw an error

here to crash our server right away

but this is a bit verbose and we still

don't have a warning here because this

listen function doesn't complain about

the possibly undefined value so better

way to handle this is use another

package which is called invalid

it's another popular package that is

used to define how our environment

variables should look which one we have

in the dot end file and then it enforces

this schema so if one is missing it

actually throws an error and our server

won't start

so let's install this we have to stop

our server with Ctrl 0 and then the wire

to confirm it

npmi and valid

and it's a normal dependency because we

want to use this in production as well

and now what we do is inside our source

folder we create another folder

which we call uter short for utility

code and utility functions

and in here we create a new file

validate nth dot TS you can write it

like this in candid case but the name of

this file doesn't matter it's up to you

and in here we want to import

then between curly braces we write

clean and

from

the invalid package

now why do we write this in curly braces

here and not just the name as before

this depends on how this clean end is

exposed inside this package to explain

it in simple terms sometimes there is a

single default export which is when we

import it like Mongoose with this one

name and sometimes there are multiple

things that are exported from a module

like in this case where we can list them

in curly braces and if there's another

thing then we write the comma and Export

this other thing as well entry will

actually see an example of this right

now because we will do a default export

ourselves because from this file we want

to export one single thing which is

basically the zenitized version of our

environment variables so here we write

export default

we want to export the same clean end

that we imported here

but we want to call it because this is a

function so we don't actually export

this function we export its return value

again if this is confusing to you just

follow along the first argument we pass

here are our normal environment

variables process.enth

comma and still inside the parenthesis

we add a pair of curly braces

because then here we do the

configuration

to be more exact we want to list all the

environment variables that we expect

which is our Mongol connection string

and our port

so we paste the name Seal

colon and then we call this Str

shortfall string function

which will automatically import this

dependency here

and this comes from the invalid Library

as well this basically defines that

connection string should be of

type string later

we also add the port after a comma here

because this is a Json object

and this time we call the port

we could also use number or string but

Port has a special type I think it makes

sure that this has a certain length or

shape and now since we export this clean

nth curl here we can import it in

another file and this will give us our

cleaned up and sanitized environment

variables so let's save this file go

back to server TS

and we want to import I put it up here

and from

from our validate and file here and now

we have to pass the location of this

file relative to the file we are

currently in so we want to go into the

parent folder which is Source then

inside util invalidate INF

so we write the dot to go into the

parent folder and auto completion

already suggests uter validate INF this

is where we want to import it but this

depends always on your file structure

but other computation will help you with

finding the correct one

now since this is the default export

here we can give this import any name we

want and it will recognize it because

there's only this one export we could

also called as banana or chocolate

doesn't matter but NF makes sense

because it mirrors the name of the

normal environment variable here

and now it's pretty simple instead of

process.enf we just want to call NF

because this now relates to our clean

end setup we did here

now the port is definitely a number it's

not possibly undefined anymore

because this is what cleanenf takes care

of I can also now remove this

exclamation mark and the IDE will stop

complaining because this is now

guaranteed to be a string and now what

happens if we actually forget one of

these values let's try deleting the port

again as we did before

and restart our server

and now it crashes right away with a

nice error message here missing

environment variable support undefined

and this is exactly what we want because

now we make sure that our server doesn't

run with a wrong configuration instead

it crashes right away so it doesn't even

start

this is better than having it used by

someone already in production and then

it just misbehaves

okay so this is why this is a nice

package let's restart our server with

the port in here

and everything should run

Mongoose connectors are running on Port

5000 by the way this warning here is

just a change that's coming up in the

next major Mongoose version you don't

have to care about this it doesn't play

any role for our project we are building

here let's actually try if we can still

access our endpoint here at localhost

5000 we can still see hello world if the

server is running

however our code organization is not

really nice here we should separate the

parts that contains all the endpoints

and the part that sets up Mongoose and

actually starts the silver one reason

for that is just good old separation of

concerns but the other reason is that

this allows us to test our server code

everything that's contained in this

Express app basically without connecting

to the real production database we won't

be writing tests in this tutorial

because this is boring as hell but when

you write tests in production you

usually insert some dummy data into the

database and then you will just wipe the

whole database and of course you

shouldn't do this in production unless

you want to get fired this is why it's

necessary to separate this code so what

we do is at the same place where our

Observer TS is we want to create another

file so inside the source folder here

we create an app.ts file

and then we want to move some code from

our server TS file over into this new

appts file so we want to move the first

line here Dot and slash config over

there

so we load the environment variables

also if we start this app without

starting the server next we want to move

these two lines over there the express

import and the express call here

which creates our server app

let's actually put this into a new line

because this is not an import it's a

function call

and then we want to move this endpoint

over there so we cut this out and paste

it here as well because this is a zero

endpoint this belongs to our server code

and then in order to use this app in our

server to call it and run it we have to

export it here and again this is a

default export which basically means

that we just export one single thing

from this file

which is our Express app where we add

all the endpoints on if you want to

export this here

and now we want to import this in our

server TS file

so we do this at the very top of our

Imports

import app again we could give this any

name we want because it's a default

export but app makes sense

and it's inside the source

folder as the app file and whenever we

import a file we don't have to import

the file extension as you might have

already noticed

and you have the rest basically stays

the same its format this properly we

still call app.listen now we call it on

its imported app to spin up our server

let's save the server TS file we don't

have to export anything here and let's

see if it still works

so we can still access our endpoint if

the server is running nice

okay our mongodb is connected and now we

actually want to put some stuff in there

right and when we use Mongols we have to

define a model for the data that we want

to put in our database so what we do is

inside our source folder here

we create a folder called model

or models actually

because it will be multiple ones

and in here we create a node.ts file and

as you can tell this will contain our

node model

let me close this terminal don't need it

right now of course this whole process

of setting up models and schemas and

everything is explained in this

humongous documentation

if you have some weeks to spare and want

to learn is in more detail but I will

show you everything you need to know

right now so we need to define a schema

and the schema defines what kind of data

our node should contain

so we write const node schema equals

new schema which is this mongoose

I guess Constructor or function here so

it should import this party at the top

and between these parentheses we add a

pair of curly braces

because this is where we put the

configuration for the schema

okay what data should our nodes contain

each of them should have a title and a

text and also this timestamp that

indicates when the note was created or

last updated

so we put these fields in here

title column

then another pair of curly braces and

you just have to get used to it when

using JavaScript there are curly braces

everywhere it's just curly braces inside

curly braces inside curly braces but

this is how JS works

here we have to define the type so this

is basically a configuration for this

title field in our node schema

the type will be string and you have to

write this in uppercase not lowercase

and we have to write it in uppercase for

all data types in these mongodb schemas

even though a normal code revitamin

lower case this is because those are

actually the constructors of these types

I don't know why exactly but doesn't

matter after type string red comma

we quiet I can't write required call on

true

as the name implies this is another

configuration that defines that each

node has to have a title otherwise

mongodb will not accept it

comma and the next property text

which is another string

but this time it doesn't have to be

required because we want to make the

text optional

and in JavaScript objects you can add

trailing commas even if we don't add

another field which is usually a good

habit because it has some benefits When

We compare changes in Version Control

doesn't matter you can edit your can

leave it out but I like to edit but the

timestamps are still missing right so

now we could add another field created

it make it of type timestamp but

Mongoose can actually add these fields

for us and also maintain them

automatically so we don't add them

inside these curly braces here inside

the schema configuration instead we go

outside of this closing curly brace but

still inside the parentheses add another

pair of curly braces and write time

stamps and we already get a suggestion

column drawer this will automatically

add the timestamps fields for created

and updated to the schema rather than us

having to manage them ourselves but

again you have to put that in the

correct place outside of these first

curly braces here

now for normal JavaScript this is

everything that's necessary to set up

the schema but in typescript we have to

add another step because we later want

to have a type for this node in our code

available so that we get type safety and

other completion for all the fields in

here title and text and everything so

below we write type which is basically a

way to add another type alias in

typescript so to create another type so

to speak

and the name of this type should be node

but again you can name this anything you

want it makes sense because those are

notes and then we write equal sign and

first schema type which is this name

here this type we get from Mongoose

again so it should add another import

then we make anger brackets to add a

type argument to this infill schema type

type

and in here we write type off as one

word or lowercase that's important note

schema

in other words this creates this node

type by looking at our node schema here

and then we are creating a drumet this

is something Mongoose does automatically

for us

and now we just have to export this

whole schema so we can use it in our

remaining code

so again export default

then we have to call model which is

another Mongoose function so it adds

another import

we add another type argument so it

creates a model of type node parentheses

then a string which is the name of this

collection

and again we write note in uppercase

this will later create a collection in

our mongodb database but it actually

turns this into a plural so by calling

this node it will later create a

collection with the name nodes you will

see this in a moment just follow along

combine the second argument as the node

schema

save this

so to recap this code here creates a

schema for our notes which each contain

a title and a text and the timestamps

and then recreate the type for

typescript and Export this model so we

can use it in our code and now let's go

into our FTS file which is our server

code and import this new node model we

just created

so import node model

again we can give it any name since it's

a default export

from

period slash models slash node

and now let's create an endpoint that

Returns the nodes that we put into our

database just so we can see how we can

interact with the database and let's

reuse our existing endpoint here because

we don't need this hello world in the

future

so instead of rest.send hello world we

want to get the notes out of our

database and then return them so we

write cons notes equals

then await

note model dot find we call this without

any arguments

and carl.exec behind it

okay so that's a lot of code what is

going on here so first of all node

model.finds.exec executes this find

operation and then exact returns a

promise we already worked with promises

earlier here but here we use this then

and catch combination as I already

explained a weight is syntactic sugar

around promises so instead of having to

use these then and catch carbacks which

adds this ugly nesting we can just write

it in one line below each other like

normal synchronous code and again I

didn't use this here because we can't

use this at the top level in express by

default but we can use it inside this

endpoint functions here but for this we

also have to add the async keyword in

front of this error function so the code

knows that this is an asynchronous

function and now this error here

disappeared so in other words this will

execute this find operation which is an

asynchronous operation meaning that it

takes a moment because we actually have

to go into our database look it up and

then return it and this can take a few

milliseconds or maybe even a second this

is why this whole process is

asynchronous we don't want to have the

rest of the server to wait just because

we do this database operation this is

where we use promises and isn't a way to

make it a bit simpler again you don't

need to understand this in detail you

can just follow along and it's important

that you don't forget this await

otherwise we will not get the value of

our nodes we will get this promise which

can cause weird errors sometimes if

you're not aware of this so yeah make

sure to add this away here otherwise it

will not work but we don't only want to

get them from the database we also want

to return them to the user So Below

we write something similar than before

we take our response object but instead

of send

we call Dot status

and pass 200 here

which sets the response status to a 200

which is the HTTP status for okay so

everything went fine basically and when

we work with our front and later we use

different HTTP calls to indicate if

there was an error or not and we don't

send a response just in form of a text

we send it in form of a Json which is

basically a way to transfer JavaScript

objects between the backend and the

client you have probably already worked

with Json before and in here we simply

pass our nodes

this will turn our notes into a Json

that resents to the front end and now we

can actually try it out

we can access our

localhost again

we get a successful response and we see

this empty pair of square brackets which

means that this is an empty array which

makes sense because we haven't put any

nodes into our database yet

so let's go into mongodb Atlas again

and know something magical happened when

we click on browse collections there

certainly is a collection oh wow we just

cut notes why is it called notes again

because we cut our node schema node

and mongodb or mongoose automatically

creates this collection from it and it

also automatically pluralizes the name

so note turns into notes because the

collection contains multiple documents

now the database here is called test

because this is what we defined in our

connection string let's actually remove

this and give this a proper name so we

drop this

go back into our code into our

connection string and we go here behind

mongodb.net but before the question mark

retry writes and here we can set the

name for our database

let's call it cool underscore nodes

underscore app

save this

and I think when we change the

environment variables we actually have

to restart the whole thing manually

I'm not sure right now but just to make

sure stop the server and run MPN start

again

let's access our endpoint again which

would trigger the creation of the

collection

and then take another look in here

refresh this

and that is now our database here is

called quillnotes app and we still have

our nodes collection which is empty now

we don't have an endpoint yet where we

can create nodes but we can create them

here manually so let's do that in the

back end here of Atlas it automatically

adds this idea because each node needs

an idea

and now we want to add the title

let's call it my first note

and the text we click this plus here at

another field

color text and rewrite subscribe to

coding in flow and then we go ahead and

click the Subscribe button under this

video

after you have done this we click insert

to add our first node here

and now when we access our localhost

endpoint again

we return our array with our one node in

it nice and this is what we will later

display in our front end

amazing but before we go ahead and add

more endpoints we should have a clue of

how error handling Works in Express

so let's just pretend something goes

wrong in here which of course can always

be the case maybe the database is down

maybe we wrote some bad code whatever

so to simulate this we're gonna throw

and around here like this it's the same

in Java and kotlin and so on

with an arbitrary message

we saved us and then we try to access

our endpoint again which now shows us an

error message the website is not

available in beautiful German the

website is

and even worse

this crashed our whole server when we

look into the console here's our error

and the app crashed and now our whole

server is done we can't access any other

endpoints anymore we get fired our life

is over our wife leaves us all because

we didn't handle errors properly so

let's learn how to do this so we want to

wrap this whole content here of this

endpoint into a try catch block

which looks like this dry curly braces

catch Arrow curly braces and our USB s

chords are the completion

while the normal chord goes into the dry

block and in catch we put whatever

should happen if something up here goes

wrong so if this throws an hour leg in

our case what do we want to do

first of all of course we want to lock

this error

so we write console.log and pass the

arrow here if this error contains an

error message we want to show it to the

user or whoever accesses this endpoint

if there is no message in there we want

to show a generic error message so what

we do is we create a variable and this

time it's a let because we want to

change its value later

colored error message

and rewrite an unknown error occurred

and whenever I write this I feel like a

real programmer because this is such a

pro camera sounding message don't get

confused by this error here this will

disappear in a moment it's just lint

complaining that this is a lead which we

are not changing right now but next we

check if error

instance of error

so we check if this error is actually

the arrow type and this is necessary

because this has the type unknown which

means this can be anything because we

can throw anything in our normal code we

can throw an error but we could also

throw Naya and so on this is why we have

to check that this is actually the type

error if this is an error then we want

to set the error message to

arrow.message

because every instance of type error has

this message property

and then we want to return this it's a

rest dot status

this time the status is 500 which means

internal server error

and we want to return a Json just like

we do for the happy path but this time

we have to add curly braces to define a

Json we didn't have to do this up here

because nodes is an array and the Json

method knows how to turn this into a

Json array automatically but now we

write this Json manually so we also have

to add the curly braces

we add an error field which will contain

the error message

so the user can later see this

so now let's try this out again so our

error is still in here we still have

this Bazinga error that we are throwing

but now when we open this endpoint we

see this error message here because this

is what we return

but the difference is that now our

server doesn't crash because we have

this try catch block so we can still

access our other endpoints our boss is

happier our wife won't leave us and our

life is just so much better but of

course we don't want to repeat this for

every endpoint because this is quite a

lot of code so what we can do is we can

set up an error Handler and the error

Handler will automatically kick in when

we have an error so it works the

following way we go below here and it

should be below our normal endpoint

here we write app.use

parentheses and to add another pair of

parentheses because we want to pass an

error function here so this error and

curly braces

but this function we'll take some

arguments and in Express error Handler

has to take a very specific set of

arguments and it has to be these same

arguments otherwise Express will not

recognize it as an error Handler the

first argument is the error itself

and we have to set this to unknown

just like the type up here

now why do we have to Define types here

but we didn't have to Define types up

here for our rack and rest arguments

this is because since we passed this as

an argument to this get function

typescript is smart enough to infer

these types so it knows from the

signature okay this is a request type

this is a response type down here we

don't have this type inference because

what we pass here could be anything so

we have to declare these types ourselves

this is necessary in typescript but not

a normal JavaScript the second argument

is the request just like up here but

again this time we have to define the

type

which is request and it's important that

you import this one here from the

Express package this is the request we

want to be using and this automatically

adds this request import up here Express

is the default export this is why this

is separate and those are additional

exported types this is why they are in

these curly braces if it didn't import

it automatically type it out by hand

the third argument is response again

from the Express package

and the third argument

card next and it's of type next function

from the Express package

again the error Handler has to take

exactly these four arguments with these

four types and then what we do is we cut

out this part here and paste it down

here

now a lint will complain that we are not

using next and that we could remove it

this is kind of a false positive because

if we remove it express will not

recognize this as an error handle

anymore so we have to ignore this one

here and just keep it the one thing we

could do is we could click Quick Fix and

disable this eslint rule for this line

which adds this comment here and I think

it's a good idea so you don't get

confused later this way we know that

this was on purpose okay so now how do

we forward this catch block here to our

error Handler

works the following way we add the third

argument up here which is next

and it's the same type as down here it's

this next function type

in every route we either have to send a

response the way we did up here or we

have to call next

which forwards this request to the next

middleware middleware is basically a

piece of code that knows how to handle a

request

on our Express server it's a concept

from the express Library you can read

more about this in the documentation

but both app.get and app.juice create

such a middleware the difference is that

app.get and also post and these other

HTTP verbs create middlewares that

create these endpoints that we can call

like slash and later slash nodes or

slash user app.us are other types of

metal Wells that we just use in our

codes to either prepare our response in

a certain way or handle this like our

error Handler here and the error Handler

is a very specific kind of middleware

that basically kicks in when we have an

error we will see more examples of these

middleware Slater so if this confuses

you don't worry just follow along and

again to cut the next middle where we

call this next function this is why we

have this next argument up here but we

don't want to call any middleware we

want to call our error Handler

middleware this is where we pass the

error as an argument to this next

function

so let's save this and see if it still

works

so we access our localhost endpoint

again we still have our error that's

handled

but now our error Handler here handles

this because the error Handler handles

the errors that have to be handled just

sounded cool in my opinion and now we

can reuse this because in every endpoint

in the catch block we just call next

Arrow and that's it

and these middlewares are checked in the

order that we Define them here this is

where we have to put the error Handler

at the bottom otherwise this is the

first one that would kick in but we only

want to get to this one if we actually

have an arrow now one more thing I want

to mention here if this was synchronous

code meaning that we don't have this

async and there's a weight in here

because we don't do a database

operations or other long running tasks

then we actually don't need try catch

because Express is smart enough to

forward this error to the error Handler

automatically however this does not work

right now for asynchronous code this is

why we have to add this try catch block

and call next ourselves however they are

going to change this in the next major

version of Express

right now we have Express

4.18.2 installed when this is five point

something or higher then you can remove

this try catch block because it

shouldn't be necessary anymore this is

an update they are planning so let's

remove this throw error otherwise this

endpoint will never work I'm going to

comment it out

so I leave it in here as a warning and

that's a reminder for you

and just to drive home this whole

concept of middleware slits actually add

another one

right now when we try to access an

endpoint that doesn't exist for example

localhost 5000 slash blah we get this

error message here but it might be a

good idea to create our own error

message that just has a better text than

this one here and we can do this with

another middleware that catches our

requests that go to an endpoint where we

don't have an actual route set up for it

so again we add the middleware with

app.use

and again we want to have this below our

normal routes because this is just a

fallback but before our error Handler

because we actually want to forward an

error in here to our error Handler so it

goes in between these two and in here we

pass another Handler function so another

pair of parentheses

Rick risk next leg up here but without

the end points because you want to use

this everywhere that we don't have an

endpoint set up for

right arrow curly braces

now this time we don't have to add types

again because they are inferred

automatically and to be honest I don't

know right now why it works for these

normal routes but not for the error

routes but it doesn't matter we don't

have to add these types here if we would

have to add them the compiler would

complain so to recap we get to this

middle wheel if none of our rods up here

fits so if we try to access an endpoint

that we haven't set up so what do we

want to do in this case well we

basically just want to throw an error

with a root not found message or

endpoint not found

so recall next and by passing an error

we forward this to our error Handler

right the same as we did up here

so we create an error like this

and we insert a message

and point not found

and now when we try to access an

endpoint that doesn't exist again

it forwards this to our error Handler

and we see our endpoint error message

now at the moment this will have a 500

response which is not quite correct they

should have a 404 response which means

not found rather than internal server

error but we will improve this later for

now this is sufficient alright and in

the next chapter we will set up another

endpoint for creating nodes so we don't

have to do this over the atlas console

anymore and we will organize our code

better into a routes and controller

files

okay now let's organize our code a

little bit better because if we keep

putting these endpoints into this FTS

file then it will be huge after a while

right and we need more endpoints with

more complex logic than this

so we cut out this endpoint here

and what we do is we create another

folder inside source

which we call routes

and inside routes we created nodes dot

TS file for our nodes routes

and here we are paste the code we just

cut out now before we take care of the

import statements and everything we want

to extract it even further because still

this file could be difficult to read in

the future because we have our endpoints

and then all this huge logic in this

Handler function

so what we do is we cut out this whole

part after the comma here

and put this into yet another file

so inside source we create another

folder which we call controllers and

this is a popular way of separating this

and here we create another file called

nodes.ears

um you could give them different names

you could call this nodes and this one

notes controllers doesn't matter it's up

to you but since this already has

different folders I'm actually fine with

having them have the same name and here

we paste the piece we just cut out

so this Handler function

and we want to export this function from

this file so that we can use it in our

routes file

so we write export const and this is

what I explained earlier it's a

different way of exporting something

from a JavaScript module but instead of

our export default where we export just

one thing this way we export multiple

things so we don't add default we just

add export and then the variable of

function or whatever we want to export

we have to give this a name

let's call it get notes because this is

what this endpoint does equals and this

function here

and this time again typescript can't

infer these types here because it

doesn't know what kind of function this

is so now we could either add requests

and response and everything to each of

these arguments separately but there's

actually a more concise way of doing

this we can give a type to this variable

itself the variable that contains our

function and then typescript can infer

the types of these three arguments so

behind get nodes but before the equal

sign we put a column to define the type

of this variable

which is type request Handler here from

the Express package we import this which

adds this import statement here at the

top and now typescript can infer the

types of these arguments as request

response and next function

and we also have to import this node

model here so let's add another import

statement

the same as we did before import node

model

from

and the destination of this model file

here by this time we write two dots

because one dot would go into the

controllers folder two dots goes into

the parent file of that which is source

so now we are inside source

you want to go inside the noddle models

folder and import our node model

now the error here disappeared entry can

also get rid of this

because we don't need it anymore

now we want to use this get nodes

function in our nodes routes

so here we import this function from our

nodes controller the following way

import then we make an asterisk so this

little star icon which means that we

want to import all functions that we put

into this file there will be more later

s nodes controller

from and the destination which is

the controllers folder

and then here we call nodes controller

get nodes

but we don't add a parenthesis because

we pass the function declaration itself

we don't pass the function call And to

clarify something we could also import

it like we did before with these curly

braces get notes like this and then we

could remove this nodes controller dot

this would also work you can do it like

this if you want the problem I have with

this is that this line here grows huge

because there can be many functions in

the controller

so with this way of importing it we add

them to this notes controller namespace

and keep the support statement short but

appear still shows us an error because

the compiler doesn't know what app means

because we are not inside this folder

here anymore where we have this Express

app

so the same as an app we want to import

Express in here

from the Express package

shouldn't matter if you put it below or

above notes controller but this is the

organization I like

and then we have to instantiate the app

but this time we don't want to call

Express because we don't want to create

a whole not Observer instead we want to

use the one that we already have so

instead of instantiating Express

we create a router

with Express dot router you can read

more about this in the documentation but

this is basically a way to set endpoints

on a router and then we later set this

router on our Express app here to add

these endpoints it's pretty

straightforward and then we want to

replace app.get for router.get and again

get means that this is an HTTP get

request

then we make this router the default

export so we can use it in a different

file and that's the only thing we need

to export from this module

so we write export default router

semicolon

save this

and then where do we want to use this we

want to use this in our FTS file

we want to import our new router appeal

and by the way we can delete this node

model because we now handle this in our

controllers

import

s again you can give this any name you

want

from the routes folder

our notes routes file

and then here between const app and our

endpoint node font Handler the same

place where we had this endpoint before

we simply call s dot us to add another

middleware

we Define an endpoint and this endpoint

will be added in front of this endpoint

here right now we have localhost 5000

and this gives us our notes back but in

production we want to have them at an

endpoint that's a bit more specific

right so the endpoint will appear

slash API

slash notes

so later let's say our website is called

quillnotesapp.com then we will get the

notes from coolnotesapp.com API slash

nodes

and we want to forward this endpoint to

our nodes routes

so this is basically like a puzzle

that's puts together we have this

middleware that catches any request that

goes to this endpoint

which then checks the notes routes

endpoints we have set up here and look

which one fits in here we will later

have more endpoints in here as well for

example router.get for a specific node

which then adds additional endpoints on

this API node's endpoint if this is

confusing don't worry you will

understand it when we later actually use

this let's just save every file that's

still opened and then

access this new endpoint so now the end

point directly at localhost 5000 isn't

found anymore because this is now not

where we get our nodes from we now get

it from slash API slash nodes and

there's our node the same as before

but it's better organized now and now we

also want to add an endpoint where we

can create nodes without having to do

this manually in our mongodb Atlas

backend now first of all we need to tell

Express what kinds of data we want to

accept

as messages to the server and we do this

in our FTS file before this route here

at this exact point we add another

middleware app.use

and pass

express.json and call this as a function

exactly like this and this basically

sets up Express so that it accepts Json

bodies so we can now not only retrieve

Json from our get endpoint we can also

send Json to our server when we then add

a post endpoint

so let's save this and add another

endpoint and our notes controllers file

So Below get notes we add another export

const

which we this time call create node and

the same as before

it's a request Handler

equal sign

it's an asynchronous function

because it does database operations

curly braces

entry can already add and try catch book

here because we always need this when we

do something that could throw an error

and in catch we want to do the same as

up here pass it to our error Handler

middleware

before we set up the body of this

endpoint let's add it to our routes

So Below router.get will write router

dot post this time because this will be

a post request we are sending data to

the server in this case our node it will

be at the same endpoint and this is

possible because those are different

HTTP methods so they will not interfere

with each other even if they have the

same endpoint if we wanted to get

different kinds of data then of course

we can't use the same endpoint otherwise

the server wouldn't know what endpoint

this is supposed to be and here we want

to use our newer nodes controller create

node function

save this and go back in here

to finish setting this up

we present the title and text in the

body of this request so first we have to

get these values out of the body we can

do this outside of the try block or

inside it doesn't really matter but this

shouldn't throw anything so I think it's

more correct to put it outside

create a cons title and we get this

value that we send to the server from

the request body so we take this request

object

foreign

and then the name of the variable that

we present to the server entry will call

it title

just like the field in the node itself

and the same for the text

we will send it as the text field in the

request body

then insert try block because this is

now the parts that can throw an error we

want to use Mongoose to create our node

and we also want to save this new node

in a variable so that we can send it

back to the client and we do this so

that we can later put this newer node

into the UI and update the UI on the

client and it's also useful to see the

data we created when we get our response

back so here we call await and again the

await is very important

node model dot create

parentheses curly braces

and I already add the semicolon down

here

and in here we create our notes and we

actually have Auto completion for this

why because this refers to our node

schema we set up here so it already

knows what kind of data this expects

it expects a title which is our title up

here

comma

and the text value

and again the timestamps will be set

automatically

now create returns A Promise by default

which means that we don't have to append

this dot exec at the end which we had to

do up here I don't know why they made

this design decision that we have to

edit up here but not down here but yeah

it's not necessary and then if this

should fail for any reason we get into

our catch block if it doesn't fail we

continue with the drive block so we want

to send a response back to the client we

set the code to 201 which is the HTTP

code for a new resource created we could

other than 200 doesn't really matter but

it's better to distinguish them properly

entry one is sent a new note back

as a Json

save

okay and now this endpoint should be

configured properly because we already

referenced it in our nodes routes file

and this on the other hand is connected

in our FTS file

so this should work now the problem is

we don't have a client yet to send data

to our server and with a web browser we

can only do get requests we can send

something to the server this is why we

will use a tool called Postman which is

really popular for they are working on

server stuff in development because it

allows you to do all kinds of HTTP

requests without the need of a real

client now don't get scared because it

says pricing we can actually use it for

free

so download it for your operating system

run this file and then you have to

create an account

before you can use it which is fine I'm

gonna sign up with my recording account

here again again you can use it for free

and it's very popular tool among

developers so you don't have to be

afraid of this

all right then log in to postman follow

this sign up process here and then we

see us on the other side then we want to

create a new HTTP request and they have

the shorthand here maybe in the future

it looks different but somewhere there's

an option to get a new HTTP request and

it should look like this

and here we select post because we want

to send a post request

we type in our localhost address

localhost 5000 slash API slash nodes

because this is the endpoint we set up

and we want to send a Json body to the

server

so we click on body

on Raw

and then we select not text but Json

and then in curly braces we have to

define the Json here which should

contain the title and a text right so we

write it like this in quotation marks

title colon

my first endpoint note

and the text

this is fun

and then we want to click Send and if we

set up everything properly this post

request should be handled on our server

and it looks good because this is the

response we got back as you can see here

status 201 created this is what we

defined in our endpoint and we get our

new note back which contains an idea and

all the data

so let's look into a mongodb again

refresh this

and excitement there's our new note

this time we created it through our own

endpoint isn't that amazing and if you

made it until here in this tutorial

please go below and leave a like it's

really important to me

of course we can also run our get nodes

endpoint as a get request here which

gives us an array of our notes just like

we got when we did this in the web

browser let's also try creating a note

where the title is missing because we

defined in our mongodb schema

that's the title is required right so

this should give us an error if the

title is missing let's remove this

send it again

and we get an error note validation

failed title path title is required now

this is not a very readable error

message because this comes directly from

mongodb but we will improve this later

for this is nice so here that our schema

is actually enforced however we can

create a notificed the should work

because this is not required in our

schema

and the succeeded so let's take a look

into the database again

and there's our third node without the

text this time let's add one more

endpoint for now to get a single note

because it's interesting to see how we

can access a single node so we go into

our nodes controller again

and just for organization let's put it

here below get nodes

export const get node singular this time

of type request Handler

an async error function with regress

next

semicolon

try catch this is just the kind of stuff

you repeat over and over again

then before we set this up we go into

the routes file

add another endpoint here

router.get

this time we write slash and after that

we'll write a colon

note idea comma

notes controller

get node

now this node ID is basically a variable

which means that whatever we put behind

the slash will be read by Express and

put into the request object so we can

read it in our get node endpoint and

then look up the specific node for this

idea so let's save this file and go into

the

get node function here again entry get

this value is similar to how we got the

values out of the body let's put it

above the dry block

const node ID equals we take our request

object but this time we don't want to

exist the board here

we want to access the params and the

params are these variables that we put

here into the URL directly

those are our strings basically and we

want to take the note idea

so it has to have the same name as we

defined here with the exact same

spelling

and then we use Mongoose inside the try

block to get this specific note so we

create a const node equals

a weight

node model dot finds by idea which is a

special Mongoose function where we can

pass the idea of this model and it will

find the specific document so here we

simply paste the node idea

this time we have to call.exec again to

turn this into a real promise and then

we want to do the same as up here

return this node with a status code of

200

in the Json body

but this time it's the singular node and

not nodes

save

and now let's try this out we can either

do this in the web browser or in Postman

but Postman just formats this a bit

better so I prefer this first of all we

need an ID of a node so let's get all

nodes

and let's get this one here my first

endpoint node we copy this idea

add notes slash and then simply the idea

because this is the structure of the

endpoint we just set up

and as you can see here this returns

this exact node

if we change a letter in here to a

non-existing idea this fails for one

because the snow doesn't exist but also

because this is not a valid object idea

we will add some checks for this later

the important part is that this gives us

the exact node for this idea later of

course a user should only be able to

access their own nodes but we will take

care of authentication and stuff later

and by the way these errors we get here

we also can see them in the console

because we are locking them

which is especially important in

production because if something goes

wrong for a user you want to be able to

go back into the log and see what went

wrong so we see the error here as well

now there's one more package I want to

install here which is just a nice tool

to have this one is called Morgan and

it's just a locking tool so we can see

all the requests to the different

endpoints that were made on our server

which is just nice information to know

so let's stop our server once again and

install Morgan the usual way

and there's not much setup and worth in

this it's just a simple middleware that

we install in our FTS file and above

Express Json right here we add another

middleware with app.use but we have to

import it first so up here we import

Morgan

from the Morgan package like this

and this shows us an error here because

it needs some type files this is

sometimes the case when you use

typescript with certain packages hover

over this error and if you see something

like this try npm is FDF if it exists or

add new declaration type blah blah blah

then you have to copy this part here

is just installation command for another

dependency

which we install right now

npm IR safe Dev adds types slash Morgan

then this error should disappear

we can start our server again and finish

setting this up we simply want to call

Morgan as a function

and pass Dev as a string this just

defines the type of information and the

amount of information we printed the

console you can read more about this in

the documentation but this is pretty

cool because it prints a concise log of

all the endpoints that we access

so let's try this out

let's make a get request again

and as you can see we now have this log

message down here get request on this

endpoint what status code resent back

and so on and this is just nice

information to have especially in

production

this is the endpoint with all the nodes

yeah

this is just something I wanted to add

here and now we already have a real

little server with different endpoints

where we can get information from we can

create new information really amazing of

course we still want to add more

endpoints but it's already a success but

in the next section before we start

adding more endpoints we will improve

our error handling a little bit because

as I already noted at some places we

don't always return the optimal status

code like here for our endpoint not

found error sometimes the error message

is not really good and really readable

like the one we get from Mongoose by

default so next we will take a look at

how we can improve this because it's

important and after that we will add new

endpoints to update existing nodes and

delete nodes

okay so as I already said before we add

more endpoints to our server we want to

improve our error handling here because

that's not quite optimal yet for one our

endpoint not found middleware here which

kicks in whenever we try to access the

endpoint that we didn't set up like

slash API slash blah for example at the

moment returns a 500 status code because

that's what we hard coded in our error

Handler here so we basically use it for

every error but different errors require

different status codes 500 is the status

code for an internal server error which

basically means that something in our

code went wrong and maybe we don't even

really know what but an endpoint not

found error should return a 404 code

because that's the HTTP status code for

resource not found so it's just more

appropriate and it's better for the

clients to work with secondly when we

try to create a node without the title

which mongodb doesn't like because we

said required to draw for the title and

mongodbier at Mongoose and fosters but

if we try to do this it also gives us an

error but with the default mongodb error

message which might be difficult to

understand for users so we want to

provide our own error message instead

and for this kind of HTTP errors there

is a convenient package we can use so we

open our terminal and ignore these error

messages down here this is only on my

site because I tried something a moment

ago and did a mistake but if you don't

know how to open the already existing

terminal

you can click on viewer and here on

Terminal or use the shortcut that's

right next to it this will open the

terminal that you already created before

if there is none you can also create a

new terminal over this menu point up

here that we used earlier

anyway just open the terminal

and then important we want to go into

our backend folder again not into the

root folder where we are right now this

is where you see these error messages

here I'm actually recording this a

second time because I messed this up

before so this is very important so we

type CD slash back end to go into our

backend folder okay actually without the

slash just CD backend and then you need

to make sure that the path looks correct

so we are in our coding and floor learn

course folder or however you called it

earlier and then inside the backend

folder here

because this is where we want to install

this new package so we type npm IO short

for install

HTTP minus errors

and as usual you have to type the

package name correctly otherwise npm

will not recognize it

we installed this

and then we want to install a second one

which are the type declarations again

that we need for typescript to work with

this package

so again npm IR

minus uppercase deal for def dependency

add types slash HTTP errors type it out

correctly and then press enter

and this should have added two new

entries here on our package.json HTTP

errors in the normal dependencies and

the types here and the dev dependencies

we could also create our own HTTP errors

instead of using this package but again

this makes it more convenient so let's

close the terminal with the same

shortcut and then improve our code here

we want to start with this part here

instead of returning a normal error with

this error Constructor

we want to create a new HTTP error which

we do with this function here

from this package we are installed

if this doesn't import automatically or

if other completion isn't there then

type in the import up here manually

and this function also takes an error

message that we already entered but it

also takes a second argument which comes

before the error message which is the

HTTP status code that we want to return

with this error

and as I already said we wanna have a

404 status code for this one because 404

means resource not found which is

appropriate for an endpoint that doesn't

exist comma and the zinc argument is the

error message just as before but the

problem right now is that we hardcore

the status codes down here on our error

Handler so we have to change this code

here as well

below let error message we also create a

new variable again a let

for the status code

we initialize this with 500 because this

will be our file back if we don't

specify a more specific status code then

we delete this line here instead of

checking if error is an instance of the

normal error class we want to check if

it's an instance of this new HTTP error

because we basically want to use this

throughout our whole server code so we

remove this and write if and in between

the parentheses of the if block we write

is HTTP here which is another function

of the HTTP Eros package but this one

didn't import automatically so we do it

manually so after create HTTP error we

write a comma and again create HTTP

error as the default import the other

one is a non-default import so we have

to add it between curly braces like this

and then paste the name of this function

again you don't have to understand the

syntax here in detail just make sure to

type it all the same way if autocomplete

didn't work

okay so is HTTP error down here is a

function which takes an argument with a

steroid serve this will check if this

error is an instance of this HTTP error

from the HTTP errors package

if this is the case we want to take our

status code variable and set it to

arrow.status which we now have available

because status is a field in the HTTP

error class

and the same as before we also want to

set the error message

so we take our error message variable

and set it to error.message

which the HTTP error class contains just

like normal errors

Alright and then the only change left is

replacing our status code that we

hardcoded down here

for the status code variable which is

either whatever status is in the HTTP

error or a fallback of 500 for internal

server error alright and now let's try

this out let's save the code with Ctrl s

open the terminal again and Run npm

start to start our server and then I'm

going to open an endpoint that doesn't

exist again and as we can already see

them because we installed Morgan

previously we now have this 404 response

here and we will see the same when we

look into the Chrome Dev tools when we

try to access an endpoint that doesn't

exist status 404 which is just a better

status code to return and displays an

even more important role when we have

different kind of Errors later now let's

also improve the error messages for our

node routes so we close our terminal

go into the notes controller and let's

start with create node here as I already

explained at the moment when we don't

pass a title we get mongosa's default

error Throne which has an error message

that might not be readable enough for

the average user and also it doesn't

have an HTTP status code associated with

it so it will fall back to our 500 code

for this reason instead of relying on

Mongoose to check the title and throw an

error we want to check the title

ourselves in here and any other field

that might be required this gives us

more control over the error message and

the status code and then the required

field of mongoose itself is basically

just a far back in case we mess

something up but the first line of

defense is the code in our own endpoint

Handler okay but the problem right now

is that the types of our title and text

here is Nia because typescript doesn't

know the type of these variables in the

body here it also doesn't have to be a

string that could also be a number for

example but we can tell typescript what

type of variables we expect in the body

we do this by declaring an interface

which we call create note body

and then we make a pair of curly braces

like this

interfaces are very similar to types

like we declared with this type keyword

here in Mongoose the difference between

interface and types are very specific

and I don't want to explain all of them

here but generally you want to use

interfaces whenever possible because

they are more flexible and there are

certain situations where you can't use

interfaces then you use types instead

for example here in Mongoose we have to

use a type because this is what in first

schema type expects from us we can't use

interface here but to declare the types

of the single fields in our create note

body here we use an interface and in

here we just declare what variables we

expect when we make this create note

request and what types they should have

and we already know what we expect we

expected title

of type string

and a text of type string

now we already know that the text is

optional we don't have to send one so we

add a question mark here which basically

means that yeah we can send this text if

we want or not so this might be

undefined but we actually set the title

to optional as well why because whenever

someone makes a request to this endpoint

we can't know if they actually send this

data even though the title is required

it might be missing from the request and

then we want to decline it right but we

still have these any types here because

we have to actually use this interface

in our request Handler here which we do

by adding a type argument after request

Handler which we do like this with a

pair of angle brackets and then we have

to declare four different types because

this is all or nothing either we declare

no type or all and by all I mean for the

body for the URL arguments the fourth

one are the URL params so there's a

difference between a UI argument like

our node idea and URL params which we

have after this question mark and the

fourth one I don't remember right now so

and the body is the third argument for

the other ones we want to leave them

untouched basically

which we do by passing unknown so

unknown is used implicitly for all of

them if we don't pass a type argument

here we want to leave the type of the

URL params and so on as unknown because

we don't use these arguments here but we

want to set the type for the body so

unknown comma unknown

comma create note body and then again

comma unknown

and when you hover over request Handler

you can see at the order of these

arguments we are passing here the params

the response body request body and the

query

anyway and you might be wondering why do

we pass unknown here and not any because

any is unsafe any basically allows us to

call anything on these variables unknown

is the opposite it's restrictive so I

think if we try to use the query params

now which has Type unknown then we could

not call anything on it I'm not sure it

doesn't matter because if we needed the

query params we would pass a type for

them and not unknown but we only need a

body right now but the magic is not

visible when we hover over title and

text because now they have types they

are both string or undefined and again

undefined is a possibility for both of

them because we don't have a guarantee

that whoever uses this endpoint actually

sends both values over the difference is

that if the text is undefined we don't

care because it's not required but we

care if the title is undefined so we go

into our try block here because now we

are playing around with errors and

whenever we undo stuff with arrows we

have to catch them so that our silver

doesn't crash and we'll lose our job and

everything remember here we check if

and in between the parentheses we write

exclamation mark title

which means title is falzia which is the

case if title is undefined then we want

to throw

a create HTTP error the same one we

called in our endpoint.font

Handler here

because this creates an HTTP error which

we then throw which then gets caught by

our try catch block and forward it to

our error Handler alright and what

status code we want to use we want to

use 400 this time and in case you're

wondering where I'm pulling this from

you can basically just type HTTP status

codes into Google and you will find

different lists with explanations for

these different chords so every

situation every kind of error has an

appropriate status code and as you can

see here for example 400 means bet

request which is often used if there is

an argument for example missing which is

the case here we could use any stereos

code here using the correct one as just

a matter of making our API better usable

for clients so it's a good idea to get

this right and not use any arbitrary

code entry also want to return an error

method Shield

note must have a title

we don't need a return statement here to

leave our code because a thrower leaves

the try block anywhere and goes right to

the catch block

all right so let's try out our new error

message here

with Postman

let's make a post request to our notes

endpoint

we still have the title in the board

here but we want to put the text in the

body and have the title missing

which now should give us a better error

message and that's not it because I

didn't save the code yet so let's save

it and try this again

now it must have a title nice with the

status code 400 so now we handle this

error for this endpoint properly and not

nearly villier like we did before okay

but our get node endpoint here also has

still room for improvement when it comes

to error handling for one we don't

really know if the node ID we passed

here is even a valid node idea or if we

are trying to use find by idea with some

random value that doesn't make sense but

even if the node ID is valid but doesn't

exist the error we get back is just no

but the short return of 404 response and

a proper error message so let's improve

this

so let's start with checking if we

actually get the notes back here or if

it doesn't exist so we simply do an if

check if exclamation mark node so if the

node is neither or undefined

then we want to throw a create HTTP

error

with a 404 code

that says node not found

which is much more readable than this

noise we had before

let's try it out let's save it

and try to access the same endpoint as

before

which now shows the appropriate error

message

with a 404 code okay so this is already

much better

but what happens if we pass a value for

the node ID that doesn't make sense

because it doesn't adhere to the shape

that these nodes IDs have to have

because they need a certain length and

certain kind of characters are allowed

so if we just remove some of these

characters here and try to access it

like this we get our good old and

unknown error occurred in a 500 response

this happens because

doesn't know how to uh handle this oddly

shaped note idea it doesn't have the

expected format here for find by idea

but we can check it ourselves and then

return an appropriate error message and

Status quote if the shape is not what we

expected so above the line where we call

finds by idea

we check if

exclamation mark then we take mongoose

is a valid object idea

we could also import a spelled object ID

directly then we don't need this

stored in front of it but this way I

think it's more readable because we know

okay this is a function from the

Mongoose package

here we pass the note idea

which is the URL argument if you

remember it's this part here and this

time we actually don't have to check if

this value is present or not because if

we don't enter anything here behind the

slash then we don't get to this endpoint

in the first place then we get to the

normal get endpoint so we don't have to

check if this value is null or not

because if we end up in this Handler

then we know that there is a node ID and

it also has the type string by default

so typescript knows that there is a

value when we get to this endpoint but

if this is not a valid object idea which

is what this function here checks for

returns true if Mongoose can cast the

given value to an object idea or false

otherwise so if it's misshaped like we

saw before then we want to throw another

create HTTP error

a 400 response here is appropriate

and error message will be a invalid node

idea

okay let's save this and try it out once

again so we go to the same wrong

endpoint here

refresh this

and this time we have a good error

message invalid node idea and the 400

response

so all of this is not really necessary

but it's got practice because otherwise

we end up with a silver with error

messages that we don't understand and we

never really know what's going wrong and

it's also good to not let any values

through it that we can't really work

with because even though nothing really

bad happens here besides an error that's

not really readable it could cause

problems in different parts of the code

because we are working with values that

don't have the type or the shape that we

expect okay that's it for the error

handling setup for now in the next

section we will add endpoints to update

and delete existing nodes very exciting

okay now let's add end points for

updating and deleting notes to our

server so we go into our notes

controller file

and where we put it doesn't really

matter but let's organize them in an

order that makes sense so I put it at

the bottom below create node we create

an export const

update node

of type request Handler just as before

and it's an async function

that takes a request response and next

function as arguments

just like the other ones

and in here we will also need a try

catch block

and this one will be interesting because

it's basically a combination of our

create note endpoint because we need to

pass a title in the text but also our

get node endpoint because we need the

node idea that we want to update

so let's next go into the routes file

and add this new endpoint here before we

forget it let's put it below router.post

this time it's a patch request

in HTTP patch request is used whenever

you want to update a resource

we set an endpoint for it

which will be slash and then the same as

up here

call on node idea because we need to

specify which node we want to update and

we do this over this URL argument comma

and then repairs notescontroller dot

update node

we saved this but of course we haven't

implemented this function here

so let's go back to our routes file

we want to declare the body here the

same as we did for create node so that

we have types for title and text and we

can check them properly

so above this function

we create an interface which we call

update node audio and then here we

Define the variables that we expect in

the body which the same as before is an

optional title

and an optional text because we can't be

sure that we actually get past these

values by whoever calls this endpoint so

I basically always make this body

variables optional with this question

mark they can always be undefined okay

and I set up here

in get node we don't have to Define an

interface for the node idea because

typescript knows that this is definitely

a string because it's contained in the

URL that we are writing out

now we have to declare an interface for

it why because we want to pass the

update node body as the type to request

Handler but we can't pass unknown for

the URL params as we did up here because

now we want to use them now we want to

use the node idea that we pass via the

URL so we can't set this type to unknown

this time we have to set it to something

specifically because again this is

either all or nothing either we declare

no type here in this request Handler or

we have to Define all that we want to

use so we call this update node

params because those are the URL params

and we expected the node idea to be

passed over the URL programs of type

string it has to have the same name as

the argument here that we put in the URL

and again we don't have to make it

possibly undefined we don't have to add

this question mark here because if we

would not pass this value here we

wouldn't get to this endpoint in the

first place we wouldn't end up here

because this requires a slash and a

value for the node ID Alright and then

we put these two new types on our

request Handler so again a pair of angle

brackets the first one is update node

params

comma unknown

because the second one is the response

body which we don't want to add a type

to because we don't need it the third

one is the update node body and the

fourth one is unknown yet again because

the fourth one is the URL query params

that we are not using here either all

right that now we can get these three

values out of our request objects

we create a variable node idea which is

the part in the URL

which we get over

rec.params dot nodeid Auto completion

works because we are defined it in this

update node params type

cons let's call it new title just to

make the variable name a bit more

descriptive because we are updating we

are not creating a new node

rec.body this time not params but body

because we send the title in the body

dot title

and by the way in case you're wondering

what kind of data you should pass over

the body and what you pass over the URL

it depends a bit and also it depends on

convention we could also send the title

and the text theoretically over the URL

but this would be very unwieldy because

it gets very long and we have to URL

encoded and stuff like that so it's more

appropriate to send the title and the

text via the body and use the note idea

as the identifier in the URL to a

pinpoint to our exact nodes that we want

to update

okay and another variable for the text

which is contained in request.body.txt

so the first one is a string and the

other ones are string or undefined

and then we want to do some checks here

to have appropriate error handling

similar checks as we already did up here

so we can actually copy some stuff

we want to check if the node ID that we

pass in the UL is actually a valid node

idea just like we did for get nodes so

let's copy this part

and pastity on the try block

then we also want to check if we

actually passed the title

which we already did in create node so

let's copy this line

paste it below but we have to change

this to a

new title because this is the variable

name we can keep the error message to

the same you can also change it like you

can't update it node without the title

or whatever but this here is fine then

we want to get the node from the

database so we write const node equals

await

note model dot find by ideal

and repairs the node ID

and let's not forget the exact color to

turn this into a real promise

the same as we did up here already in

the get node endpoint and the same as up

here we also want to check if this node

exists

and show a different error message if it

doesn't

so as you can see there's a lot of error

handling involved here but this just

makes sure that we always return an

appropriate error message and code for

all the different situations

if we end up down here then everything

was fine we can go ahead and update the

node so we can take the node object that

we already have here

and just set the title to a newer title

NZ node.txt to a new text

and then below we'll save the changes

but we store the changes in a variable

again so that we can return it to the

color of this endpoint which allows us

later to update the node on the screen

in our react app because we get the

updated note back we don't have to fetch

it again so we create a cons updated

node

equals a weight

note dot safe

like this

this as the name implies saves the

changes that we made to the node up here

if there is any error that happens then

it will throw we will catch it and

return it to our error Handler there's

also another way to update the node we

could also do it with

node model dot finds by ID and update

then you can pass the node idea and it

changes as a second argument this is

also an option but this will look up the

note again but we already have a handle

to the node because we are fetched it to

check if it exists right so there's no

reason to fetch the node again and we

can just use the save method here all

right and now we want to return the

updated nodes to the color so recall

rest dot status

pass a 200 code

dot Json and SD Json body we return the

updated note and let's also

to our next error call down here to a

card error Handler in case there is an

error but here I did a typo I passed

update node which is the name of this

function it's important that we pass

updated node which is the actual node

that we get back after saving the

changes okay let's also save the changes

to this file and then try it out

let's open Postman

change this to a patch request

and then let's take any idea of our

notes Here

let's use my first endpoint note we need

the object idea because we want to

update this

we pass this here as the URL argument

and we need to pass a body so now if the

title is missing it should still show

the error message that we need a title

for the node node must have a title so

this works as expected

what other errors did we Define here

invalid node ID Let's test this as well

let's put

a title in here

let's change this to updated title but

usern invalid idea

send invalid node idea let's use one

that is valid but

not found so I replace the last letter

for idea node not found

but if we use the correct node idea then

the update should go through

and we should see the update reflected

in our database so one more time

the update went through we get our

updated note back with the updated title

and now when we look into mongodb again

and refresh this

we should see the changes update the

title isn't that amazing but of course

in the future we want to do this over

our react app over our real website but

right now we do it via Postman and this

is already pretty cool okay then next

let's add the delete endpoint which will

be a bit shorter so let's put it below

our update node

endpoint function

export const

and by now it is the second nature for

us

delete node of type request Handler

it's an async error function

with our good old three arguments here

we will also identify the node we want

to delete by its ID in the URL

so we create a const node idea equals

request.params.note idea and this time

since we don't need a body for the

delete color we don't have to pass any

type arguments here and we can use the

default string type for URL Paramus

try catch

in the catch block because our error

Handler over the next function

and then in the try block we still have

to check if it's a valid idea that we

are passing here

so let's copy this part here again

then we want to check if the node

actually exists you can do this step you

could also just return a success

response in both cases either if it was

deleted successfully or if it didn't

exist in the first place there are

different opinions about this but I

think it makes sense to throw an error

message if this node doesn't actually

exist because we expected that it was

there but it wasn't

so as the first step we look up this

node and save it in the variable so

await node model

and again these awaits are important if

you forget them then the return type

will not be correct

node model finds by ideal

replace the node ID param

and carl.exec

then below we check if exclamation mark

node so if this node is null or

undefined

then we want to throw a create HTTP

error and since the note wasn't found we

set the status code to 404

and the message will be a note not found

if the note was found then we go ahead

and call away

node.remove which deletes it again there

is an alternative for that which would

be a node model dot find by ID and

delete or remove I'm not sure right now

which is the appropriate one you have to

look into the documentation I think it's

delete but since we already have a

reference to the node it would be an

unnecessary step towards hatchet from

the database again okay so no dot remove

and then Ria return a status code this

time we don't need a body if we know on

the front end that the deletion was

successful we can just remove it we

don't need the body of the old node for

anything so instead of rest dot status

this time we call send status

with the code 204 which if I remember

correctly means deletion successful or

something like that it's important that

you use send status instead of status

this time like we used in these other

endpoints why because status itself

doesn't send a response Json is the card

that's responsible for actually sending

the response but since we don't send a

Json body down here we have to call Zen

status to set the status but also send

it at the same time so in other words if

you don't add Json then you send status

save

okay let's not forget to add this end

point in our routes file here

so our router dot delete this time

delete is another HTTP verb and the URL

will be slash and again the node ID

entify the skull to nodes controller dot

delete node

save this and then try it out with

Postman

so this node ID up here should still be

valid we change the verb to a delete and

let's go through our different arrows so

let's try and invalid

node idea

invalid node idea let's use a

non-existing one node not found

but as soon as we pass the correct node

idea this node should get deleted and

removed from our database

so zent we don't get a response back

because we only send a status code but

the status code tells us that this was

successful which means that on the front

end when we get this back we know okay

our note was deleted and we can remove

it from the UI

and when we look into the database and

refresh it this node here with the

updated title should be gone

so refresh this

and where is that moment our notice gun

farewell old friend okay in the future

of course we want to protect this via

authentication we don't want to allow

anyone to delete any nodes nearly

villier any user should only be allowed

to delete their own nodes but this is

something we will add in a later section

of this tutorial for now we will leave

our server aside a bit because it starts

getting boring right adding more and

more endpoints that's lame in the next

section we will actually start building

our react app we will get back to the

server here later because we aren't

finished yet but now it's time to write

some react code because that's fun

all right to create our react app let's

go into the folder where we also put the

backend code let's put it in here as

well you can also put it somewhere else

I do this so I can push them to the same

GitHub repository so you can find

everything in one place now when you set

up a newer vanilla react project then

you should do this over the command line

with this special create react app

command which you can find in the docs

or if you just type in create react app

in Google but we basically just need

this command here you can also type it

out by hand instead of copying it

let's do that let's go into this folder

open the command line here and again on

Windows you do this by holding shift

down right clicking open Powershell here

and then we type npx not M but X

create minus react minus app

then we have to give it the name I'm

just gonna call it front end for

organization

and then to initialize this with

typescript we also add Dash Dash

template

space

typescript

so the full command looks like this

npx create react app the name front-end

template typescript

enter and now we let the magic happen

it will install the following packages

create react app blah blah

we type in y to confirm this

okay looks like it went successful now

it saves 10 highest probability of

vulnerabilities so it's probably the

case that it doesn't install the latest

dependencies we can do this later we can

update them for now this is fine we

close this and as you can see it created

this newer front-end folder in our

project which contains a lot of files

that we know already from our backend

we can also see it here in our project

directly

so we have a package.json file with

dependencies we have a TS config file

which is already set up properly we have

a git ignore file with the most

important stuff and we have the source

folder here which contains the source

code of the react project create react

app also sets up some other stuff for

example the whole tool chain that allows

us to compile our code basically into

production code which also minifies it

so it runs more efficient and it can't

be reverse engineered as easily this is

all set up by this create react app

command now first of all let's go back

into the package.json file of our react

app and let's try updating these

dependencies here maybe we can get rid

of this warning about the 10 highest

rabbit here vulnerabilities first of all

I want to point something out as you can

see in react all dependencies are

installed under the dependencies block

even the types and so on and the

dependencies we only need for

development are here and not in the dev

dependencies block you can put them in

the dev dependencies block but I read

their reasoning behind putting all of

this here this is because when we later

built the project everything that we

don't use will be Stripped Away anyway

this is not the case for our back end

but it's the case for react apps this is

where you can just put everything into

the dependencies block and it will not

make a difference so we don't have to do

a install safe def we can just install

everything as a normal production

dependency and by the way eslint is also

configured by default so we don't have

to install this either but let's try

updating our dependencies here but we

are still in the backend folder we want

to get to the

front end photo as we go backwards one

step with CD and then two dots if I

remember correctly right and then we

want to go into the front-end folder and

I'm actually not sure where the

vulnerabilities are coming from so let's

run npm audit

which checks the dependencies so where

is this coming from I don't really know

because I think the dependencies are

actually up to date already I just

checked them a moment ago so let's run

npm audit fix to try to fix them

automatically

no it still didn't work but here it

seems to be caused by react scripts so

maybe there's something wrong in the

latest dependency we could run npm audit

fixed false which were basically set it

to an older version but since this is a

tutorial and you might watch this in the

future where this is not the case

anymore let's just keep it as it is

Let's ignore this for now if you watch

this in the future there might be not

these vulnerabilities anymore otherwise

you can run npm audit fix false which

will set it to the appropriate version

so this vulnerabilities disappear but

for this tutorial we will ignore this

but let's actually run this app because

we can run it with the default setup

we type npm start

and the react app runs on Port 3000 by

default as you can see here so now you

can either type in this localhost

address but it actually should open it

automatically and this is our brand new

react app this is how it looks by

default

the cool thing about developing react

apps is that we see changes that we make

to the code instantly so let's close the

console here let's actually close all

the tabs because most of them are from

our backend code

let's also collapse the back end folder

and then let's go into app.tsx before I

explain what all of this means let's

just make a little change in here

let's change this text to

subscribe to a coding in flow and as

soon as we save this it changes over

here so this is a lot of fun in

development because it's really fast you

can see the changes instantly in the

browser okay whenever we work with react

we have this TSX files if this was not a

typescript but a normal JavaScript

project this would be called jsx and jsx

or TSX is kind of a mix between HTML and

JavaScript so we get this weird mix here

where we have yeah HTML tags but we can

also write JavaScript in these files

entry act as a so-called declarative UI

framework to understand what this means

let's look at the old approach the

imperative approach so usually on

websites we have an HTML file that

contains the basically the structure of

our website where our buttons are where

text is and so on in this example here

we just have a button but of course a

real HTML file has a body and different

components and so on and then we have

separate JavaScript files so we don't

have this mix between HTM and JavaScript

that we just saw a moment ago we usually

have to separate it and in our

JavaScript files we can interact with

our HTML files and we can make changes

to the text of buttons or other elements

for example so in JavaScript we have

stuff like variables because JavaScript

is a real programming language and when

we want to change something we look it

up like in this example we look up the

counter button with this get element by

idea function we can set an on click

listener on it and here we can Define

what we do when we click the button and

imperative means that we are basically

micromanage what happens we say okay we

want to increment the counter variable

and then we want to go ahead take our

button change the text inside it with

this inner HTML card here by changing

this we change the text contained in

this button and then we Define what we

want to set this to we want to set this

to a current colon and a new count this

is how a programming worked in the past

basically the downside of this is that

it's easy to forget stuff like changing

the text properly of course this is a

simple example but if you have a real

app where many different things change

in many different places at different

situations then this is easy to get

wrong and add bugs in the future because

we always have to micromanage what we

change at which point in time right

declarative UI Frameworks changed this

concept a bit and react is one of them

jetpack composes another example of a

declarative UI framework on Android I

think Swift UI is one as well and

flutter too with declarative UI we are

defined one time what kind of data is an

element on the screenshot contain and

then it's basically updated

automatically so this is basically the

same button example as before but this

time it's react code so imagine that

this is a jsx file or TSX so we can put

all of this in the same file the

JavaScript and the HTML code and in a

declarative UI we are defined one time

what kind of text this button should

contain so as you can see we have this

button tag and here we have count colon

entry passes count variable now the

difference to imperative UI is that when

we now increment is counter and we

change this current variable this text

here will update automatically we don't

have to go ahead and there change the

text or the HTML of this button to this

new value nowhere here in this code does

this happen because it happens

automatically that's called declarative

because we declare how the layout looks

the UI and then react takes care of

keeping it in sync with the data it

depends on so whenever the current

changes react knows that the text of

this button has to change as well and it

basically recharge this whole button on

the screen and this is okay because

react takes care of making this

efficient under the hood and the main

benefit of this is really that it's

easier to keep our UI in sync so if we

have many different places and different

variables different states then we just

have to declare how the different

components look and what data they

should contain entry Architects care of

keeping everything up to date as long as

we declared it properly and because we

have this mix between HTML and

JavaScript we can also do stuff like

putting for Loops directly into our HTML

and saying okay depending on the size of

a variable we want to add more or less

items to our layout for example so we

can do some really cool stuff it also

allows us to work create reusable

components that we can use in different

places in our app because we don't have

this arbitrary separation between HTML

and JavaScript which actually was never

a good idea because it's a separation of

Technologies and not a separation of

concerns as it should be but jsx or TSX

fixes this by allowing us to work riding

this mix between HTML and JS and we will

actually rebuild this example in a

moment so let's go back to our react

project

first of all let's install bootstrap or

rather react bootstrap which is this UI

library that we want to use it just

makes it easier to create uis that

actually look good it's completely free

and I think it's easier to use than

Tailwind CSS for example so here are the

installation instructions we basically

want to copy this line npm install react

bootstrap and bootstrap so those are two

dependencies

so open the terminal here

cancel the execution with Ctrl Z make

sure that we are still in the front end

folder and paste this command

while this is installing we take a look

at the instructions again

we have to import this part here

this Imports the CSS so that our

elements actually look good there are

also different ways to install this or

customize this but the rest here doesn't

really matter for us we just want to

copy this line and you can get it from

this URL or take a look into the code in

the description below of my project on

GitHub there you can also copy it from

and Twitter reporters we put this into

the index TSX file here

which is another TSX file just like our

app TSX

now the order of the CSS Imports is

important so we put it all the way at

the top here

and import this bootstrap Min CSS

now index TSX basically initializes our

react app for this it uses another file

in the public folder here which is

called index.html as you can see this is

basically the structure of a normal

website this is a normal HTML file and

this is where our react app appears

later basically so this is our page that

we load when we load our react app down

here we have this root tag and index TSX

looks up this root tag

and it renders our react app at this

place and the react app is the app.tsx

file that we made changes to a moment

ago we don't really change much in this

file besides little things like

importing the CSS because we want to do

this very earlier in our code we could

also do this in the app TSX file but we

actually want to do it before we

initialize the app itself

and here we also see something that we

saw earlier already this text here you

need to enable JavaScript to run this

app if you remember in the beginning

when I disable JavaScript in the browser

without the same text

this is handled by this no script tag

here and if JavaScript does work then we

see our normal route where our app is

rendered in this index HTML file also

contains metadata about our website so

as you can see we have this title tag

here we have a description somewhere and

we also have stuff like the preview

images for social media now you can read

more about this by just Googling or

reading the documentation but let's make

some little changes in here let's change

the title to a

quill Notes app

and let's change the description as well

which is this meta tag here

website created using Create react app

this is what we see for example later in

Google search when our website shows up

there let's change this tool tutorial

project by coding in flow because of

course you always have to give

appropriate credit

then save this

now when we run npm start again

and look at the page again

after the test started

we can see the changes to our metadata

now the title says Square Notes app we

can't see the description but again we

would see it in Google search for

example the little fav icon here on the

top left this little icon you can see

here is also something you can change in

this index HTML file there's a path icon

text somewhere this one here

there are generators for this kind of

icons that you can find in Google but we

will leave the rest here untouched

also interesting to notice the public

folder here this is where you put files

like images that you want to use on your

website we won't add any images but

these react pictures here that we saw on

the page are inside here you can delete

them if you want you can also leave them

there it doesn't matter and if you want

to learn more about these different

folders and file types that I don't

explain here then of course everything

is explained in detail in the

documentation

and now as promised let's rebuild our

button example our button clicker that

we saw a moment ago on the slides for

this let's go into the app TSX file

because this is where the code of our

actual app lives basically of course

later we have different pages and

different components and we create

separate files for them but they are all

put here in one way or another we will

talk more about the syntax of these

react components later but for now let's

ignore this and the first thing we need

for our calendar is a variable of course

that maintains the current count now the

first idea would be to just create a let

counter and initialize this with zero

but in react we need a special type of

variable for the state of a component

because we need to notify react that it

has to redraw the UI to display the new

value so we don't use a normal variable

we create a state like this const

then we make a pair of scrap brackets

and then here we write click count which

is just the name we give this variable

comma and the second variable in here is

set click count so we always have a

variable and then we have basically a

function with the same name but just set

pre-appended to it outside of the scrap

brackets we write use

state which should add this import

statement up here if it didn't edit

manually and we initialize this with

zero

and because typescript has Type

inference as usual it knows that click

count is a number because we initialize

it with a number

so this weird syntax means that your

state basically returns us a little

array with two values and create

destructure it like this we take the

first value call it click count and the

second value which we call that click on

one is the value itself and one is used

to update the state and we do all of

this here at the top of this F function

before the return statement because the

return statement Returns the actual UI

element okay and then we want to put our

button somewhere let's remove this learn

react link we don't need it anymore

instead create an opening anchor bracket

button which creates the HTML element

entry One Import button here from the

react bootstrap package which adds this

import statement

we close this and in between this text

we can now Define the text contained

inside this button so for example if we

just write click zero times and save

this

we see the change in our UI this is the

bootstrap button just for comparison if

we didn't use bootstrap but the normal

HTML button it would look like 1993 but

we use these special styled bootstrap

buttons but of course we don't want to

hard code the zero here we wanna show

our click count

so instead of 0 we write a pair of curly

braces because this is how we put a

variable in between these two pieces of

text

and in here we pass the click on

when we save this it still says 0 but

this time it's coming from this state up

here and now as I explained the magic of

declarative UI is that when we update

this click count over this set click on

function the text in here will change

automatically we don't have to

micromanage this like in the imperative

approach and we want to change this

value on when we click the button so in

the button opening tag we can add an on

click function like this make sure that

you get the spelling right candid case

with an uppercase 0. and in here we want

to pass a function we pass an anonymous

function like this

pair of parentheses a right arrow like

we did in our server code and since this

is only one line we don't have to add

another pair of curly braces instead we

can just call the function that we want

to call directly we want a car that

click count

and we want to set this to a click

current

plus one

two add one to the value that we already

have let's save this and try it out

now when we click our button the state

gets set to a click count plus one so

zero plus one is one and since we

updated the state react notes that it

also has to update the content in the

button

and this time it's really difficult to

mess this up in the future with that how

this button should look what data it

should contain

and react takes care of updating it

properly okay we Now understand

declarative UI and you can put react

developer on your resume but of course

if you want to learn more about react in

your short stick with this tutorial

because the next step is to actually

fetch the nodes from our backend and

display them in the UI somehow

okay so before we can fetch the nodes to

the front end we need a model for the

nodes on the front end as well so we

create a new folder in our source folder

here in our front-end folder so in our

react code

and we call this lowercase models not

uppercase

and then we create a file in here we

right click new file

and we call it node.ts attention this is

not a TSX file this is not this weird

HTML JavaScript combination it's just a

normal typescript file because all we

put in here is one interface that we

want to export so that we can use it in

other places we call it node

and this will contain the shape the

structure of our node type that we

receive and use on the front end okay so

every note we will get from our server

will contain an idea with an underscore

because this is how a mongodb

automatically saves IDs underscore idea

and it will be of type string now

technically the idea in mongodb is a

different type it's this object ID type

that we used before but what we will

receive from the endpoint will just be a

string and that's all we need to work

with every note will have a title of

type string

the text of type string but the text

remember is optional so we add the

question mark here because there might

be a text in the node or not and then

the timestamps are created at and the

spelling has to be correct because this

is the name with which mongodbier stores

these timestamps and this will also be

of type string because rotary receive is

basically a string representation of the

timestamp and the reason why everything

is a string is because we receive Json

from the back end and Json doesn't have

where we elaborate data types there is

no date type in Json for example but

string will suffice because we can pass

everything from the string that we need

okay and then updated it

which is also of type string

let's save this because this is all we

need in here

all right and then let's go back into

our app TSX file because instead of a

borrowing counter we want to retrieve

our notes here and display them in the

UI so let's remove this line here with

the click count

and replace it for another state so

another const with the square brackets

and these two are variable names in here

we call it notes and the equivalent as

the zetter function is z nodes there's

always this pair between the variable

and the zero when you use State and

react

equals use state

and this will contain the nodes that we

display on the UI in form of a array we

want to initialize it with an empty

array

because at the beginning when the site

is opened there isn't any data in there

yet we have to fetch it from the back

end first but this way typescript

doesn't have enough information to infer

the type properly so when we hover over

nodes it's of type never array so we

have to tell typescript what type the

state has to be later and we do this as

usual with a pair of angle brackets and

the type will be our newer note type we

created in the models folder but it will

be an array an array of notes and now

nodes has the correct type here

okay but now the question is where do we

load these nodes we can't just put it

directly in here inside the body why

because if you remember I explained that

react basically redraws this whole

component whenever something in it

changes and it does this by executing

this function again so now when we do

something in the function body which is

called a zeit effect so something that

doesn't belong to the rendering itself

but something that happens in our normal

app flow and we do it directly here

inside this body then react will execute

it on every render every time this

function is called which of course isn't

what we want it's way too often instead

we want to load our nodes one single

time when the app starts in this on

click Handler down here we didn't have

this problem because this only gets

executed when we click the button we are

not calling this function in the body of

our app component we call it only when

we click something so this is an

appropriate place for these side effects

but we don't want to have to click

something before we load our nodes we

want this to happen automatically and

for this we use something called us

effect as usual if it didn't import

properly added up here next to you state

it's a react import and this is a

function that takes another function as

import so we make a pair of parentheses

and put another pair of parentheses

inside it

and the right arrow so an error function

and a pair of curly braces

like this

refuse effect we can execute side

effects outside of the Year rendering of

the component itself in here we have

control over when it executes and how

often as you can see the documentation

says accepts a function that contains

imperative possibly effectual code in

here we want to load our nodes so we

basically want to do

const response equals

await because it's an asynchronous

operation we have to load something from

the back end this can take a moment and

to fetch data in react or in JavaScript

in general we have this fetch function

available that takes the URL and some

configuration and here we pass a string

and the URL where we want to fetch the

data from that's HTTP colon slash slash

localhost colon 5000 because that's the

address of our server in development

slash API because this is how we

configure the endpoint right

slash nodes

and then after the string we write a

comma because here goes some

configuration for this request for this

fetch call and in between curly braces

we write method colon and then get as a

string in all uppercase

this configures that we make a get

request with this Fetch and not a post

or a patch but a weight complains

because we only can execute a weight

inside an async function but when we try

to make the function and use effect an

async function we get this lint warning

effect callbacks are synchronous to

prevent race conditions but they also

tell us the solution put the async

function inside

and then they are basically doing this

so we remove this async here again and

we simply have to wrap this inside

another function which we can then make

async so we create an async function

which we call load nodes doesn't take

any arguments and then we take our line

here cut it out and put it inside

and then we can simply call this

function below

to execute it this way we don't have to

make the use effect itself async and

display react is happier also this fetch

car can throw an error if something goes

wrong so we have to wrap this into a try

catch block so we create this try catch

block cut out this line once again put

it in here and in the catch block we

will simply lock this error and show a

message to the user we related to the

more elaborate error handling but for

now that's sufficient zor rewrites

console.erlaw

pass the error which we are printed to

the error console

and then we can also call alert and pass

the error here as well alert opens a

little pop-up window in the browser it's

not very beautiful and it's not a great

user experience but for development this

is sufficient okay then we go be a load

the fetch line again because now we want

to get our data out of this response we

are still inside the dry block so

everything went well

we create a const nodes

and then we have to add another weight

because passing the data out of the

response is another asynchronous

operation

then we take response and carl.json

which passes the Json body out of this

response and when we take a look into

our

nodes controller

we remember that real

return our nodes

as a Json to the front end so this is

what we get out of here when we pass

this Json

and then recall set notes which is our

state function here and paste in your

notes

this way we update our state and

wherever we use these nodes in the UI

this part now gets updated by react and

we can display this new state one more

thing that's important we have to pass a

dependency array to use effect we do

this down here after the function which

is the first argument that we passed

rewrite the comma and an array with two

scrap brackets in here you can pass

variables that whenever they change they

will execute this use effect again if we

pass an empty array like this then use

effect we'll only execute one time at

the beginning this is exactly what we

want however if we would pass no array

at all this would again execute on every

single render and this is pretty much

never what we want because this is the

same effect as if we put it directly

inside the body without the use effect

so if you want to execute something one

time you pass an empty array like this

okay and we haven't designed a layout

for our nodes yet we will do this later

for now let's just display the data that

we get back in the form of a string so

what we do is we remove this whole

header here because we will create our

own layout later

and we want to display the value of our

state variables so we make a pair of

curly braces and in between we write

Json and uppercase

dot stringifier which as the name

implies can turn a Json into a string

such as that we see that we actually get

some data back and here we pass our

nodes

then we save this and we are try to run

this first of all since I closed

everything I have to start the servers

again both the front and and the backend

so ICD into the backend code

Run npm start here to start a server and

then I'm gonna create a new terminal so

if we have a separate one for the front

end and again you can do it via this

command here a new terminal

here icdn to the front end

and Run npm start here as well

and then react will open this on

localhost 3000.

and let's see what happens so this is

the alert dialog that we wrote here

which means that there's an error that

happened so let's look into the

developer console which is a good habit

to get used to anyway as a web developer

let's refresh this to see the error

here it is in beautiful red

and it says course but we see the actual

error message in the console failed to

fetch access to a fetch at our server

endpoint from our front end address has

been blocked by course course stands for

cross origin resource sharing and it's

basically a security mechanism that

doesn't allow our front end to fetch the

data from our server because they are on

different addresses localhost 3000 and

5000 count as different addresses now

there are two ways to get around this

either we have to configure on our

server that we are allowed to fetch data

from this address but this problem

actually doesn't exist when both the

front end and the back end run on the

same address and later in production we

will actually deploy everything to the

same URL just that our server code will

be behind this slash API endpoints but

later in production we will not have

this course problem we only have it now

in development because we have these

different localhost addresses but there

is something we can configure in reacted

that will make it look as if the request

is going to our own address we will do

this in a moment with something called

proxy first I want to clarify a few

other things first of all why did

Postman not have this problem why was

Postman allowed to fetch these resources

this is because the security mechanism

is actually enforced not by our server

but by the browsers so Chrome for

example implements the security feature

and every browser can decide if they

want to adhere to this or not and

Postman just ignores it basically

because it's a development tool Postman

knows that we don't need a security

mechanism when we use it because it's

not a real browser we're not actually

observing the web like a normal user the

other thing I want to clarify is as you

can see everything gets executed twice

we see our error messages drives and

when we refresh this we should also see

the alert message twice don't get

confused by this react just renders

everything twice in development as a

reasoning behind it that is written

somewhere it makes debugging easier

apparently but yeah it executes

everything twice so don't get confused

by this this will not happen in

production it's just a development

feature but yeah now let's go back into

our project and implement this proxy I

was talking about for this we go into

the package.json of our front end

which was generated automatically

earlier and somewhere in here we put

another key I'm going to put it above

the dependencies

which is called proxy colon and then we

basically just pass the URL of our

server in form of a string so HTTP colon

slash slash

localhost colon 5000.

we saved this then we go back into the

ftsx file and just remove this part here

because now the proxy knows that these

relative URLs will be added to this URL

and this way it also doesn't have

problems with calls because it

recognizes this as its own URL basically

this is just how this proxy works then

we have to save everything and we have

to restart our front end otherwise this

proxy doesn't go into effect so we open

the terminal of the front end press Ctrl

Z confirm it

and Run npm start again

and lint complains about some unused

stuff

but it's just because we haven't deleted

it you can do this if you want but it

automatically opens the page again and

you can see our notes array from the

square bracket you can see that this is

a Json array

and it contains our first node and our

other one and even though our website

wouldn't win a design price yet it's

already a queer feeling that we receive

our notes from our own server on our

react front end right and this is the

raw data and we can then use this raw

data to put it into good looking

components and display them in the UI

this is what we will do in the rest of

this course one more thing I want to

clarify this proxy approach works

because we have our own server and our

own front end if you want to build a

public API where different clients can

access it then you might have to set up

course properly to allow these different

Origins

and you can do this very easily with

this course package here you can install

this on the back end with npm install

course and then the setup is explained

here it's a very popular package over 5

million weekly downloads

but we don't need it because we are not

building a public API but just in case

you want to build something like this

and by the way if you were got to this

point and haven't liked the video yet

then I really don't know what's wrong

with you leave some support I put out a

huge course for free and you can help by

just leaving a like on the video because

it helps this video grow better and

reach more people thank you very much

okay to make our notes better looking

than this string representation here

we have to create a component for our

nodes a component that contains the

layout of each node Zoom we go into a

desert bar here into our front-end

folder and inside source we want to

create a new folder which we call

components

and this contains all kinds of single

components as opposed to stuff like

models or later our Pages which also go

into a different folder we right click

on our new components folder create a

new file

and colored node.tsx this time so this

is this HTML JavaScript file and not

just a normal typescript file

and react components come in tour forms

either a class or a function I've

actually never built a component as a

class because this is the old approach

this is what I used in the past before I

started learning react now these

components are all created in form of

functions and the app itself which is

our front page basically is also a

function so such a function creates a

piece of UI basically and we want to do

the same thing for our node component

now we will type our dysfunction by hand

once and then we will install an

extension for the s-code that gives us a

shortcut for that so we can either write

it like this function or we can declare

it as an error function and the

extension we will later use also creates

error function so let's keep this style

so we create a const

uppercase node

equals

and then we create an error function

like this a pair of parentheses a right

arrow and a pair of curly braces

and then below we want to export this

function so we write export default node

and now in here we can declare the UI

for a node and then we can use this in

different places in our app but in order

to display the data of each node we have

to pass the nodes to this component

right otherwise where do we get the data

from

so to declare what types of data this

node should receive we have to create

another interface

again this is only necessary in

typescript and JavaScript you don't need

types so you can just pass everything

nearly Billy but we don't want to do

that we want to be a bit more

descriptive but safe and you can call

this interface anything you want I think

a good naming convention is the name of

the component itself

and then props appended to it props is

what we call the arguments that we pass

to our component I think it's short for

properties

and we want to pass a note to it what

kind of note our node model so we write

note and import this model's node type

here now it's a bit confusing that our

node model and our component here have

the same name and this can also cause

problems but I don't really want to name

them differently but we can use an alias

for the name so what we can do is we can

go up here behind import node

and write as note oops node model this

way we keep the name of our node

interface here as it is

but we use it under a different name

inside this component so in here we

change this to node model as well

gonna add a trailing comma it's not

necessary but I like that and then we

add this as an argument to our node

function here and we use this

destructuring syntax where we write a

pair of curly braces

the name of the variable the name of the

parameter which is the same as up here

node and outside of the curly braces we

write colon note props and if we add any

more arguments up here to the interface

then we also add them to this list so

comma and then the next one

and now we can use this node data inside

this node component and what we want to

do is we want to draw some cards on the

screen from the react bootstrap package

because they look pretty good

you can read the documentation with all

the features that are available all the

styling options

but for this tutorial you can just

follow what I write here so in this

function body here we want to return

something because what we return is the

UI that gets drawn on the screen

we put it between parentheses because

this allows us to write something below

it Beyond many lines and this just makes

these parentheses necessary so that the

return statement knows what belongs to

the return

here we write open the anchor bracket

uppercase cut and we import it from

react bootstrap

close this which automatically adds the

closing tag

and here we put a card dot body tag

close it as well

and then another one in here cards dot

title

and for the title we want to use the

title of the note so we make a pair of

curly braces and in here we write

note which is the node model that we

pass to the component dot title

let's leave it like that for now see how

it looks and then add the rest of the

notes to it arguments that you pass to a

component like our node here worked the

same as state whenever a state changes

react knows that it has to update the UI

that depends on the state whenever an

argument that we pass to a function

changes react knows that it has to

update this component as well which

means that if we make a change to a this

node object that we pass to this node

then react knows that it has to withdraw

this component and show the latest data

let's go over to the ftsx file again

first of all let's change the name of

our node model here as well so we don't

have this clash between the model type

and the component name

we change this to node model as well

and then we change the name here in your

state

and then instead of just stringifying

the notes we want to turn our notes into

this note card we just created

so we keep the div

add a pair of curly braces then we take

our notes which is our data the node

model array and Carl dot map

and map is not something specific to

react but if you're not familiar with it

map allows us to take some data like the

array of our nodes here and turn it into

something different this is exactly what

we want to do we want to take our raw

node models and turn them into a node

component objects and we do this with

map and since we are in this TSX or jsx

file we can write normal JavaScript in

here we can add Loops we can add map

calls and so on this makes this whole

thing very flexible because now we can

map our data directly to this HTML

components so map is a function so we

add a pair of parentheses and then we

have to pass an error function this

error function takes an argument which

is each node object in our array so we

write node and the right arrow so this

way we get past each single node of our

array and now we can decide what we want

to transform it into we want to write

this in a new line so we add a pair of

parentheses

just like we did over in our other

component in a return statement and now

here we want to create our node

component so we write opening angle

bracket node which comes now from our

components folder

this is the node TSX component we just

created

we close this with a slash and a closing

angle bracket and this still shows an

error because this expects an argument

which is the argument that we defined up

here it expects a note where do we get

this node from we get it from the map

card here so we pass it in between now

one more thing whenever we have a list

of stuff like this our list of nodes

we have to add a key

to the object as well this key property

is there automatically we didn't have to

add it to our node it's just added by

react by default now sometimes lint

complains about this but this time it

doesn't I'm not really sure why but we

should add the skill otherwise there

will be a warning in the console later

equal Zone curly braces and for the

value of the key we have to pass a

unique identifier for each node this is

just necessary for react to know when it

has to redraw this node and what is a

unique identifier

now the idea is always unique to each

node so let's use that one

so let's save this and see how it looks

so I open our localhost again and we

have our two nodes it's still not

beautiful but something happened on the

screen this is supposed to be a card

this is the card's title and this is our

two notes so now let's improve the

styling so let's go back into the node

TSX file and finish the styling here

first of all we don't only want to use

the title value in here we want to use

more values and instead of writing

notes.title note dot text and so on we

can use the same destructuring syntax we

used to appear to unpack these single

Fields basically that's just a simple

JavaScript feature what we do is we

write const

a pair of curly braces after the closing

curly brace you write equals note

so we are unpacking this node property

here

and let's see if we have other

completion yeah we have because I

already added this equals node and then

we want to list each field that we want

to use here in our component we don't

need the idea but the other ones

supervised title comma text

created at comma

updated at comma and now we can just

write title here instead of note or

title which I just like more because we

already know that we are inside the node

component so this word is enough in my

opinion so below a card dot title

we add the card dot text

again you can see these different texts

and the combinations of them in the

bootstrap documentation

here we want to write the text let's

save this and we see the changes

immediately

only this node here has a text but of

course we also want to style these notes

with CSS we're going to change the shape

the colors we want to add Shadows later

and so on so we have to write some CSS

now we could put the styling into the

app.css file that we already have

there's already some default code in

here that we got when we render create

react app command but I don't want to

write Global CSS because this later

makes it difficult to organize your CSS

properly because there can be clashes

between different classes with the same

names instead we want to use CSS modules

so what we do is first of all we delete

this app CSS file so we selected press

the delete key and delete the sucker we

also have to remove the import statement

here from the app TSX file

so it compiles again and then we want to

remove this class name app here because

we just deleted this whole CSS file so

let's remove that as well

and we still have this index CSS file

which is imported in the index TSS file

here

but we don't want to delete this we want

to make this our Global CSS file because

even when we use CSS modules we want to

have one single Global CSS file for some

stuff that we just want to set up once

globally and not for each component like

the font throughout our app for example

so what we do is we change the name of

index CSS by clicking on it and pressing

F2 on the keyboard or right click rename

whatever you want let's call This Global

CSS to make it clear that this is a

global CSS file

going to the index file change the name

here as well

and this will be the only place where we

are allowed to write Global CSS code and

let's actually add something new in here

let's set a background color for our

whole app so in the body tag

we add background colon

and then a pound symbol or for your

Zoomers out there a hashtag f-a-f-a-f-a

which is this very subtle light gray

that you can now see here

but now for our node component we create

the CSS module so that the CSS of our

node component can't clash with any

other CSS and let's create a separate

folder for our CSS files

so on source and our front-end folder we

create a new folder called styles

first of all let's put our Global CSS in

here

we might have to update the import in

our index file

to a slash Styles slash Globus CSS

okay it works again and then we create a

new file in here

which we call node Dot

module.css and as the name implies this

is how we create a CSS module with the

name Dot module.css

in here we want to create two classes

which we do with a DOT this is CSS

syntax

note card and candle case

and another one called card text this is

the tour pieces that we want to style

for now before we set this up let's save

this and add it to our node component so

in our node.tsx file we add another

import statement let's put it all the

way at the top

import styles

which will be the name of the variable

of our CSS modules you can also give

this a different name

from

and then the path of our node module CSS

file so dot dot slash

Styles slash node Dot module.css

and now we can use the CSS module in

here and it won't clash with any other

components it will be ignored by other

components unless we are imported there

as well we want to use one of the

classes here for the whole card

so we add something to this card opening

tag

class name but instead of a string we

add curly braces and pass Styles dot

note card which is the class name that

we adjust added here to the node module

CSS

and we want to use the other class here

on the text

so we add class name here as well

Styles Dot card text with the same

spelling as in our CSS file

we save this and then we go back into

the node module CSS file now we can

style our node in here let's start

simple let's set a background color on

each node

and you can use whatever you want I'm

going to use this conzig which is this

yellowish color

and I also want to style the text and to

show you what I want to do exactly let's

open the database again and I'm gonna

add a text here to the node that doesn't

have one yet

so text colon

and then I want to write a text over

multiple lines so this is line one

this is line tour let's keep one line

free

this is line four save this and see how

it looks in our front end when we

refresh this okay as you can see it's

all in one line even though I put it in

separate lines in our database but we

can fix this with this white space

attribute and we set this to pre-lions

if this and now it's formatted like we

added it in our database

now our cards don't have room between

them yet which of course we can do with

the margin

attribute

it will look like this later but we

actually want to add this margin in a

different place later so I'm going to

remove it again and if you want to know

where I learned these CSS attributes

from I just learned them through

Googling I never formally studied CSS I

didn't go through a list of all

attributes I just look up and Google

whatever I want to do like this white

space pre-line and then you can find it

somewhere the other thing I want to

point out is you might be wondering why

this is called kala's name and not just

class because a normal HTML the

attribute is just called class this is

because we are in this TSX file here and

class is a reserved name in JavaScript

code this is why they changed it to

class name instead otherwise this

wouldn't work alright so we already

learned some CSS styling our nodes at

least look a little bit more like notes

now we are not done yet we will finish

up the CSS in the remaining tutorial

okay to put our notes into a nice grid

we will use another component from react

bootstrap they provide these grid

helpers here

which are rows and columns and

containers that make it easy to create a

responsive design and automatically

adapts with the screen size

so again you can read the documentation

but you can also just follow along we go

into our app TSX file once again because

this is where we map the nodes and here

we want to shape them into a grid now

first of all we want to change the diff

to a container

which is a bootstrap component let's not

forget to change the closing tag as well

this just adds some padding and zenders

the notes on the screen then in here we

want to set up our grid which we do the

following way

we add a roll which again is coming from

the react bootstrap library and it's

adding all these import statements up

here

and we do some configuration in here we

have to Define at which screen size how

many rows we want to show in our grid

and you can change this however you want

but I tried it out and I found this the

best configuration at rapid small

screens we want to show one column

add medium-sized screens and we have

these different properties for these

different screen sizes MDM we want to

show two columns

and on large screens we want to show

three

we close this and we cut out the closing

tag and put it below our map call here

now when we save this I think we should

already see a difference here you can

see how it grows and shrinks

we don't have three nodes yet so let's

add a third one let's do that with

Postman real quick so we do a post

request

to our notes endpoint

we need the title

let's call it node three

let's also add some body text

this is line one let's just add one line

here the centers and let's create a

fourth note as well

and it says this is line one I actually

don't know how I can add multiple lines

here not sure if I can just do it like

this probably not

so I will add more lines later in our

database

create a fourth note

go into our database backend here

refresh this

I just want to make the fourth note a

bit bigger

so I go into the text here

this is line two

this is line three and save this

take a look at our

front end here again and now we have

more notes

and because of our row setup here

the layout changes depending on the size

of the screen

it's not perfect yet but we are getting

there to add some margin here between

our elements in the grid we add a class

name

to the row tag

which this time will just be a string we

use this g-4 class which is a class from

the bootstrap library that adds some

room between the single elements in a

grid we could also create our own class

in our own CSS component but we might as

well use these predefined ones here

let's again change the size and see how

this looks okay there's still no room

horizontally between the notes

we add this by wrapping the single nodes

that we map in here into column elements

so we go inside this map call here

inside the parentheses Andrea wrap the

note into a column again this is a react

bootstrap import cut out the closing tag

and put it below our node here

now we also have to move the key from

here to the outer element

so we cut this out and put it in the

column

now there should be some horizontal

spacing between our notes as well

as you can see the slices are different

so this doesn't look good yet we will

fix this in a moment we want to get all

of these notes at the same height the

question is where do we put the CSS of

course we could put it into the node

module CSS file here so it will be

applied to every node however I want to

keep the styling of these notes a bit

more flexible and give the outside

component control over how each node

looks the same is the case for stuff

like the Box shadow that appears when we

hover over a node I don't want to bake

this right into the node component

because then every place in our app has

to display it the exact same way instead

I want to declare The Styling on the

level of this page here and then just

pass it to the node also it's a good way

to learn how to pass class names to a

component so what we do is we create

another CSS module in our Styles folder

which we call notes page.module.css

we will use this on the page that

displays our nodes at the moment that's

the app TSX file but later this will be

a separate component in here we put a

node class

and a node colon hover class

this is how you define the styling of a

class in CSS when you hover over it with

the mouse now before we fill this with

actual styling let's use this in our app

TSX file so we go in here

we import The Styling import styles

from

and the path is here dot slash Styles

slash notes page

Dot module.css

and then we want to style our node from

in here this way as I explained this

page defines the styling of the node and

not the node itself or at least part of

it but first we need a way to pass a CSS

class to our node component so we go

inside the node component and we add

another property to the node props

which we give the same name as the

normal class name attribute here but we

make this optional so we can pass a

class name to this component or we can

omit it

and it will be of type string

and then we want to add this class to

our Cartier to the outermost component

so we can style it from the outside we

already have a class in here so how can

we add another one we can change this to

a string and we do this with a pair of

back ticks like this because backticks

allow us to put variables inside the

string so we wrap this styles.note cut

into backticks and then into a curly

braces and we add a dollar sign here

charging this way we put a variable in

here and this allows us to add another

one inside the string so again dollar

sign charging

curly braces and then we pass class name

which is this property here but we must

not forget to also edit up here to

actually add it as an argument to the

component

this now allows us to pass another class

name from the outside if we want to

allow the color of this node to style

this node then we go back to our app TSX

file after saving this

and now we can add this newer class name

property here which is optional so we

can edit or we cannot however we want

and here we now want to pass the class

that we defined in this notes page

module.css

let's take a look at it again we want to

use this node class here

so apts X let me move this over here

so that it's easier to reach

here we want to pass Styles dot note

save this and then we can style this

node from the notes page module

so what we'd want to do is first of all

we want to set all the nodes to a fixed

height of 200 pixels so it looks already

better in our grid

we want to give them a Min width as well

which means that when the screen gets

very small

they can't just shrink indefinitely

which at a certain point looks

ridiculous like this

we want to set the Min width to a 150

pixels

and now they can't shrink

below the size

I also want to add a box Shadow which

I'm going to copy paste

you can pause the video for a moment and

type it it out by hand so add box Shadow

colon and then pause the video and type

out this stuff here or copy it from the

GitHub repository below

this adds a shadow to the hover State

it's very subtle but it looks cool

but we also want to add an animation so

it's not so abrupt

we add this to the note tag

with the transition attribute and then

we write box shadow

the duration which is 200 milliseconds

so a point to a s and then we use this

ease in our animation here

and now it animates to this box Shadow

when we hover over a node

one more thing we also want to change

the mouse pointer toward this yeah this

little hand icon that indicates that we

can click something because later when

we click a note we want to open it

so we add another attribute cursor

pointer and now we have this pointer

cursor when we hover over a node nice

but we aren't done with the CSS yet

let's see what happens when the text of

the note gets longer than these 200

pixels

so once again into our DB

just going to add some more text here

this is line five this is line six line

seven let's add another empty line line

nine

that's a lot of lines

refresh this yeah and it goes beyond the

note which of course doesn't look great

we will fix this on the CSS level of our

single nodes so we go into the node TSX

file once again and we want to add

another class to the card body because

this is where we have to fix this

so class name will be Styles Dot card

body

we saved this

and go into the

CSS module of our node this one here

and add another class for the card body

I'm going to put it here just for

ordering we set overflow to Hidden

this removes the text that goes beyond

the body

but this now it doesn't really tell us

that there are small text in here right

so I want to add some nice effect which

we do the following way

mask image

colon

linear gradient and in here we can yet

specify a gradient

180 deg for degree

the color will be a hashtag zero zero

zero that may be black

but with a 60 gradient to it comma and

then we write transparent

which creates this gradient effect here

when we save it as you can see now this

kind of indicates that there's more text

below it I just like this effect this

way we can give each note the same

height but still not just cut off the

text in this ugly way next I want to add

the timestamp here at the bottom of each

note so let's go into the node TSX file

once again

and here I want to add a card photo

below card text we add another tag

cards.folder

and in here we want to see the created

add timestamp for now

okay this doesn't look great yet because

this is actually the wrong place

we have to put it below the body

here okay the first one doesn't have a

timestamp yet because we created it at

the very beginning directly in our

database also the timestamps are not

formatted yet so it's not really

readable and we also want to show the

updated timestamp if the note has been

updated so we still have to make some

changes

the first change is adding another class

to the footer which again is a class

from the bootstrap Library

which is called like this text muted it

just makes the text a bit more gray

again we could do this ourselves in our

CSS module but there's no reason to not

use bootstraps predefined classes for

that next I want to format the timestamp

properly but I don't want to do this

directly in this component because

that's not really a good separation of

concerns and we might want to use this

in a different place again later

so let's create another folder for that

and our front end folder

in Source we create

a utils folder for all kinds of utility

functions

let's add another file in here

which recall format date dot TS a normal

typescript file

and in here we export one single

function

with the same name

format date

it will take one argument which is the

date and form of a string so let's call

it date string of type string

and it will return a string

we don't have to declare the return type

in typescript but I like to do this

because it gives us a bit more safety

because now this will not compile until

we return a string from this function

and here we want to return our date but

in a nice format and again I found out

how to do this through Google and stack

overflow

return new date

we initialize this date with the date

string that we pass and then we can

format it with DOT tool locale

string this one here

and to this we can pass some

configuration

the first piece is a string

like this e n minus u s

the U.S in uppercase which if I remember

correctly formats this refer you as

styling there are also other languages

Chinese for example but in most

situations you want to use the US

styling comma and I put this in the new

line

take a look at the exact syntax I'm

using here because that's important the

first argument is a string the second

document is a JavaScript object with two

curly braces and here we can do a

further configuration of how we want to

style this date stream until you just

have to follow along

we Define year

as a string and we are set it to a

numeric

we set month

to short and those are just the

different options we have to display the

date for example a year with just the

last two digits or all four the long

name of a month or the short one this is

just the combination I found looks good

day numeric

our numeric

minute numeric and we don't need seconds

here

so this is fine

now we can use this function in our node

component

but we want to display either the

created timestamp or the updated

timestamp depending on which one is

newer so let's put this logic here

inside the body of this component above

the return statement

we create a LED

created updated

text of type string

if there should not be a comma by the

semicolon below we check if

updated ad is created and created at

which means that the note has been

updated because when we create a new

node updated add and created it will

have the same value when we updated node

updated it will be a greater so if

updated ad is greater we want to show

the updated timestamp so with that

created updated text

tool

updated colon

and then the formatted date string so we

call our format date function

and paste the updated add timestamp

if updated add is not greater so in the

else block

we want to set created updated text tool

created colon

and the formatted created at timestamp

now remember that whatever we put inside

this component body without a use effect

will be executed on every render this is

okay because format date is a cheap

operation we can afford to execute this

on every render but if this was more

expensive you should use something

either a use effect or something else

called us memo which you can read up in

the documentation which is basically a

holder for this expensive operations but

cheap simple operations that are very

fast can be done directly in the body of

a component just be aware that this gets

executed on every single render okay and

then down here we don't want to display

created yet we want to display our

formatted created updated text

and when we save this it now looks much

better again the first one has an

invalid date but later we will not add

any new nodes with invalid dates so we

don't really have to take care of this

case because it's just in our

development setup here but let's try

updating a note to see if the timestamp

changes properly

I want to update node three

which has this ID here

let's do it over Postman so it's

actually recognized as an update

we do a patch request to the notes

endpoint to denote with this idea

we keep the title as node 3. and there

this is an updated note body

send this update

it went through

refresh this and now we see our updated

timestamp because now the updated

timestamp is greater than the created

timestamp really nice

our notes already look pretty cool the

layout is responsive

the next step is to add a way to add

nodes through our front end rather than

having to do this via Postman all the

time okay so let's do that next

okay so we want to add a way to add new

nodes through our front end and we

already have all the endpoints on our

server in place for that for creating

reading updating and deleting notes and

now we just need some kind of form in

our react app where we can enter a new

node's title and text and send them to

our server first of all let's organize

our fetch code a bit better so when our

ftsx file we have our fetch call at the

moment where we get our existing notes

from the server and I like to put this

low level code into a separate file for

better organization so that we don't

have these endpoint strings and this

method get in our react components but

rather a clean function that we can call

so what we do is we go into our source

folder in the front-end folder right

here

right click and create a new folder

which I'm gonna call Network

and in here we create a new file

which recall notes underscore API dot TS

not TSX it's not a react component it's

just a normal typescript file and you

can give this any name you want but I

think this won't make sense and in here

I want to move the fetch curl from our

get request here but there's also

another problem this code has right now

by default server responses like 400 and

500 which mean that something went wrong

are not handled as Errors By The fetch

call so they don't end up in the sketch

block here but they should because these

status codes mean that something went

wrong and in this case we want to show

an error in the UI because we don't have

any real data to work with so we have to

do this ourselves if we get these status

codes from the server we have to throw

an error ourselves but to see the

problem let's just throw an error from

our get nodes endpoint here

so in our backend code

let's just throw a create HTTP error

with 401 for example it doesn't really

matter I will remove this in a moment

this is just for presentation and now

when we try to access our front end

through localhost we don't see an alert

that we are normally do in our catch

block here

instead we just see an arrow in the

console notes map is not a function

which happens because we don't actually

get an array of notes back since we

throw this error in our server here I

don't know what we get back now

undefined I guess and our react app

can't work with that but the correct way

to handle this is to actually throw an

error when we get an error response like

401 but again we have to do this

ourselves first of all let's get rid of

this error code here

then we go into our notes API file again

and what we want to do is we want to

create a wrapper around fetch a wrapper

that uses fetch but throws an error if

the status code is 400 or 500 so we

create an async function we don't have

to export it because we will only use it

within this nodes API file

and I'm gonna call it fetch data which

is similar to fetch but it's our own

function you could also call it Fetch

with error I guess but I like this name

this will take the same arguments as the

fetch function itself

so when we look into fetch here we can

see that it takes an input request in

four and an optional init request in it

so let's add the same arguments here

input column of type request info

and an optional init

of type request in it

this way we can call this function like

the normal fetch function

so the next line is const response

equals a weight fetch so we execute the

fetch color itself

where we just pass the input and the

init

that repairs to the fetch data function

and then we do a check if

response dot okay

which is this property on the return

type of the normal fetch Carl

andresponse dot OK will return true if

the response is between 200 and 300. if

it's between 400 and 500 this will

return false so only if the response

HTTP code is okay we want to return the

response

else we want to throw an error so that

we end up in our catch block now our

errors also have a Json body right when

we look into the backend appts file we

set up our error Handler in a way that

the error gets sent back through the

Json body

so let's read this here so that we can

lock it and also maybe display it in the

UI depending on the error so we create a

const error body

which we get with a weight

response.json the normal way like we

also get a real body out of the response

const error message

equals error body Dot error

why error because this is the key we set

on this Json body here so those have to

be the same

and then we want to throw

an arrow

and for the message we will just pass

the error message here

now later we will get back to this

function and distinguish between

different kind of error codes and

through different errors which we can

then handle differently in our UI

depending on the type of error but for

now this is sufficient

now let's put our fetch note skull in

here

So Below

we write export async function because

we want to use this one from the outside

and let's call it fetch notes

it doesn't take any arguments

but it will return

a promise of type node array

now adding this return type here is

optional but I like to edit because this

makes sure that we are actually return

the correct value from here and not mess

anything up when we change the code

later and all async functions have to

return a promise because async is

basically just syntactic sugar around

promises so whenever you create a

function that is async and return

something the return type is

automatically wrapped into a promise and

then we want to take the code from over

here

these two lines cut them out and paste

them in here just with a little change

we don't want to store the Json body in

a variable we want to return it we want

to call fetch data instead of the normal

fetch so that 400 and 500 responses are

treated as arrows and we have to import

a note type here

so let's just use autocompletion

and it should add this import statement

let's save this go back into our ftsx

file and call our newer shiny function

here instead

so first of all I want to import our

notes API file and I import it manually

because I want to import it in a special

way I don't want to import each function

separately I want to add them to a

namespace so we do the star asterisk

symbol write s nodes API

from

and the folder is dot slash network and

the notes API file

and now here we can write

coins notes equals

await notes API

Dot fetchnotes

and now we have this clean function that

we can call here and we hide the low

level fetch code here inside this

separate file I just think this looks

better and it keeps these components

clean but let's see if our error now

works properly so I go into our endpoint

again and I add this

Arrow here once again which of course I

will remove in a moment

let's open our page here again

refresh it and now we get our alert

message here which we do in the catch

block because now 401 and also 500

responses

throw errors and end up at the correct

place now let's also add a function to a

create a new node which we put into our

notes API file as well

let's create an export async function

create note

and this of course has to take input the

node title and the text now we could put

this as separate string arguments in

here but I actually want to create an

interface for that because we use the

same types later in our form and this

way we don't have to repeat title and

text again all the time and when we make

changes we have one single place to

change it

so we put an export interface in here

export because we want to use this from

a different file later

let's call it node input

and every node needs us a title in form

of a string

and the optional body text which is a

string as well

and then we can use this type here as

the input parameter

like this

this will also return something I

promise because it's an async function

and it will return the note we created

when this was successful so a promise of

type node

so we create a const response equals

await fetch data not fetch but fetch

data the endpoint where we create new

nodes which is the same for getting

nodes

so slash API slash nodes

comma

and I put a configuration into a

separate file because this will be a bit

longer so we add a pair of curly braces

the method this time of course is post

and we have to add some headers to our

request to indicate what kind of data we

are sending so we write headers colon

add a pair of curly braces then we add a

string as the key

and the spelling has to be correct

otherwise it will not recognize this

header content type like this with the

same casing

colon and the content type will be

application slash Json this just helps

the back end what kind of format our

body is in of course we are sending a

Json going to add a trailing comma here

we don't have to but again I like

trailing commas

and then we want to pass the body itself

and since we can only send string back

and forth between our server and our

front end we are one a stringifier the

node that we pass here so we write Json

in our uppercase Dot stringify and pass

our node

then I'm going to put the semicolon here

because we are not Savages

okay and if this went successful in

which case it didn't throw then we can

just return

response.json which should contain the

newly created note which we can then put

into our UI

okay and now we want to add some kind of

form to input new nodes and send them to

our backend and for this we will use

bootstrap models

which are these dialogues here that we

can open

and we will create such a model with

some form input in it I think it's just

a quick way to insert new nodes

so let's go into our front-end folder

and create a new file in our components

folder

right in here

let's call it add note dialog and this

one is a TSX file again

and I said the second time we create a

react component we want to use an

extension for that so we click here on

this extensions tab

and I think we should find it when we

search for react or react Snippets

actually

should be this one here

this gives us these different shortcuts

we can use to create stuff like

components and your state and stuff like

that so let's install this but of course

you don't have to if you don't want you

can also just keep typing them out

manually like a peasant

okay and now we can just type sfc

which creates this functional react

component

going to paste the name here

and then we have the return statement

and the export and everything let's

start by creating a minimal version of

this dialog just to see how we can show

it in the UI

so between return

we add a modal tag from the react

bootstrap package

close this

and here in the opening text before the

closing angle bracket we press show

this has the same effect as passing

shower equals true like this whenever

you want to pass through you can also

just pass the name of the property

then in between these tags we add a

modal.header

where we add the close button to the tag

to add this little X in the top right

corner where we can close this model

later

and in between here we add the

model.title

when this tag is just responsible for

formatting the title properly with the

correct text size and everything

and the title will be a add note

let's keep it like that for now and

display this model from our app TSX file

and the way this works is that we need a

state that tells us if the model should

be shown or not and the little animation

for opening and closing this all happens

automatically

we just need to 10 react if it should be

shown or not so below our notes State

here we create another state the same

way we call the variable show at node

dialog

and the zeta function will be a set

show at node dialog in camera case

and we initialize this with us State

faults

and again typescript can infer the type

because we pass false which is a Boolean

so it knows that this variable here is a

Boolean and then we can just add this

dialog like every other piece of UI into

our return statement here where we draw

the UI on the screen we do this within

the container block because it needs

some text on the outside can be a

container can be a div doesn't matter

then we add a pair of curly braces

and now we can do a little yeah react

syntax that might look a bit weird at

first but this is how you can draw UI

components conditionally on the screen

we take the name of our state show add

notes dialog and add two embossance

which means that whatever we put after

that will only be a drawn on the screen

if show at no dialog is true if it falls

it will not be drawn and here we add our

add node dialog which right now it

doesn't take any arguments but let's try

it out first of all I still have the 401

array of course we have to remove this

then since we don't have a button to

show our dialog yet let's initialize

this withdrawal

just to see our dialogue here on the

screen and there it is right now we

can't close it because we don't have a

way to set show at node dialog to false

yet but you can already see that this is

displayed on the screen here

let's set this back to false we will

show this later when we click our add

new note button and I want to mention

something instead of writing it like

this with this variable down here

we could have also passed this variable

as a property and used it as the value

for this show property here so then we

could remove this part here with the two

ampersands and pass show as node dialog

as a property the reason I do it like

this is because when we do it the other

way then any input in this dialog will

be maintained after we close the dialog

so let's say we type in a title and a

text and we close the dialog and open it

again the title and the text will still

be there because this date is contained

in this dialog component depending on

your situation this might be what you

need but in our case I want to clear the

whole form whenever we close the dialog

because if you will try to enter a node

and close the dialog I assume that you

will change your mind and you don't want

to store the input that's right I write

the syntax like this since this will

completely remove this component from

the screen the state inside this

component is also lost just as a little

explanation why we write it this way and

don't use this show property here

instead we hardcore show to true

and handle showing or not showing from

the outside like this now let's actually

go ahead and add the button that can

open this dialog so we don't have to

hard code the state here to true so what

we do is inside this container here

above our node grid

we add a button

which was a add new note

the button gets an on click attribute

where we pass an error function like

this

and this will call set show at node

dialog and set this to true

this way we display our dialog

then we save this we go into our dialog

and we add an interface because we want

to pass some data here

interface add note dialog props

we want to add a way to a close the

dialog now when we click outside of the

dialog or we click the close button all

of this will be detected inside here we

just have to pass it to The Carling

component to tell okay change the state

back to a z show dialog false and we do

this via a callback this might be

confusing at first but this is just how

you do it in declarative UI if you've

been coding with jetpack compose on

Android for example then it works

similarly with these callbacks on

dismiss is a function

that doesn't take any arguments and it

doesn't return anything so write it like

this

added here as the actual argument on

dismiss

we destructured this as we have done

before and use our add no dialog props

type here and then on this model tag

we have this on height callback which

will be a cult whenever we do an action

that closes the dialog this includes

clicking outside of the dialog but also

clicking this close button for example

and here we just want to forward to our

on dismissed callback and since this

doesn't take any argument we can just

pass the function as a reference

directly by its name and we don't have

to pass an error function we could also

write it like this

this would have the same effect but

since this doesn't take any arguments

this is basically a shorthand for the

same thing

we save this and now of course we have

to pass this new property to our dialog

here

so we pass on dismiss

which this time again is an error

function because we want to call such

show at notes dialog

and set us back to files

so let's try this out we open our page

again and The Styling is not great at

the moment we will fix this later but

our button is still and we can use it to

open our dialog so this sets the shower

dialog state to true and when we click

the close button or we click outside it

sets the state back to false and this is

how you show a model dialogues in

declarative UI

now let's finish our add note dialog

and for forms we also have bootstrap

components that we can use they just

look a bit better than the usual HTML

forms you have they look like this of

course you can change the styling if you

want

but yeah you can do a lot with them

okay so let's add these form components

to our add node dialog

we go below the model header and I like

to put a space in here the space has

nothing to do with how the motor looks

later it's just in our code

and we add the modal body for the main

part

and in here we want to put a form and we

use the form from the react bootstrap

package

and then we create our form like this

and I've pulled it into a split screen

again so we can see how this form comes

into a reality

so we need a form dot group and again I

know all of this from the bootstrap

documentation the idea explain how you

have to structure this the form group

will take a class from the bootstrap

Library which is called mb-3 this just

adds some margin at the bottom of each

input field

in here inside the form group we add a

form label

which we call Title okay so that's the

first piece of form

on the screen below the form label we

add a form dot control

which is the actual input itself

this takes a self-closing tag because

everything that we pass to this

component is a property when we save

this we already see the input field but

we have to Define some configuration

here this is the same for react forms

but also normal HTML forms we have to

give it a type which we set to text

this just helps the browser know what

kind of input this input field expects

for password for example we will later

set the type to password which

automatically hides the characters we

can add a placeholder

set this to title

which adds this additional little text

Insider field that is only there until

we insert some text that's it for this

input field for now we will later add

some more stuff but not right now

instead We'll add another form group

below the first one

this will take the body of the node the

text itself

again it takes a class name mbr3

it gets a label

which was a text

and we add another form control

this time we don't set the type to text

instead we do this we write ask equals

text area but as a string like this

which creates this larger input field

where we can change the size of it this

is just another type of HTML input

we can also Define the rows number which

sets the default the size

of this input field so by default this

has a size of five lines basically

again we set the placeholder

to text

and that's it for this component for now

the last thing we need is a button to

submit this form right and I want to

have this button in the folder of the

model it's just a better look in my

opinion

Zorb below the modal body

we create a model footer

and in here we put a button

that was a safe or submit or whatever

you want

and this button takes some properties as

well

we want to set the type of the button

to submit

and this is not an arbitrary string this

has a special effect if we put this

button inside the form here inside this

form tags then submit tells the browser

that this button is supposed to send

this data so it has an effect when we

click it automatically without us having

to add an on click listener this is the

property that tells HTML components that

this button is responsible for sending

the form but since we put this button

into this footer here it's disconnected

from the form as you can see it's

outside of it this way the browser

doesn't know anymore that these two are

connected but we can fix this with

another property

with the form property we can add an ID

here let's say add node form and then we

can set the exact same ID on the form

itself this way the browser knows that

these two are connected so we set an ID

here

and it has to be spelled exactly like

down here at node form

now this button is connected to this

form right now this won't do anything

because we still have to Define what

happens when we submit a form but now

these two are connected I think when we

click it by default the page will

refresh this is how this behaves by

default but we will change this in a

moment now handling forms manually

especially in react can be a bit

trickier because you have to synchronize

it with the state you have to handle

different error States and so on and

also you don't want to retract a UI too

often when your insert some new text

this is why you usually want to use a

package for that which handles the form

stuff and the most popular one for react

is react hook form there's also another

one called formic which hasn't gotten

any new updates in almost two years I

think so this is the one you want to use

it's really good again you can read the

documentation if you want but I will

show you how this works so as usual we

open the command line and we go into our

front end command line here

stop the execution for a moment

and install react hook

form

then let's start our server again

close the terminal

and then let's finish our add note

dialog by using react hook form first of

all we add another property that we pass

to this form we also need a callback

when a note was saved successfully

because then we want to add it to the UI

we want to add it to our list here so we

add another callback called on node

saved

which is also a function but this time

the function takes an argument

so we write node colon which is the name

of the argument and the type of the

argument is node in uppercase

but it won't return anything

and then we add the second card back

here as the argument to our component

then to use react talk form and here we

go above the return statement and there

is a special hook we can use this hook

returns different kind of data and

functions that we then use in our form

so we have to destructure this single

barrier boots by creating a const adding

a pair of curly braces and then we list

them in here before we do that let's go

behind it and write use form which is

the name of the hook so it adds another

import statement

and we have to give this a type which is

the input type of our form here and this

is why I created this node input

interface in our nodes API file earlier

and exported it there because now we can

reuse it here and this is a functions

that we have to call it

and now we should have Auto completion

in here I think so yeah the first one is

called register you will see what we use

this for in a moment the second we need

is handle submit

and then we need the form state which we

want to further destructure which we do

like this colon another pair of curly

braces this just is the beauty of

JavaScript syntax

and in here we have an arrows field

comma and this is submitting callback

this one

okay that's a lot of stuff to add but

just type it out like I did here

then below we create a function that

actually handles submitting a node and

calling our API endpoint

so it's an async function because we do

our async request and we call it on

submit

which is a naming convention for

whenever you do something in response to

submitting a form you can also call this

whatever you want

it will take input in form of our node

input type

then we add a try catch block here

because we do our back end request which

can always go wrong

we lock the arrow

in case there is one and we use another

alert

now in a real app you can use a more

beautiful UI elements than an alert

dialog because it's a bit disruptive and

we will actually do this later in a

different place but for this here this

is sufficient okay when we create a note

we will get the created node back as a

response so we create a const

colored note response

a weight notes API which of course we

have to import here

import Star as nodes API from

dot dot Network this is just write an

error where where the location of the

package itself is we already have one up

here but with the syntax we can't

combine the two we can't cut this out

and put it in front of these curly

braces

okay so await notes API dot create node

where we forward the input

which is the title and the text

okay so on and if this succeeded we want

to cut our unknown saved callback

and paste the note response

toward the color of this component which

right now is the ftsx file this

represents the successfully created

nodes there and we can add it to the UI

the next step is to go into our form tag

here again and add a second property to

it

which will be on submit as the name

implies this is called when this form is

submitted which happens when we press

our submit button because it's connected

to the form right and in here we want to

use this handle submit function that we

get from the use form hook sounds a bit

complicated at first but those are just

steps you have to learn because it works

the same way every single time

so in here we want to call handle submit

and pass an argument to it which is our

own on submit function so this is a bit

weird syntax but this connects the form

to the react hook form package so on

submit is the Callback when this form is

submitted entry pass handle submit which

hence the inputs to a react hook form

first which then does some stuff behind

the scenes and cuts hour on submit

function which executes this part here

so pay attention to the syntax seal even

though we have parentheses and calders

this is not an error function so we do

not write it like this we write it like

this why because this gets called at

initialization not when we click submit

I guess it creates some return value

that it then uses in here I don't know

how this exactly Works under the hood

but this is the syntax you have to use

okay and the way we connect each form

input to a react hook form looks also a

bit weird but again this is how it's

supposed to be done we add a pair of

curly braces here inside this form

control component then we do a three

dots which means that whatever comes

after it gets destructured into its

single components

so we add one thing here which is this

register car but this basically gets

separated into a many different

properties that I get added to this

component to the phone control this is

what the syntax here means it takes

register and it separates them into its

single pieces basically

register is a function that takes

arguments the first argument is the name

of this input field which has to be one

of the properties that are contained in

our node input here that we used in use

form so node input contains a title and

a text and auto completion already tells

us that we have to use one of them down

here because this is what connects this

input field to this value and react hook

form later knows that when we submit

this this is the tidal value that it

will send to our onsubmit function here

again it's a bit complicated at first

but this is how HTML forms work and

react the second argument to register

after the string is some configuration

we can pass in form of a JavaScript

object so we add a pair of curly braces

in here you can for example set up form

validation for example you can use this

required key

and pass a string here for example

required the string is what will later

be shown in the UI if we try to submit

this without input by adding this

required property in our form control

for the text we won't use required

because this one is optional

so here again we are at register like

this and just pass the name which this

time is the text

okay but for our required field we also

want to have some feedback right we want

to have this little red text below the

input field that prints this required

text so inside the form group we add

another component

which is called form.control.feetback

and this gets a property as input

which we said to invalid

there are two types of feedback valid

one which is the screen text when

something when successful and invalid

which is this red text and in here we

want to get the error message where do

we get it from we get it from this

errors property of use form

so to use a variable in here we add

another pair of curly braces

and we pass arrows Dot and we get Auto

completion for our two input fields

title

and this error is undefined if there is

no error so if you didn't try to submit

empty input so we have to add the save

call Operator here which is this

question mark and then the dots behind

it which means that we will use this

message where you hear only if title is

not undefined or null and otherwise this

will return undefined and we use this

message property here which contains the

error message itself which is this piece

here

okay but we only want to show this input

if there's an actual error for the title

right we handle this with another

property on the form control

this one is cut is invalid and we have

to set this to a Boolean

we want to show the error down here only

if there is an error for the title right

remember this is possibly undefined only

if it's there we want to show this piece

down here so what we do is we write two

exclamation marks which takes a value

like our Title Here which is of type

field error or undefined and turns it

into a Boolean true or false so when we

write arrows.title

if the title arrow is undefined this

will resolve to false if the error title

contains a value this will be resolve to

true this is why we use this for this

invalid property here so invalid will be

true if there is an error for the title

and if not it will resolve to false and

it will hide this piece down here react

hook form can also do more sophisticated

validation than just this it can also

recognize certain patterns like email

addresses we will not use that here you

can read the documentation if you want

to get more into it but I just also want

to note that front-end validation does

not replace backend validation because

whatever we enforce on the front end can

always be circumvented for example by

sending a request with Postman to the

back end instead of using our neat forms

here this is why it's important to have

the validation on the back end as well

like we have in our notes controller and

all these different places

where we check if the required fields

are actually present

so this is just for better user

experience but whenever something is

important and has to be taken care of

then you have to do it in the back end

also this is pretty where both you will

later extract this stuff into reusable

foam components so we don't have to

repeat this over and over again but for

now this is fine okay and there's one

more property up here that we haven't

used yet and that's this is submitting

Boolean

I want to use this in the button down

here I want to disable the button as

long as the form is submitting so that

we can't click it tries right we don't

want to submit the phone twice

accidentally

so we can add a disabled attribute to

this button

and set it to this is submitting Boolean

so as long as the form is submitting

this button will be disabled okay let's

save everything

but now let's try it out and we still

have an arrow here because we haven't

passed the unknown saved callback here

yet let's do that now

but let's keep it empty for now I just

want to try it out quickly and then

we'll take care of this so we pass an

empty function here

save this

and now beer should be able to send a

new note to our back end so note from

react front end

this is amazing

let's try it out when we send this the

dialogue will stay opened because we

haven't taken care of closing it yet but

the save button should be a great out

and disabled for a short moment it will

be very fast because we are on localhost

and we don't have to send the data

through the internet but it might be

visible for a short moment and yeah it

was visible for a very short moment

so let's take a look into our database

and let's see if the new node is still

and there it is not from react front end

really nice so this is our first note we

created through our own website instead

of Postman now let's finish up the

dialog let's hide the dialog after we

have sent the note and let's also add a

note to the UI here because right now we

have to refresh the page before we

sealed and actually just realized that I

wouldn't have had to look into the

mongodb database because we can see it

right here but now we want to make it so

that the node appears immediately and we

don't have to refresh the page first so

the first thing we do here

inside the skull back

is we set show add notes dialog back to

false so the dialog disappears and we

also want to add this node to the UI

this is why we have this function block

instead of just one line we want to add

more stuff here we already know how we

update our state right we have to use

the set node scale here

and update it with the newer nodes array

but we don't get the whole array sent

back from our backend we just get our

new node so what we do is we call that

nodes

we pass an array here with scrap

brackets and then we write dot dot dot

nodes

what this does is it creates a new array

and it adds the nodes that are already

in our node State into this array so all

the single nodes that we already have on

the screen are added to this new array

and then we want to add our new node to

it the new node is the argument that we

get passed from this one node saved

callback remember we declared it up here

and here when we call on our saved we

pass our node response

so we can add the name for the variable

here

we can give it any name we want and this

is the node model that we are pass when

we are called this function so after the

comma down here we pass our newer node

so to recap this creates a new array

it adds all the existing notes to it and

it also adds the new node to it which

will then be displayed in the UI

Zoom let's make this bigger and let's

try adding another note

this is a newer react node blah blah

when we save this the dialog should

close and we should see our new node on

the screen but first of all let's try

the input validation so when we try to

save this we see our required text when

we type in something the required text

disappears this is really cool

it's actually try sending a note without

the text this should work

and we save it and it is added to the UI

nice or just one more thing I want to

show you what I mentioned earlier

when I type something in here and I

close the dialog

and open it again the next time the

input is gone this is by Design This is

how I wanted it this is why I handle the

dialog like this as I explained earlier

if you want to keep the input you can

use the show property here like I

explained earlier and now I wanna add

some margin to the bottom of this button

and Center it on the screen

so we add a class name to the button and

again we have this class that we can use

from bootstrap which is called mb4 which

adds a little bit of margin here at the

bottom

but we still want to send that is on the

screen so now we could add the class to

this button and put the CSS code in the

notes page module CSS file but for a

certain kind of CSS attributes that I

use over and over again I like to create

utility classes that I put into a

separate CSS file so let's do that now

let's open the sites bar and add another

file to the Styles folder

which we call utils.module.css

this contains a reusable utility classes

and I'm gonna cut this one block Center

I've actually not seen this name

anywhere else used but it makes sense to

me because here I want to use two

attributes display block and

March and left Auto

and margin right Auto

these attributes together will display

whatever we use this class on yeah in a

way that it is centered on the screen

because margin Auto does this it sets

the margins ordered as an equal amount

of either side so let's save this copy

the class name and use it in our app TSX

file

so let's duplicate this line and we can

do this with shift ielt and pressing the

down key or just type it out again

we call this style utils and we import

this due to its module.css

and then we can use it on our button

now we do the same trick as before since

we already use this bootstrap class we

replace this for a pair of curly braces

a string with back ticks use mb4 in here

and add our other class as a variable so

style your tits

block Center which now centers this

button on the screen and you can reuse

this block Center class in other places

if you want so the layout is still not

finished completely we still need some

room here at the top but we will do this

later when we add our navbar and also we

don't have any loading or error or empty

States yet so right now when we load

nodes from the back end it's very fast

because we are on localhost but when we

do it over the actual internet it may

take half a second or so that's why we

have to add some kind of progress

spinner while the nodes are loading we

also want to add an error state if the

nodes can't be loaded we don't just want

to show the alert dialog we want to show

something in the UI and it also makes

sense to have a special kind of text or

message that shows when there are no

nodes in our database so that the screen

isn't just empty it should say you

haven't added any notes yet or something

like that we will implement this in the

rest of the video but the next step is

to add a way to update existing nodes

and delete them so that's what we will

do next

okay let's add a way to delete nodes

next for this we need another function

in our notes API file

so let's put it here at the bottom

export async function

we colored delete node

and it will take an argument which is

the ID of the node we want to delete

and in here recall a weight fetch data

the delete endpoint is slash API slash

notes slash and then we want to append

the node idea at the end of it right

because when we look into our nodes

routes this is how we set up this delete

endpoint

so we can simply add a plus here

and append the node idea which is a

string anyway we don't have to work URL

encoded in a special way we can just

append it doesn't contain any special

characters

and then we add the configuration as

usual where we set the method

which this time is delete

this function won't return anything we

also don't get anything back from the

endpoint but we have to await this fetch

call otherwise arrows won't be

propagated to the outside so the weight

is important

to delete a node I want to add a little

a trash bin icon here to each node

and for that we can install this react

icons package

yeah which contains ideas different

icons here

from different other packages that you

can use

so let's add this

in our front-end terminal

we install react icons this dash dash

saved by the way is not necessary you

had to add this in the past but not

anymore so you can ignore this

okay we start this again

then we want to go into our node

component the nodes that we draw on the

screen so this one here the node TSX

file

and I want to add this icon here to the

title of the note so it's right next to

the title so what we can do is we can go

below the title value here but within

the card title tag and just add our icon

but we will have to import it manually

the IDE doesn't recognize it

so up here we write import

we restructure this

and write MD delete with the same

spelling the same casing

from

the react icons packet we just installed

slash MD MD is short for material design

by the way so this is the material

design delete icon by Google

and then we can use it down here open

the anchor bracket MD delete

let's close it see how it looks

might have to refresh this

okay we are not quite there yet

first of all we add the class to the

delete icon for which we use bootstrap

classes again the first one is text

muted we used this before this just

turns the color into this grayish color

which I think looks just a bit better

and then after a space we also add MS

Auto which adds the margin starts with

the value auto to the icons which should

move these icons to the right but only

if the container of the title actually

supports this so we have to add a class

to the card title here as well

class name

and we will use our utility styles again

which we have to import first

so Style utils

utils module.css

and we want to add a new one there

so let's go into the YouTube's module

CSS

and add another class which we call Flex

Center

which contains the following attributes

display Flex which is flexbox again you

can learn more about this through

Googling

a line item Center

justify content Center

and a gap of 4 pixels

type out all of this

let's copy the class name

and add it to our

node title here so the style

youtubes.flex Center which applies this

and this yeah send us the text and this

icon properly and because we added the

flexbox now this MS Auto here Works

which adds the spacing to the front of

the icon and moves it all the way to the

right looks much better doesn't it but

we actually want to do something when we

click this icon we want to delete our

node right so we can add an unclick

attribute toward the MD delete

component and here we pass a function

like this and we want to do a two things

we want to trigger a callback so that

whoever uses this node component notes

that a note was deleted with a certain

idea right so what we do is we go up

here to the interface

the note props and we add another color

back here let's call it on delete

note clicked

and here we will forward

the whole node that we clicked so that

the color can later decide what to do

with this information in our case we

will get the ID out of this node and

then the delete request to our backend

with this idea

and this function won't return anything

let's not forget to add it down here

to the parameters

and then we can color it in our on-click

card back here

on delete note clicked

where we pass the note what's the note

that's the note that we are passed

through the component itself so we pass

this back to the color of this node but

then I also want to add a second line

here later when we click a note we also

want to open it so that we can update it

by default our click on the delete icon

will go through so it will trigger both

the undelete node clicked but also our

other callback later to open the node

for this reason we want to add another

line that swallows this click so to

speak so on click actually can take an

argument

which is often just called ear it's this

mouse event from The Click we can Define

it in here or we can ignore it like we

have done before this time we want to

use it and we want to color something on

this e variable

stop propagation

which this allows this click to go

through so we use it upright here and

our other on click Handler below this

icon won't be called later again I found

this all through Googling I don't put

this information out of my behind I have

to figure this out myself so you just

Google something like don't let click

through react or something along those

lines and you will find these answers

okay let's save this

and go back to the ftsx file because now

we have to pass this new callback to our

node component here so let's put these

arguments here into a separate lines

and let's add this new card back below

on delete note clicked

and we could either handle it right here

but since we do an API calling

everything let's put it into a separate

function

which we will call delete node

we haven't created this function yet but

we will now do so above the return

statement

so we create an async function with the

same name

and it takes the note that we want to

delete as import

ant try catch Block in here

as usual if something goes wrong we

print the arrow to the console and we

are

open an alert dialog

and in the try block we want to call

await

notes API

our delete node function that we created

earlier

which expects the idea of the note we

want to delete so we pass note dot

underscore idea

if this doesn't throw an error we stay

in this try block so now we want to

remove the node that we just deleted

from the UI and this works similarly to

how we added a new node here with the

set nodes column just that we know when

to filter our nodes and remove the one

that we just deleted

so again we call Z nodes

this time we pass nodes dot filter

as the name implies this allows us to

take the nodes array and filter certain

nodes out of it filter takes a function

that takes an argument

we have to give this argument a name

let's call it existing node and then we

make such a right arrow this filter

function will go through each node of

this array and pass it to this callback

one by one and then we can decide what

we want to do with it and we have to

return a Boolean from this function true

if we want to keep this note element in

this array and false if we want to

remove it so what we do is we write

existing node

take the idea

and we compare to the node ID we just

deleted if we know that it's the same

idea then we want to remove it so we

write not equal to like this with an

exclamation mark and two equal signs

note which is the node that we just

deleted

dot idea

so to recap this deletes the node

through our delete endpoint and then if

it was successful it Fitters our

existing node and removes the one with

this ID we just deleted so that we

update our UI and reflect the newest

changes

so when we save this our preview here

compiles again and a short break now

right let's try it out let's delete a

node let's take not the last one but

this one here click delete and its gun

and the UI is updated

and it should also now be deleted from

our database

so let's look into the atlas backend

refresh this

and there should be five notes left

right node four and then this is a new

react node

and looks correct to me

so the leading works the next step is to

update notes but before we do that I

also want to add a little icon to the

add new note button here a little plus

icon now that we already have the react

icons package installed that will be

really quick let's go into our button

tag here

and add this icon to the content of the

button

but we will have to import this first so

let's go up here

import this one is called fa plus from

the font awesome package

from react icons

slash F A

and then we can use it here

if a

plus with a self-closing tag

and there it is now it's not aligned

properly yet so we have to add another

class to our button here and we can use

our Flex sender utility class that we

already created so let's add

another class like this style utils Flex

Center

which aligns everything properly because

it turns it into a flex box it applies

the line item sender attributes and

everything and the little space here in

between the icon and the text is caused

by this gap of 4 pixels here this is why

I added this earlier okay looks pretty

cool if you ask me okay now let's add

the way to a update existing notes for

which we need another entry in our notes

API a file here let's put it between

create node and delete node

export async function

update node

which will take two arguments it will

take the note ideal

of the node that we want to update

and denote input let's call it node

where input doesn't really matter but

it's of type node input so it contains

the title and the text that we want to

update our node with

this function will return a promise

of type node if everything goes

successful it will return the updated

nodes which we then display in our UI

okay so we create a const response

it creates await fetch data the usual

way

the update endpoint is slash API

slash nodes

slash

and denote ideal

similar to how we did it for the delete

endpoint

comma and configuration

which we put into a new line

the method will be patched this time

we need the same HTTP header up here

because we send Json data

and the body is the same as well

we then the stringified version of our

node input

and the line here below is the same as

for create node as well we want to

return the Json body of the successful

response which should contain the

updated node

to update an existing node I actually

want to reuse the add node dialog that

we already created earlier we want to

change the name from add note dialog to

add edit nodes dialog because adding new

nodes and updating existing ones looks

very similar so it makes sense to reuse

the existing model we already have and

by the way this is why I kept the name

of this onnode saved callback generic I

didn't call this onnode edit because I

already knew that I want to reuse this

for editing notes as well so I called it

safe so what we do is first of all we

rename the props here I do this with the

F2 shortcut or right click rename from

add nodes dialog to add edit node dialog

props

let's also rename the component itself

but this doesn't automatically change

the file name so we have to do the

separate layer

to add edit notes dialog.tfx

update Imports always automatically

update Imports make sense

entry might have to use this save all

filets command here to save the files

where this import has changed okay then

we want to pass an optional argument to

this add edit nodes dialog

we want to pass the note to add it to it

which is an optional argument of type

node

which is our node model the way this

works is that we can pass this node to

edit to it or not if we pass one then we

know that we are not adding a new node

we are updating an existing one if we

don't pass this node to edit then we

know that we are creating a new node

so let's not forget to add it down here

then we want to make some changes

throughout this dialog here

first of all we want to pass a

configuration to use form which we do by

adding a pair of curly braces between

the parentheses of the series form color

let's put this into a new line

because one thing we can do in here we

can Define default values like this so

what we do is we set the default value

of title

to a node to edit

save color title

so this will use the title of the note

we are updating if we pass this argument

if not this will resolve to undefined

and we can handle this case with these

two vertical pipes which is a logical or

this exists in most programming

languages if the node to edit repairs is

undefined then we want to use an empty

string as the default value because then

we just have our usual add node

situation where we don't want to have

any default values already in the input

fields comma entry do the same for the

text

note to edit

text or an empty string then in on

submit we have to distinguish between

the situation where we want to create a

new node or update an existing one so

what we do is we create

a letter variable for this node response

here

so we write let note response

which will be of type node but we don't

initialize this yet

because now below we want to check

if not to edit

which means that it's not undefined we

forwarded it then we want to set node

response to

await notes API

and make our update node color

where we pass the node to edits idea

and the node input right the title and

the text

if we don't have this node to edit idea

we are in our usual create node

saturation then we want to color create

node and store the return value in this

variable and then we just do our unknown

saved callback in either case

when we created a new node and when we

updated an existing one

just a few more changes we have to do

here in our add edit notes dialog

we want to change the title and make it

dependent if it's an update or an ad

situation so what we do is we add a pair

of curly braces

we check if not to edit ID has a value

which we can do with this ternary

operator so node to edit question mark

if this value exists then the title will

be edit node

colon if this value does not exist

we use the title add node and let's also

adjust for completion

update the idea of this form we could

keep it at node but I'm perfectionist so

let's change this to alt edit node form

and not forget update here in the button

component as well

save this but we don't have a way to

open this edit dialog yet right so next

we need to catch this click on our nodes

here on the Node component and then open

this dialog in response to it

so let's go into the notes component

once again which I have to find First

this one here and we want to add another

card back here

on node

clicked

let's keep the name generic let's not

call it update node or something like

that because this way the color can

decide what they do in response to a

note being clicked maybe they don't

always want to open the updates dialog

maybe they just want to show the text so

we keep this decision to the color okay

this is a function that looks exactly

like the delete function here

it takes the note that we clicked and

forwards it to the color

we could also put this edit dialog

directly into this component this would

work theoretically but we want to pass

this card back to the outside instead

because this way we keep our code more

flexible and how we use these nodes this

is called hoisting by the way hoisting

means you're taking state or callbacks

and moving them one level higher to the

component that uses this component where

you put State and where you handle

clicks always depends on what exactly

you want to do and how flexible you want

your code to be okay and we want to

trigger this callback when we click our

node right

so what we do is we are going to discard

tag here

and add an on-click attribute to it

which takes an error function

that just calls on node clicked I

haven't added it here to our

parameters yet so let's do this

at this position

we want to cut this down here

and we want to forward the node that we

clicked

the same as we did here in the delete

callback

now let's wire everything together in

our ftsx file this now expects the

onnode click callback but first of all

we need a state where we store this node

ID that we clicked so let's add another

state here at the top

let's put it below show add node dialog

because this decides if we show the edit

version of our dialog so we create

another state

const let's call it node to edit

and the setup function set in order to

edit and we always have to change this

to camera case

which is a use State and we have to set

the type of this explicitly because we

initialize this with Nile

so the type of this is node model or

null

because we use null when we don't have a

node that we want to update right now

this is what we also start with

then we go back down to our node

component which is already complaining

here

and adds dismissing on Note clicked

callback and here we should be able to

just pass the name of the setup function

of our new state

so Z note to edit

because this is a function that gets

passed a node model and Z node to edit

is a function that takes a node model so

if I'm not mistaken right now the syntax

should work

otherwise we could write it like this

note right arrow and pass it here but

since these functions have the same

signature this should work as well

but first we have to set up the second

dialog so here we did show add node

dialog to Amazon science below we want

to do the same but this time with node

to edit

if this value is not null we also want

to show our add edit nodes dialog just

with a slightly different configuration

first of all we want to pass the node to

edit this time which is this one here

and since we have this check up here

with the embossing sign we know that

oops it's not null down here because

otherwise we would not get inside this

block and typescript is smart enough to

smartcasters it's smart enough to know

that this can't be null down here so we

can pass this value then we want to

define the on dismiss callback like we

did up here

just that we don't want to sit show at

no dialogue to false

instead we want to set notes to edit

back to another

which will also hide this dialog because

of this checkup here

and the last thing we need is our onnote

saved callback

which the Sim is up here forwards as the

node that reserved just that this time

it's not a new node it's the updated

note it's the same variable basically

but we can give it a different name

we can call it updated note

and then Define what we want to do with

it first of all we want to set note to

add it back to Nile here as well to

close the dialog after we save the

changes

and then we want to update the UI and

what we want to do is we want to take

the node that we updated but put the new

data in there without having to refresh

the page first we want to do this with

the value we get returned from the API

so again we call Z nodes

which is our state setup function

and then recall notes dot map earlier we

used notes.filter to remove a node from

the nodes array with nodes.map we can

take each single node and transform it

in some way now we want to leave most of

the nodes untouched we only want to

transform the one that has the ID of the

node we updated to put our new data in

there so nodes.map which again takes an

argument which we call existing node

as we did earlier when we deleted a node

then we want to check if the idea of the

existing node

is the same as the idea of the updated

note then we know that this is the one

we just updated and we wanna display not

the old one but the new one in the UI I

have to make this a bit bigger again

so what we can do is if existing node ID

is the same as updated node ideal

question mark in this case we want to

return the updated note colon

otherwise we want to return the existing

node so this might look a bit

complicated at first

but it completely makes sense we call

our Z nodes state map our existing nodes

by checking for the idea for each of

them and if the ID is the one we just

updated then we want to display the

updated note and put it into this array

otherwise we want to put the same old

node as we had before into this array

okay let's try it out let's make this a

bit smaller again and let's try updating

a note so when we click this node it

should set the node to edit states to

the node we just clicked which opens

this dialog with the edit node State and

the default values already inserted

let's change the title and the text

updated note 3. we updated this note

through our react app

when we click save the save button

should be disabled again for a very

short moment while the update is running

the changes should be saved in our

database through our server and because

of our map call we should see the

updated state in the UI so save and

after a very short moment everything

works properly here's our updated note

and when we refresh the screen we still

see the Zim because this data is stored

in our database properly

somewhere here is our updated node 3.

with the latest updated timestamp really

cool

also I don't know why the ftsx file has

two spaces instead of four by default

but it looks a bit cramped in my opinion

so we can change the stone here

indent using tabs you don't have to do

this but I want to use the default tab

size of four and when I format this

again looks better in my opinion okay

this works really nicely and the next

thing we want to do is we want to put

this loading and arrow State into our UI

to take care of situations where

something goes wrong and we also want to

organize our code a bit better so that

we don't put everything into our ftsx

file

okay so right now since we are on

localhost loading notes is really fast

so there's almost no delay and we see

our nodes on the screen instantly when

we actually deploy this to a server this

will take a moment so it makes sense to

add a progress bar while the nodes are

loading and it also makes sense to add

some text in case loading went wrong so

we show something like a code and load

your data right now we are just showing

the alert dialog and of course that's

also an option but it's a bit annoying

to the user so how you display these

errors in the UI is up to you if you

show a dialogue or an error message

embedded on the screen you can decide

this yourself I just want to show you

different options so what we do is we go

into our ftsx file and at another state

for when the notes are loading let's put

it down here below the nodes state

we create another state that we call

nodes loading

and set nodes loading for the setter

and we initialize this state riff true

this time because as soon as we open the

page the nodes try to load right so we

can set this to True white array then we

add another state below

which we call show notes

loading error

and then the setup which I'm going to

copy this and change this here to camera

case

which we initialize with a state of

false

we don't want to show this right array

only when something went wrong

now as you can see I give this error a

very specific name I prefer long

variable names to be more descriptive I

don't just want to call this show error

because this could be any error we want

to use this error specifically for when

loading the nodes failed so I give it

this long name and we handle all the

states down here when we try to load

nodes so what we do is as soon as we

load nodes

we set the error

we are showing the error to false

because we might want to add a retry

button or something like that and when

we retry loading the notes we want to

hide the arrow if there was one right

and we want to set loads loading no

notes loading to true

because as soon as we call this function

here we start loading our nodes and only

after this run we are finished

we want to replace the alert dialog here

in case something goes wrong

and set short notes loading error to

true

which will contain a generic error

message by the way you could also

display the error you get from the back

end by extracting it from this error

variable I just want to show a generic

error message instead it always depends

on how much information you want to give

to the user

and then we also have to set nodes

loading back to false now we want to do

this in both cases when everything went

well and when there was an error so we

put this into the finally block try

catch finally

set notes loading

back to false

okay so now we have the state and now we

use this data to display different UI

elements on our page for this we will

have to put some conditional Stone here

into our UI that decides if we show our

usual notes grid here or if we show

something else now to keep this a bit

organized let's put this into a variable

that's something we can actually do we

can cut this out go above our return

statement here

create a variable that's colored

nodes grid

and we can set it to the piece we just

cut out

and then we can use the stone here in

the place where we had the chord before

but now I want to check

in between curly braces

if notes loading is true

then so we use these two Embers enzymes

as we have done before we want to show a

loading spinner which is another

component from the bootstrap Library

we had some configuration here we set

the animation to border

and the variant to primary which just

sets the color and we close this with a

slash and a closing angle bracket

this will be shown why the notes are

loading you could see this for a very

short moment

but we are not quite there yet

the second line we add another

conditional

if show notes loading error is true

then we want to show some little text in

the UI for which we can use this

paragraph HTML tag which basically adds

some text with a little bit of margin

below

something Rand wrong

no there's no apostrophe here

something went wrong

please refresh the page

okay this will show in case there is an

error you will see this in a moment

and finally below we want to show the

notes themselves if there was no error

if the notes are not loading and if they

are not empty so another pair of curly

braces here we write exclamation mark

notes loading if the notes are not

loading anymore and exclamation mark

if show notes loading error is false as

well and again to emboss enzymes then we

show the component itself and I actually

want to add another conditional down

here because I want to show a little

text if the notes array is empty so what

we do is we add this pair of emptier

angle brackets which is a so-called

fragment in react a fragment basically

allows us to put more than one

components or HTML tags in places where

we could only put one and we need it

right here because we want to add

another pair of curly braces for a

conditional

and if we remove this fragment

this will complain because the syntax is

not valid you can't put curly braces

into another pair of curly braces you

have to use this fragment in between and

here we want to check if notes dot

length

is greater than zero so if the nodes are

not emptier

then I put the next part into a separate

line

question mark which is a ternary

operator

then we want to render the notes grid

and Below colon if notes that length is

not greater than zero which means that

our nodes array is emptier then we want

to show another paragraph

you don't

have any

notes yet and I'm really bad at spelling

so to recap why not loading is true we

show a spinner if there's an error we

show the error message if both the

loading State and the error are false

then we either show the notes grid if

there are nodes in the array or our

empty State here now let's make some

changes in our nodes controller in the

back end just to see these different

states

you don't have to do this you can just

watch the video here go into the back

end

and the place where we fetch our nodes

first of all let's see the loading State

again

we still have to Zender this progress

bar on the screen we will do this in a

moment

but let's try throwing an error here

create HTTP error doesn't really matter

which one we throw

refresh this something went wrong

refresh the pitch and let's also try

returning an empty array as if we didn't

have any nodes in our data set

refresh this again

you don't have any notes yet

okay let's not forget to rewrote this

and now I want to Center everything on

the screen horizontally

and our app TSX file now we could use

our block Center class that we used here

on our button but then we have to add

this to each element separately so let's

actually handle this in one place

instead by adding a class to the whole

container of our notes page

so let's add a class name here

styles.nodes page we haven't created

this class yet we will do this in a

moment and also one on our grid here we

will need this in a moment so let's

remember this g-4

change this again to a g-4 but also add

the second one

Styles dot node grid

or in the closing

back tick here of the string has to go

here

okay let's go into the notes module CSS

file once again and set up these new

classes here let's put it here at the

top

the first one is the notes pitch

we want to set display to flex

and flex direction to column

because with flex we can use align items

again and send everything

yeah which puts everything below each

other

which should now also be the case for

our spinner

yeah and our error messages and

everything it's all send out now the

reason why I also added the second class

for the node script

is because if there are now only one or

two nodes in our array it doesn't fill

the whole width we can't see this right

now because we have so many nodes but

this looks weird when we have fewer

nodes and we can fix this by setting the

width of the node squid to 100 so this

will always take up the full width it

has available you can check this out by

just deleting all nodes but one or two

and try it without this width 100 and

with it we see a difference okay now we

already have a nice front end and

loading States and error States and

everything we are not quite done yet but

the next step is to add user

authentication to the app this will be

very exciting because in the future

users have to sign up here in our app

and then every user will just see the

nodes that belong to them and also only

delete and update their own nodes rather

than everyone being able to change every

note in our database

okay when a user signs up on our website

of course we want to save them in our

database this means we need another

Mongoose schema so let's create one but

first of all I'm gonna close all these

tabs here

because I'm losing all overview

then we go into our back end folder

into the models folder and we want to

create another one in here which we call

user.ts

this will look similar to what we

already did here in our note schema

so rewrite const user schema

equals new schema

parentheses curly braces

put the semicolon here and configure

this

every user needs a username

at least in our app of course you could

also just use an email address if you

want

of type string remember we write this

type here in uppercase

and with that required to true

because the username is not optional and

we can actually duplicate this line on

Windows we can do this by holding shift

and ielt and then pressing the down

arrow key like this

because the other two fields are similar

the second property is an email

also type string required Journal

and a password

but we want to add another setting to

the email and password configuration

here after required rule we want to set

a select column faults for both of them

so I copy this and add this to the

password as well

this means that when we retrieve a user

from the database by default the email

and the password will not be returned to

us we have to request them explicitly

this makes sense because if you retrieve

a user for example on a public profile

then you don't want to return the email

address and password even though the

password will be hashed but you don't

want the stuff to be visible to the

outside right and even if you don't show

the user data in the front end it might

be in the Json response you get from the

server so with select faults we make

sure that this is not returned by

default if we just request a user from

the database it will only contain the

username unless we request the email and

password specifically you will see how

this works later so let's finish setting

up our schema we create our type user

for typescript

equals in first schema type we have

already done this before

as the type parameter we passed type of

in our lowercase user schema

and then we add our export default

model

add the user as the type parameter here

parentheses pass user as a string the

name of the collection later

comma and the user schema this is

nothing new for us we've already done

this in our node schema and then we save

this

and next we need endpoints where we

interact with our user data where we can

create users by designing up where we

can log in Fetch user data and so on so

let's create another controller for this

stuff

so now our controllers folder here we

right click

and create a users.ts file let's start

with the sign up endpoint

so we create an export const which we

call Design up

which is of course of type request

Handler but when we sign up the user we

have to send some data we have to send

the username email and password that we

just required in our user schema

so let's create an interface for the

sign up audio

interface sign up

body

we need a username again all of these

values here are optional because we

don't know if the use of our endpoint

actually sends this data so we have to

be safe

email of type string

and a password of type string

and then we add this type argument down

here

unknown comma unknown comma sign up body

comma unknown

is in typescript a beautiful language

and this is of course in async function

that takes a request object a response

object

and the next function

and then we add the body as usual

at the start of this callback we want to

get our data out of design our body so

we create a const username equals

request dot body dot username

the same for the email

and for the password but I'm gonna call

this password Raw

instead of just password

because for security reasons you should

never store passwords in plain text in

your database you need to Hash them we

will see how this works in a moment and

to make sure that we don't accidentally

save this raw password in our database I

give it this name here so this makes it

very explicit and makes it less likely

that we accidentally use it like the

hashed password

okay and the rest of this card back here

happens in the try catch block

let's call

our error Handler down here through the

next function

and then take care of the try block

as usual we want to do some input

validation here so that we get proper

error messages and not just rely on the

cryptic error messages of the database

so first we want to check if any of

these variables here are missing so we

type exclamation mark username

two vertical bars for a logical or

so if there's no username or if there is

no email

or if there is no password wrong in the

request

then we want to throw

a create HTTP error

with a status code of 400 which means

bad request which is appropriate here

and error message was there parameters

missing

and we also want to keep the usernames

and emails unique so that no two users

with the same name or email address can

sign up and there's actually another

schema attribute for that which I forgot

to add earlier so let's do that now

for username and email

we go after the required

true and by the way you can hold IELTS

down and click somewhere to create a

second cursor like this and now we can

add another attribute to both lines at

the same time

let's set unique to true

which as the name implies make sure that

we can only ever insert a single user

with the same username or email address

into the database

let's save this and go back to our

controller as usual we don't want to

rely on the error message of the

database we want to insert our own check

here as well so we have more control

over the status code and the error

message that we show to the user so

let's try to retrieve the user with this

username out of the database and then if

there is someone we know that the

username already exists so we create a

const existing username

and cut a weight we have to import the

user model here

import

user model from dot dot slash models

slash user

then we continue down here

user model dot find one

which as the name implies returns us one

single document if the filter fits in

between parentheses we add a pair of

curly braces

write username colon this is the field

in the user schema we are searching for

and then we want to search for the

username we passed here so again we

write username as the value

and don't forget the exec here

if there is a username found we know

that this username already exists So

Below we do a check if

existing username

then we want to throw another create

HTTP error with status code 409 don't

remember what is meant right now I think

something like a clash I looked this up

before preparing the tutorial so 409

should be appropriate

and an error message

username already taken

please choose a different one or log in

instead of course you can write any

error message here that you want

then we want to do the same for the

email address and again we could skip

this because our user schema already

enforces the uniqueness of the email

address and username but this way we

have better error messages and better

status codes below let's do the same

again for the email we create a const

existing email

awaits user model dot find one

email colon email

exec

then we check if existing email

we want to throw another error

again 409

the user with this email address already

exists

please log in instead

nice

so if we get to the point here below

then this user doesn't exist yet and we

can go ahead and save it in the database

now as I already said we don't want to

save the raw password in the database

because even though your database is

locked by a password usually there can

always be something bad happening and

your database leaks and then you don't

want to leak the raw passwords of audio

users so instead as a process called

hashing which basically turns this

password into an unreadable string of

characters you can Google the exact

mechanism behind it but it makes it so

that even if the database leaks no one

really can do anything with the

passwords of course there's a package we

can use for that which is called B Crypt

it's a very popular one so let's see D

into our

backend folder

and run npm install

bcrypt which is spelled like this

and we also need a type package for it

so we type npm IR

-d for Dev dependencies

add types slash bcrypt like this

and install it as well

okay and then we can go ahead close this

and save our user here so we create a

const for the hashed password I'm going

to call it password hashed equals

then we use bcrip to Hash our raw

password and this is an asynchronous

operations area write a rate

bcrypt dot hash

which is a function

but we have to import bcrypt first so up

here

import B Crypt from the bcrypt package

the first argument is the raw password

and the second argument is the resulting

rounds

salting is another security mechanism to

make it harder to a reverse engineer

these hash passwords because there is

actually a way to figure out a real

password from a hashed one if it's a

commonly used one through something

called rainbow tables and sorting is

another security mechanism that makes

this yeah impossible basically so if you

write it like this then your passwords

will be saved and then we can save this

data as a new user in the database

so let's create a cons new user because

after signing up successfully we want to

return the user to the front end

immediately

equates await user model

dot create

parentheses calibrases

we store the username that we are sent

to the endpoint

we store the email as it is

and we store our password hashed not a

raw one

and then Ria sent a status back with the

code 201

and the Json body will contain this

newer user we just created

next we have to set up the route to this

controller right so we create another

file in our roads folder

which we also call users.ts

so we need a router here

so first we import Express

from the Express package

we also want to import our user

controller import Star as user

controller

from

dot dot slash controllers slash users

and then we create a router constrada

equals Express dot router

and then below we create our first

endpoint for our users controller which

will be a post request because present

data to our sign up endpoint

the URL is slash design up

and we want to forward this to user

controller DOT sign up

don't forget to add a default export

below

export this router save this

and then we have to register this new

route in our app TS file so let's go

over there the same as we did for our

notes routes we need our user roads so

import

user routes from

routes slash users

and then we added down here either above

or below it doesn't really matter put it

above

app.use slash API slash users

comma

and our user routes

okay and now we should be able to reach

our sign up endpoint

since we don't have a sign up form yet

let's try it out in Postman first so we

want to do a request to our server slash

API slash users

slash sign up and we have to pass a body

here because if we try to send it like

this it saves parameters missing which

is our own error message we set up

so we need a username

gonna give it my name

needs an email address

let's set this to a

Florian at test.com

and we need a password

I use my favorite password which is one

two three four five

let's send this and see what happens

okay so it looks like we got the user

back this is our hashed password Here by

the way let's also take a look into the

database

so we have our new users collection

again this takes the name of the schema

which is user and pluralizes it

and our data is in here this is our

hashed and soldered password now let's

try signing up with the same email or

username again

which shows us our error message here

let's also see if the unique key

actually works by removing our own error

for a moment so let's remove these

checks for existing email and existing

username just for a moment I'm going to

comment this out save this

try this again this should still not

work

an unknown error occurred and in our

logs we should see our mongodb error

here duplicate key error collection this

is what we want to see

so this is basically a fallback security

mechanism that happens because we are

that is unique key is here in our user

schema

so let's just go to have these two lines

of defenses because of course we can

always mess up our own server code here

so it's good if the database itself also

enforces this constraint and of course

if we use a different username by the

same email address we should still see

an error here a user with this email

address already exists please log in

instead nice and we will later show this

error message in our front end in our

react app but of course inserting the

user in the database is not enough we

also have to keep the user locked in

somehow right and we want to do this

right after a user signs up because why

should they insert their login

credentials again if they just enter

their own password

for user authentication we will use

sessions through this Express session

package here there are basically two

popular ways of keeping a user logged in

either sessions or JWT tokens JWT tokens

are used in a lot of tutorials but they

are actually quite hard to use because

JWT tokens are self-contained which

means that once a user has it they can

always log in with it there is no way to

invalidate an existing JWT token but in

validating a session after user signed

in is important for example when they

want to change their password then they

should be locked out in all the other

places right because maybe their

password has been compromised this is a

problem that this self-contained token

spring and the usual way to handle this

is to keep these tokens will be

short-lived usually one hour and then

they have to be refreshed before they

can be used again this way when you

change the password then the user Can

Only log in for the rest of that hour

until the token expires but then you

also have to implement a refresher

mechanism which can be quite complicated

or another way to handle this is to keep

the tokens long-lived but Implement some

information in your database some kind

of Blacklist where you enter tokens that

have been expired but then you're

basically just rebuilding sessions in a

sub-optimal way what you must not do is

giving a user a token that lives for

like a week or a month and then you have

no way to invalidate it that's a

security issue but if you have your own

server that can store data then I

actually prefer just using sessions

because they are much easier to use

possession works so that a user has some

kind of key stored in a cookie and there

is a corresponding entry in your own

database on your server for each session

and then when you need to invalidate the

sessions for a particular user then it's

just a matter of deleting this database

entry and that's it these session

cookies are not self-contained as

opposed to what JWT tokens

so yeah this is in my opinion much

easier to implement you will see how

easy this is in a moment let's install

this package now so we need this install

command here go into our terminal

cancel the execution for the back end

for a moment and install Express session

here

we also need the types for Express

session again so npm IO Dash Dio

add types slash Express session

install this as well

and we need one more thing our session

information has to be stored somewhere

and there are different adapters that

you can use for that they are listed

somewhere down here there are different

ones we are going to use the mongodb one

so we store the session in our existing

Atlas mongodb should be this one here

connect Bongo in a real app I actually

recommend that you use something like

Reddit because our mongodb database is a

remote database it's not on our server

directly and it's on atlas's server

right this means that it takes a moment

to store this information in the

database if you want something that's

really fast you can just install a

radius database on your own server and

then this is just a bit faster but

setting up Reddit for development is a

bit complicated so for the ease of this

tutorial we will just use the mongodb

one because we already have this

database set up and you can also use

connect in your production app you

don't have to use the Reddit one it's

just a little bit faster

so this is also an npm package

and we want to install this here as well

npm install connect Mongol

let's do that

and then let's start the server again

because we have installed all

dependencies we need for now and then

when a user has signed up successfully

before we return the response we want to

establish the session and this is really

easy with this package we just take our

request object

on which we now have the session keyer

and here we can store some data and what

do we want to store we want to store the

ID of the user that just signed up

because this way we can identify a user

so we store this user ID property here

and we set it to the ID of the new user

we just created right so underscore idea

in normal JavaScript this would be

enough but as usual typescript

complaints because it doesn't know about

this user ID field here on the session

object because we decide ourselves how

this is called so we have to do a little

bit of extra configuration what we need

to do is we need to create another

folder here in our backend folder not in

that Source but right at the root folder

because this is not our normal source

code

which we call it types and in here we

can put stuff like our own type

definitions that we sometimes need and

again I figure this out through a Google

and documentation

you always find these Solutions in

Google somewhere

and here we put a new file

which we call session dot deal dot TS

and these DTS files are these type

definition files which help typescript

recognize variables and stuff like that

and whenever we install these add types

slash packages then we are installing

DTS files basically just that they are

residing inside the node modules folder

okay and here we will need Mongoose

because we want to store the object idea

which is a mongoose type so we import

Mongoose from mongoose

and then below we write declare module

the same name that this package has

where we want to add this type tool so

this is Express session

curly braces and now we can basically

add our user ID variable to the existing

Express session type

by writing interface in here

we call it session data and you have to

use this exact name because this is how

the type on Express session is called

then we add another pair of curly braces

and now we can add our user ID field

by declaring its type so Mongoose dot

types dot object idea

so that's it for this file

we have to make a little change to our

TS config file as well so that this is

actually used here because otherwise

this will not work properly so we go

into the TS config file

and we search for the key called type

Roots which is down here

we uncomment this

here we tell typescript where the type

definitions are

by default this should point to node

modules types but now that we set this

explicitly we have to enter this

ourselves

so in here we put a string

node underscore modules

slash add types

comma and then we end the second one

which is our own types folder now so we

just type add types which points to this

one here we just created

and this now tells typescripts that it

can find type definitions in both places

the node modules folder which are the

ones that we installed and our own one

and one more thing we have to add all

the way at the bottom because this

happens outside of this closing curly

brace here so there should be two

closing curly braces down here

we go before the last one at the comma

and adds this TS node key which is

necessary for TS node to recognize these

types remember TS node is what we use to

automatically restart our server in

development whenever we save the changes

and here we add the silence key

and that is the true and again I found

this through a stack Overflow because

the session key didn't work then I

looked this up and then you find all

these necessary steps there

okay we save this

let's not forget to save the changes to

our users controller and then we have to

go into the FTS file once again because

we still have to configure our Express

session package here but this is just a

little bit of code and then we can use

our sessions throughout our whole server

the Press session is another middleware

that we have to register here but the

place is important we want to register

them before our routes but after we read

the Json body so right here we write

app.use

and here we want to call session

okay Auto Import doesn't work so we have

to import it manually

import session from Express session

which is a function that we can call

and add a pair of curly braces to do a

configuration in here

the first thing we have to set is a

secret this liquid is used to assign the

cookie that the user receives so this is

basically their key to identify their

own user session so each session has an

entry in the database but also a cookie

with a secret key is stored on the side

of the user in their browser there

should be a random string now as usual

we don't want to hard code sensitive

data right into our code we want to put

it into the nth file

so we open our backend and file

and add another entry in here which

requires session secret the name is up

to you

and then we just set this to a random

string

you can type in whatever you want

just don't use any reserved characters

this should suffice but this has to be

an equal sign not a column I always mix

this up

okay and we also need to add this to our

sanitized and file right remember we

have this validate and f file here

where we want to registered this new key

as well so that we make sure that we

actually have this available at runtime

this is a string

let's go back into the app TS file and

import our validate and Theorem so

import enf

R from

dot slash uter slash validate INF

o and then down here for the secret

we pass nth dot session Secret

then we set Reserve to false

entry that save uninitialized to false

as well this is some configuration that

is necessary that I don't want to

explain here you can hover over this or

look into the documentation and it tells

you what this means it's just not

important here

then we need to configure the cookie

that will be stored on the user's

browser

so cookie colon curly braces

entry set the max Edge how long this

cookie lives this is up to you again you

can make this long lift because we can

invalidate sessions from our side even

if the cookie hasn't expired yet I'm

gonna set this to one hour here you can

also make this longer and I later also

want to try out what happens when this

cookie expires but that's something we

want to do later but the cool thing we

can do is we can set rolling to true

this means as long as the user is using

our website this cookie will be

refreshed automatically so if the user

enters the website within this one hour

they will stay signed in and of course

if you say this to a week for example

then they will stay signed in if they

use this website within a week which I

think is really cool because if a user

doesn't use your website I think it's a

good idea to lock them out eventually

and lastly we need to set a store

store is where the session data will be

stored if you don't pass anything here

the session data will be stored in

memory so it will work until you restart

your server then your sessions will be

gone this can be enough for development

but definitely not for production but

also for development it's good to

actually store the session data

somewhere and for this we want to use

our store that we installed

so we have to import this here import

store or the completion takes care

of the rest

and then we want to use it down here

bongostore.create

parentheses curly braces

and in here we can pass a URL

which is just the same URL that we also

use for the rest of our database

connection which we stored in the

environment variables in this

connection string

let's save this

and now we could create a new user and

see how this cookie is stored we can

actually see this in Postman but I don't

want to create a yet another user so

let's implement the lock and Route first

and use that one that so we go into the

user's controller

and Below sign up we export another

function here

export cons login

of type request Handler

it needs a body so we create an

interface

this is second nature for us by now

lock and body

we send a username

and a password

it's hard to type and talk at the same

time

we don't need to send an email this time

because we are not creating a newer user

account we are just signing into an

existing one

down here unknown comma unknown comma

login body comma unknown

and if I'm too fast for you then you

just have to step up your game come on

man type faster async Reckless next

and we create our error function

okay I'm slowing down a bit

we want to extract the input from the

body

so a const username equals rack dot body

dot username

and design for the password

and then we add our good old friend the

try catch block

and call our next function down here

which we have to do a every single time

in the try block we want to do some

input validation

if the username is missing or if the

password is missing

we throw a create HTTP error

status quo 400

error message parameters missing

now before we can check if the passwords

match we first have to figure out if

there's actually a user with these

credentials with this username in our

database

so we create a const user

to an await user model find one

for the username we entered

and since the user is signing in we want

to send them back all their data

including their own email address and

remember we set select to false by

default so they will not be included

here when we call find one but we can

include them explicitly by adding dot

select

parentheses and then we pass a string

here and in the string we write a plus

and then the name of the field we want

to include so plus password then is

space plus email

and then outside we append our exec

this adds the password and email to this

find one request which is necessary

because by default we exclude them

okay so if the user doesn't exist we

want to throw another arrow so if

exclamation mark user

we want to throw a create HTTP error

the response will be 401 which means

unauthorized

and the error message was a invalid

credentials

now I keep this error here generic on

purpose I don't say this user doesn't

exist you can do it if you want but for

security it's a good idea tool don't

tell whoever is trying to log in that

this user doesn't exist because it makes

Brute Force attempts more easy right

this way when a user types in a username

that doesn't exist they don't actually

know if this user doesn't exist or if

the password is just wrong but this is

up to you you can implement it this way

you can also tell an error message that

this username doesn't exist but if we

found the user we can go ahead and

compare the passwords so we create a

const password match

equals a weight and then we have another

b-crypt function that we can use compare

which can take the raw password which we

are sending over the login body and it

can compare it to the hashed password of

the user from the database so even

though this password Here is hashed and

this one is raw decrypt knows how to

compare them and tell us if they

actually match this is the cool thing

about this Library it hides all this

complexity from us okay so below we

check if exclamation mark password match

so this is a Boolean that we are getting

back

if this is false the passwords don't

match

we want to throw another error we

actually reuse this one here in valid

credentials

if we get below this if block then

everything went well the user exists the

passwords match then we can establish a

session

which again we do a with request

dot session

we set the user idea

to the ID of the user but with the

underscore

that we just compare the passwords with

and lastly we want to return this user

to the front end with a status code of

201

and we send the user as the Json body

so we can use it in our front end right

away

let's save this and register this new

route in our user routes file

So Below sign up we create another

user.post

slash login and we forward this to

usercontroller.login

and then let's try this out in Postman

so I opened Postman change the endpoint

here to slash login

we don't need the email address anymore

let's remove the password for now to see

what happens

um yeah we also have to remove this

comma here

parameters missing let's add the

password back in but let's make it wrong

invalid credentials

let's make the username wrong

invalid credentials

and now let's use the correct

credentials

okay and we are getting a user back not

only that we are also getting a cookie

back

this connect.s idea is the session from

the express session package we just set

up and Postman actually stores these

cookies just like a real browser would

so you can see it's stored here

as the key is stored in there and when

we look into our mongodb database

we will actually find another collection

now for the sessions this is what the

Bongo store did for us so this is the

session for our user that's stored in

our database with this x bios keyer and

now we can force the user to log out by

simply removing the session here but

before we see how this works we'll have

to add another endpoint where we can

retrieve the user data of the currently

locked in user so that we see that when

we delete the session this will actually

not work anymore so let's go back into

our code and into our users controller

once again

and all the way at the top here before

designer body I want to add another end

point which I'm gonna call

get authenticated user

so here we get our user data from if we

are logged in

it's a request Handler it doesn't take

any body or anything so we don't have to

declare any types

and as usual it's an async request next

and here we want to get the currently

locked end user out of the session which

is very simple we can write const

authenticated user and set it to

rec.session

dot user idea

if there is a user currently logged in

then this will have the ID of this user

and if there is no user logged in it

will be undefined and we know that there

is no login session right now

so in the try catch block here let's add

the next call First

we can check if there is no

authenticated user

then we could either just not return

anything from the database but let's

actually throw an error here so throw

create HTTP error 401 for not

authenticated

viewers are not

authenticated

if there is an authenticated user we can

return it here and we can call this

endpoint for example later when we open

our website so we open the website and

of course we don't want to log in every

time instead we want to see if there is

a session that exists and the key that's

stored in the session cookie and then we

can just return the user right array So

Below we want to retrieve the locked end

user from the database

so const user equals await

usermodel dot find this time we can use

find by ID because we have the idea

stored in the session so between

parentheses we pass authenticated user I

actually want to rename this to

authenticated user idea

so rename this one up here as well

we don't need to return the password

here because the user doesn't need their

own password on the front end but they

probably need their own email address

for example to show it in the user

profile

so we add a select

plus email

and add exec

and then we want to return the user with

a status code of 200

and we send the user and the Json body

save this then set up a route for it

router dot get

slash we do it right at the user

endpoint

he was a controller dot get

authenticated user

save this as well and then let's try it

out in Postman

Postman

get request two API users now we should

be getting a user because we have the

session cookies stored

let's look in the audio there it is our

user with our email address

let's delete our cookie that we have

stored here then the session should not

work anymore use are not authenticated

let's log in again

of course that's a post

change this back to get but before I

execute this

I wanna delete the session from the

database

so we have two now because one for the

designer one for the login but the

expire after a while so they don't keep

stacking up in the database after they

expire they will be deleted

automatically

but now we delete them manually

and no decision should also be invalid

even though the cookie is still stored

yours are not authenticated so this is

how sessions work there are two pieces

there are the cookies which are

basically the keys to your session and

the session entry in the database and by

deleting a session from the database you

can force the user to log out but of

course the user should also have a way

to log out themselves without us having

to delete them from the database so

let's add another route for that

let's add the route itself right array

and then set it up afterwards so

router.post

slash logout

entry will forward this to user

controller dot logout which we haven't

created yet but we will do this next

now you could also make logout a get

endpoint because we are not sending any

body to the server but I think it's more

correct to make this a post because we

are changing something on our side on

the back end side there are different

opinions about it but I think post is

appropriate so let's go into the user's

controller let's put it at the bottom

export const log out

request Handler

red rest next

and then we have this rack dot session

dot destroy function we can call to

destroy a session now this doesn't

return a promise so we can't use a

weight and try catch in here instead we

have to use a callback here but that's

fine it's not a lot of code anyway so

destroy attempts to destroy the session

if there's anything that goes wrong it

will pass us an error in this callback

so we add error

a right arrow and the function body here

on curly braces

we check if the error exists

then we want to forward it to our error

Handler as usual

and if the error does not exist we just

send

a status code of 200 to indicate that

the logout when successful and again

since we don't send a Json body you have

to use Zen status instead of just status

okay and that's our last authentication

route we need let's try it out in

Postman once again

let's log in first

slash user slash login

there's our session let's try retrieving

the locked in user

works as well

let's log out

we got our status of 200

and let's try to retrieve the user again

oops

and doesn't work because we are not

authenticated anymore

and there should be no session in the

database yeah the session is gone as

well

okay so we just implemented

authentication into our app using

Express session if you found this

helpful please leave a like on this

video and the next step is to use these

new endpoints on our front end so that

we can actually sign in and log in and

retrieve our user data in our react app

rather than in Postman

alright we will need a model for our

user on our front end as well right so

let's close all these tabs here for now

and go into our front-end code

here front end Source models and here we

want to add a new file

which we call user.ts

that's just a simple interface

that we want to export

which we call user so that we have a

type that we can work with

it will contain the username

and the email of the user

we don't need a password here because

there's no reason why we need this in

any way in our front end we probably

wanted this by the username somewhere

and maybe the email address so the user

can see it and change it but we don't

want to do anything with the password on

the front end now let's add all the

endpoints that we need to our notes API

file the endpoints for retrieving user

data are logging in signing up and so on

I'm going to put this all the way at the

top here but below fetch data right here

and you can also create different files

for the API endpoints for the nodes and

for users and other stuff but since they

aren't too many right now I'm gonna put

them into the same file Zone the first

one is export

async functional

get locked in user

I think the name is self-explaining

it will return a promise

with our user type here which we have to

import properly

in here we write const response equals

await fetch data

the end point is a slash API slash users

and this will be a a get request

now since both the front end and the

back end are on the same URL this will

actually send the cookies to the back

end automatically so we don't have to do

anything special in here we will either

get the user if we are locked in or we

will get a 401 response if we aren't

so here we can simply return the Json

body of the response which will contain

the user data if we are logged in this

works since the front end and the back

end are on the same URL if they are on

different domains or subdomains then you

have to include the credentials

explicitly which you do in the fetch

configuration here so there's a

credentials include property for that

but you have to Google it because I

don't remember the exact Syntax for that

right now but you have to add this to

the fetch call but our front end and

back end are on the same URL so the

cookies represent automatically but we

also need endpoints for signing up

logging in and logging out so for sign

up we will need some input so let's

create another interface for that

which requires design up credentials

similar to how we have created this node

input interface earlier we will also use

this in our sign up form later

design up credentials consist of a

username

the email

and the password

and then we export another async

function

that we call Design up

and this will take these credentials

design up credentials as input

and it will also return a promise of

type user because after signing up rear

return the sign up user right away okay

const response equals

await fetch data

to a slash API slash users slash sign up

comma and some configuration

the method will be posed

we send the Json body so we need our

Json header here so let's copy this

insert it here

and the body itself

for which we stringify

our not create nodes but credentials

which we pass to this function

and then if everything went successful

we want to return response.json

which is the data of the newly designed

app user

we need another function for logging in

again we need the credentials for which

we create another interface

lock in credentials

because those only consist of the

username and the password

we don't need to send the email again

so we create this interface

and another function

which we call login

it takes the log in

credentials

and it also returns a promise

of type user

let's actually copy this from design up

function because it's very similar

just that we make the request to the

login endpoint and the rest is the same

we still send the credentials we still

get the user back

and lastly we need a function for

logging out through our front end

so another export async function log out

doesn't take any arguments doesn't

return anything we know that it went

successful if fetch data didn't throw

so we simply call a weight of fetch data

two slash API slash users slash logout

and the method is post

and that's it

save everything

okay and now we want to create models

for logging in and signing up which of

course contain form input similar to

what we already have in our add edit

node dialog here

but I said that we want to create

reusable components for text input

Fields otherwise we have to repeat the

syntax here with form group and form

label over and over again and it's quite

verbose so what we do is we create

another folder here in the components

folder

which we call form

I just want to put form Fields into a

separate folder for better organization

and then here we created text input

field.tsx file

and we can split this and move this to

the right so we can view both our files

here at the same time

we want to set this up in a way that we

get rid of a lot of duplication here

when adding these form input Fields so

the first step is to create our

component function here with the same

name

text input field

and above it we want to Define an

interface for the arguments that we pass

to this component

so text input field props

so every text input field will need a

name which is this part here that we use

to register the field with the react

formwork Library so we add a name of

type string

also all of our forms you have a label

above it right so let's add this as

another property you can make this

optional if you want and only show the

label for some but we show labels for

all input fields

then we need to pass this register call

here to the text input field

so we add a property that we call

register

and the type is used for register

of type any like this we have to set

this to any because we don't know yet

what Fields this register will contain

this way we keep it reusable we can use

it in our zainab form in our added node

model and so on and where do I know this

return type from that we have to use use

from register again I just Google this

you just have to figure out stuff like

this through Googling and this way we

can pass this register function here to

our text input field to register it with

react talk form

we will pass this configuration here

separately

so we add a register options

and this one is optional because yeah we

can pass register options like we do up

here or we can omit them so we make this

property optional

and the type here is register options

I just think it's more readable to

separate the register function and the

options rather than passing them as one

thing and we also want to have this

error message here and the type of these

errors is field error or undefined so

what we do is we add another property

that we call error but this one is

optional and it's of type field error

so we can pass a field error or we can

pass undefined in which case we want to

ignore it just like we did here

and then we add one more property here

which we write like this

scrap records X colon

of type string

like this

and then call on any

what does this mean this basically

allows us to pass any other probes that

we want to our text input field

component even if they are not defined

in here and we do this because these

form input Fields have a lot of

different properties available that we

can add or omit and instead of defining

each of them here separately we just add

this syntax which allows us to pass any

array of remaining properties then we

have to list all these properties again

down here so name comma label comma

register

comma register options

comma error

and for these

optional props here at the bottom we

write it like this dot dot dot props

which is the syntax again where it takes

something and it destructures it into

its single pieces basically this just

means that we get past each of these

props that we add additionally one by

one could be a bit confusing but if you

just follow along you will see how this

works and we must not forget to set the

type here

text input field props

let's make this big for a short moment

so we can see the whole thing this is

how it looks

and then we want to set up the same way

as we did here on the left

zor the outer tag is a form group

with this

mb3 class name

and we add another property called

control ID on this one

and reset it with curly braces to name

plus and then we append a string input

and then we close this tag

control ID is a property that does some

accessibility stuff for example it

connects the label that we put into this

form group with the input field itself

so that we can click the label and it

activates the form input field and it

also helps screen readers for example

this is what this control ID is for we

just have to set it here and we use the

name of this input field which is

different for each of them and we just

append input to make it more

recognizable

then let's finish setting up this input

field so we add the form label here

which will contain the label that we

pass to this component

you can make this optional if you want

by wrapping this with these two Amazon

signs as we did earlier but I don't want

to make this optional

below we add form control which is the

input field itself

then first we want to pass these props

here with this three dots which we

simply do like this a pair of curly

braces and then we write dot dot dots

propsy as well and this simply takes

these optional props and adds them to

the form control and then we can just

add them like we add any other props to

our component just that we don't have to

Define them up here on our interface

then we have to do the same with the

register like we did earlier another

pair of curly braces dot dot dot

register

the first argument will be the name that

we pass that's this property here

comma and then we pass the register

options which repair separately

and then the same as over here

is invalid property

which we set to a to our exclamation

marks to turn it into a Boolean and then

the arrow we pass here which is the

field Arrow or undefined

this stuff is a bit complicated and a

bit annoying but you only have to set up

this input field once and then you can

reuse them in your app that's the cool

thing about it and it will be much less

for both than what we have currently

here and then we need this invalid input

feedback let's copy this

opacity inside the form group

but change this to error.message because

this is already the field error but it

can be undefined so we add the save call

Operator but it has to be error not

arrows because this is the name of the

property

and now let's replace these input Fields

over here in our add edit nodes dialog

for these newly created text input

fields so I'm going to do this with the

browser open so we can see if the newer

input field looks the same as the old

one

so let's not delete the other ones right

away let's first add the new ones so

opening angle bracket text input field

and we can add the self-closing tag

right array

they all need a name the same one as we

used here to register this

so title

they all need a label

which will be title

we set the type to text and this is the

first example of our rest props here

because we didn't Define the text as

input props because we don't want to

pass one down here for the text area

this one is optional but instead of

adding an optional property here we use

these rest props this is how this is

called

so we can basically pass any property

here and they will be put into our text

input field so this is really just a

matter of how explicit you want to be

you can add them to the properties

interface if you want to make this

decision explicit or you can use these

rest properties where you can basically

add anything you want it makes sense for

something like a form input field

because there are so many different

properties that we can pass or not and

we don't want to specify each of them in

our interface okay we want to set a

placeholder as well which is another

example of a rest property it's not in

our interface

3.0 set this to title 2.

we need register that's required

here we can simply pass the register

that we get returned from react formhog

register options are optional

and here we have to add two pair of

curly braces because what we pass is a

JavaScript object and that's why we need

another pair of curly braces

we want to set required

and use the required string the same as

we did before and now we can already

save this and we see our second input

field here the one at the top is the new

one through our text input field

component one more thing we also want to

test the error here

which we set two errors from react from

Hook dot title

so now when we don't add the title the

error is recognized properly

okay so we can delete the first input

field here of the title

and then we want to create another text

input field for the node body area

the name of this one is text the same as

we are used down here to register it

the label will say text

we use S text area

reset the rows

and here you can really see all these

different combinations of properties

that we can pass

that we all want to handle through this

rest props here

because it would be a lot of work to add

each of them to the interface and it

would be very verbose

we add the placeholder

which is a text

and re-register this

but this time we don't need register

options add no errors because this is an

optional field

we don't have to pass it

and there's our new text field

and now let's delete this one down here

now the new text input field code is not

really that much shorter but the

important part is that we don't have to

repeat stuff like adding the correct

margin all the time or all these

different components is just a bit

easier to use and everything that's

required you can just add to the

interface

let's save this and see if adding a node

still works

another note

blah blah

and it's here at the bottom so it still

seems to work

now let's create a design up model

through which we can create a new user

account through our front end let's

close the text input field code and the

add edit node dialog code

the API we can actually close everything

and then let's create another component

front end Source components new file

we call it

zineappmodel.tsx copy this name

and create a functional component in

here

first we need to define the input props

interface

sign up model props

we need an on dismiss callback

so that we can close the model

a function that doesn't return anything

and we need another callback for when

the sign up was successful so that we

can set the use of our app to the newly

signed up user

so on design up

successful

this is a function that gets a user

passed to it

and doesn't return anything

then we add these properties down here

the usual way

on this Miss on sign up successful

of type sign up model props

all right and now we have to write a

little bit of code

so first of all we need our register

form hook and this stuff so we create a

const curly braces the same as in the

add edit note dialog

we need to register

let's actually add equals use form here

at the end right array so that we have

proper Auto completion for these

different fields so we call use form add

this import statement if it didn't

automatically and the type for the input

is our sign up credentials that we

created in the notes API file earlier

so we add this type argument and call

this and now we have better Auto

completion here

we need handle submit

we need form state

which we destructure tour errors and is

submitting this is the exact same stuff

we have done in the add edit node model

before

then we need a function that handles

submitting this data

soar an async function

on submit

which will take design up credentials as

input

we need to try catch Block in case

something goes wrong

as usual we do alert with the error

and we lock the arrow in the console

we need a handle to our notes API file

so let's duplicate this line

and change this to a star as nodes API

from the network nodes API file

because we want to use this here

we create a const for the newly signed

abuser

equals the weight notes API

and we call our sign up function

which expects design up credentials

passed to it

and if this weren't successful

we want to call our on sign up

successful callback

and paste this newly created user to

whoever is showing this sign up model

now even though we don't have a sign up

button yet we can still go into our ftsx

file and show the signup model already

so that we can see what we are building

while we are adding the form Fields so

let's go into app TSX and down here

where we already have some models set up

let's put it here below another pair of

curly braces

and since we don't have a state yet for

now we just write true and to Amber's

enzymes to show this model all the time

and here we want to use our sign up

model

which expects the on dismissed callback

on enter on sign up successful callback

and for now we just pass empty functions

here to ignore these callbacks

but we have to finish our sign up model

return statement here first before we

can see it on the screen so let's finish

setting this up this should return a

model from the react bootstrap package

research Hotel true as before

and on height will trigger our on

dismissed callback

in here we put the model dot header

with a close button

and the title will say sign up

below we put a model body

which will contain our form

so we import this react bootstrap form

tag

we forward on submit

to a handle submit from the react talk

form package

and call on submit here which is our own

submit function

I don't explain this again because this

is the same thing we have done in the

add edit node dialog before now when we

save this we should actually see

something on the screen nice it's our

emptier model right now and the

formatting of the title is not correct

yet because we also have to wrap this

into a model title

which takes care of using the correct

font size and everything

then let's finish setting up our form

down here

so we use our shiny newer text input

fields

the first one has the name

username

the label username as well just that we

start with an uppercase because this

will be visible to the outside

we set the type to text

we set the placeholder

to username

we Press Register

from react formhook

we Define register options with two pair

of curly braces again

because this will be required

and you want to show an arrow here in

case we didn't enter anything into this

field

which we get from errors Dot the

username also from react formhog

and when we save this we see our first

input field

then we want to add a second one below

for the email address and then one for

the password email and password are very

similar so let's copy this

it takes the same attributes but the

name is email

the label is email

the type will be email as well and this

changes how the browser handles this

input field when we set the type to

email we actually get some simple input

validation here which means that Chrome

or any other browser that handles this

will not accept an email that's not

shaped like an email with an ad and

everything that's just a bit more useful

than a normal text field but it does not

replace backend validation remember

because front-end validation can always

be circumvented in one way or another on

the back end we only checked that an

email exists we don't actually check its

shape there are packages that you can

use for that but that's beyond the scope

of this tutorial you can look that up in

Google the placeholder will say email as

well register is the same it's also a

required field but for the error we want

to use arrows.email

and then let's copy it once again for

the password and we can actually

duplicate The Code by highlighting it

and then we can press shift out and the

down arrow like this

but you can also just copy paste it the

old way like a peasant okay so the name

of this field is password

the label is password

the type is password 2 and this is

pretty cool because it automatically

hides the characters here so these types

are handled by the browsers

the placeholder will be password

register and register options stay the

same and we use errors password down

here

then of course we need a submit button

so below here we add another button

which is a sign up

and it needs some properties

we set the type to submit again so the

browser recognizes this as a form submit

button but this time we don't have to

specify the form idea because now we

have put the button inside the form tag

itself remember earlier we put such a

submit button outside of the form then

we had to connect it manually but since

this is inside the form the browser

knows that this subnet button belongs to

this form and when we press it it will

automatically trigger this unsubmit

callback here okay so we want to disable

this button while the form is submitting

so that we can't submit it twice

at the same time

this is our button but I also want to

give it a width of 100 so it fills up

the full horizontal space

for this we can create another utility

CSS class let's do that let's go over

into a

utils.module.css add another class down

here which I'm gonna call width for 100

I think the name makes sense

and here we set the width to 100 percent

save this

go back into our sign up model and

import our utility styles

so import Style utils

from

where is it located

dot dot styles

slash

utils.module.css

and now we can use it on here

class name

style utils dot with 100. and looks much

better in my opinion looks like a real

sign up form

let's format this properly

like this

and then try it out

so let's enter a new username

Florent tool

for around 2 at test.com

and the password ASD ASD

sign up

now we don't have any feedback yet and

the model doesn't close yet but if

everything went successful we should see

our new user in the database

and also a session for it

so here's Florian tour

and there should be a cookie in our

browser yet security is not secure is

because we are on localhost it will be

secure when we deploy this with https

and there is our connect Sid cookie and

now we should be able to retrieve the

user data without having to send our

login credentials again unless we log

out let's also try this email validation

that I was talking about

so the browser yeah actually recognizes

this and shows this error message here

if the email is misshaped and also

password managers recognize these input

Fields because we set these different

types here password and email and

everything so a password manager like

one password or LastPass will recognize

that this is a password field and

suggest you a credentials to put in

there now let's also create the login

model

so we create another file here in our

components folder

we colored lock and model and of course

you can organize this into another

folder if you want but we don't have

that many components in this tutorial so

I keep it like this

and create another functional component

in here let's start with the props

interface

login model props

as usual it's a dialog so it needs an on

dismissed callback

and then on login

successful callback

which again gets the user passed to it

so that we can use it in our front end

then we add this properties down here

on this Miss unload in successful

login model props

and then the setup is very similar to

design up model

we need to set up our form so let's

write const

curly braces equals use form

of type log in credentials

that we put into our notes API file

and then we need

register

we need handle submit

and we need form state

arrows and is submitting

we need our async submit function

so async function on the submit

which takes the look in credentials

log in

credentials

try catch

alert error

console Arrow error

in try we want to try logging in

a const user equals a weight

we need a notes API let's copy it from

design up model here because we are lazy

this one here notes API

the same location

Dot Login

we pass the user login credentials

and if this weren't successful recall

unlock and successful and pass back the

user

okay and then we need more forms so in

here

we create a model

show

on height

I don't expand this again because we

have already done this a few times by

now

oops what the hell is this

model dot header

with a close button

model dot title

that says login

below the header we put a modal dot

audio

and inside here we put a form

on submit

handle submit

on submit

I heard that you like submits so we put

an unsubmit into a handle submit into an

unsubmit this was just a joke by the way

don't get confused

and we need tour text input fields

first one has name username

labor

username

type would be text

placeholder will be a username

we set up register

we set up the register options

required

with the warning method required

and for error repairs errors dot

username

that's a lot of work

okay let's duplicate this

for the password

name password

label

password

type password

placeholder you guessed it password

and error set password

and then we need our submit button here

as well let's copy this again first of

all we need a style

the style utils

and the submit dot button down here

copy this as well go over here paste it

inside the form

just change the text to a log in I never

know if it's one word or two word it's

very confusing and we have to import the

react bootstrap button

let's take a quick look at our login

model

over here we set this to false

and we add another drawer

to Amazon science

log and model will be later set this up

properly

on dismiss and on login successfully

for which repairs empty functions for

now

just to see this

and as you can see the browser already

suggests to save the password because it

recognizes this as sign up and the login

form

okay here's our login form now it

doesn't make sense to try this out right

now the cookie is already saved first of

all we have to set up enough bar and

this navbar will then indicate if a user

is logged in or not because we will see

the username in the navbar

let's set this to false for now so that

we can set up our navbar and for the

navbar as usual we will use a react

bootstrap component this is how this nav

bars here look you can add different

stuff to them

different colors

different buttons and so on

so let's add it to our app so we add

another component to the components

folder

and I write the bar with an uppercase B

like this because the component from

react bootstrap is also called navbar

but with a lowercase b and this way the

names don't Clash

soar we set up a functional component

with the name navbar

and as usual we have to sign up the

props interface

with the arguments the snuffbar

component will take

the Snapback will take the locked in

user as an argument so that we can

display the name of the logged in user

but also the correct buttons either log

in and sign up or log out for this we

set the type of this to user

from our models folder

vertical barn now

so this can be either the locked in user

or null if there is no user locked in

currently

now why don't I make this an optional

property like this because I want to

force the color of the snuffbar

component to pass something here if we

used an optional parameter like this

then we could just omit this property

completely but our enough bar doesn't

work without the user even if it's

locked out we need this information so

this is why we declare this type like

this now we have to pass in a user even

if it's null and then we need a few

callbacks here for our different buttons

log in and out and everything

so the first one is called on sign up

clicked

when we click design up button we want

to open our sign up model in the ftsx

file now the question is why don't we

put the authentication models directly

into the navbar component then we

wouldn't need a skull back to the app

TSX file this is definitely an option

but then you have to keep in mind that

you can only open the models from within

the navbar code but you might have other

triggers in your app later that also

open the sign up or login model for

example if the user tries to do an

action that requires a user account this

is why we want to hoist this to the

color of this navbar okay and two more

let's duplicate this

the second one is

on login clicked

and then we have

on log out success file

because we will handle the log out

directly in here and then just notify

the ftsx files so that it can remove the

user data that's currently stored in the

memory okay then we add all these

properties here

locked in user on sign up clicked

unlock and clicked and unlock out

successful

and the type is our navbar props

okay and then let's start building the

navbar here and the return block

we use this navbar tag from react

bootstrap again this one has a lowercase

b that's not our own component it's

enough buff from react bootstrap

we can do some configuration here we can

set the background color

to primary which is this default Bluer

that react bootstrap components have you

can customize this with CSS if you want

but we won't do that here

the variant defines the text color we

said is too dark so that we have light

text on the blue background

expand defines Edward screen size the

navbar turns into this mobile mode where

we have this drop down menu that you

will see in a moment

so the Snapper is completely responsive

and we set this to LG to what size you

say this depends on how many buttons you

have in there if there are a lot of

buttons of course you have to collapse

earlier otherwise there will not be

enough room

and we set a sticky attribute to Top

This Way the nuff Bob will always be

visible even if we scroll down

but that's up to you and your preference

okay inside the snuff bar we add the

container which adds some padding so it

looks better and then we have different

components available which again I know

from the documentation

navbar brand adds a text or an image to

the left side which many websites have

when you click it you usually get back

to the home page

so let's enter a text in here Queen

Notes app but you can also use an image

if you want

and let's already display the softball

on our page where we are building it so

we go into the ftsx file

scroll up here to the notes page

container and we want to wrap this into

another div because we don't want to put

the snuff bar inside this container we

want to put it above it

select this and then here we can

use our navbar but this time with an

uppercase B because that's our own one

that's not the bootstrap one

foreign

user we just pass null right now and for

the callbacks

we pass empty carbex

we will hit this properly later

when we have this data

so here we pass an empty function

and there's our navbar

of course it's not finished yet but we

can already see our brand text let's

actually make this a bit bigger here

as I already mentioned we want to show

different content in our navbar

depending if we are logged in or logged

out because if we are logged out we want

to show a sign up and the login button

and if we are logged in we want to show

the username and the log out button so

now we could cram all of this in here

but it makes sense to extract this into

separate files for better organization

so we create another component in our

components folder

and recall this nuff bar locked in

viewer.tsx

I think the name is self-explaining

and we create a functional component

with the same name

this takes some properties

so interface

Enough by locked in view props

the first one will be the user

from our user models and this time it

doesn't have to be nullable because we

only show this if there is a user only

if we are logged in

but we need a callback for logging out

on lockout successful

which is a callback that Returns the

void

we add these properties here user unlock

out successful

of type navbar locked in viewer props

then we need a function for logging out

which we can put directly in this

component there's no real reason to

hoist it to the outside in my opinion

because the navbar is the only place

where we have a logout button

so we create an async function that we

call logout

doesn't take any arguments

try catch as usual because even for

logging out something can go wrong

because it's a post request to our

server which can always fail

in which case we want to lock the error

and alert it

then we need our notes API so I'm going

to copy this import statement here again

they wait it doesn't need to return

anything

notes API dot logout

and if this was successful we'll call

our callback

so that the ftsx file that contains the

navbar can then remove the user from

memory

and in here we put the content of the

navbar this will be two elements the

text we've designed and username and the

logout button and we want to display

these two elements here in our enough

bar later

as I already explained we can't put two

elements into a return statement they

need one parent element we could put

this into a diff but we basically just

want to render them as they are inside

this navbar here so we use a fragment as

we did earlier and the fragment allows

us to use two or more attacks in a place

where we could usually just use one

with a lowercase b and that's the

bootstrap one

dot text

we add the class name

m e minus 2 which adds some margin to

the end of this text

and this will say signed in as colon

and then we use a variable

we want to print user.username

this will be shown in the nuff bar and

then we add our log out button

which was a log out

and it needs an unclick attribute

which will

simply call our log out function up here

which will then handle the rest

now we also need a locked out navbar

viewer so we create another component

nav bar locked out viewer.tsx

sfc

this doesn't need a user because there

is no user logged in but it needs

callbacks for when we click the login or

sign up button

the interface

navbar locked out viewer props

and we need two callbacks

on design up clicked

and

can you guess it

unlock and clicked

we add these here

on sign up clicked

on login clicked

the type is navbar locked out view props

and then in here we have set up this

View

again we create a fragment that will

contain two buttons

the first one triggers our on sign up

clicked callback

and it says sign up

the second button

triggers our on login clicked callback

and the text says

login

that's it for the navbar locked out View

now let's go back to the navbar TSX file

and finish this

So Below enough bar brand we add navbar

dot talker

this is this button that will later

appear when the screen is small where we

can expand and collapse the manual in

Mobile viewer this needs a property

called area controls

which defines what menu this talker is

responsible for it will be responsible

for the main navbar

so we type it in like this

and then below we add enough bar

dot collapse which we give the same ID

here so this connects this toggle with

this navbar collapse which is the

collapsible manual

so we said the idea

to main navbar here as well you can set

any name you want they just have to be

identical

close this

and in here we put this enough Tech

which just aligns the elements probably

give it a class name of MS Auto

which adds a margin start of order to it

which means that these buttons and these

elements will be moved all the way to

the right so they will be at the end of

our navbar

so we close this as well

and then what we show in here is either

our navbar locked in or our locked audio

depending if we are locked in or not so

we add a pair of curly braces and check

our locked in user

which we passed with the snuff bar

in the next line we add a question mark

if there is a locked in user we want to

show our navbar locked in viewer

which expects some arguments it expects

the user

which is the locked in user which now

can't be null anymore because we have

this checkup here

and our on logout successful callback

which we forward to unlock out

successful

which is the property that repairs to

the navbar component

now as you can see when you have

components and other components you

often have to forward properties like

this so we have unlock out successful in

the nav bar but then we also have it in

the navbar locked in viewer to a certain

point this is okay this is called prop

drilling because you trade these props

into different layers if this gets too

much there are ways around this for

example your react context which you can

Google there's also something called

react query which gives some convenience

functions and hooks for when you will

fetch data from an API but this is

beyond the scope of this tutorial here

we use good old prop trailing because

you need to get a feel for how this

works when you are a beginner

and below this line we write colon for

when the user is null

then we want to show the navbar locked

out viewer

which needs to unlock and clicked

callback which we forward to unlock and

clicked

and the same for on sign up clicked

okay and after saving this we can see

that our token menu here appears

let's make this bigger because at a

certain point

this will not collapse anymore again the

size depends on what you want to put in

here we can actually make this expand

Point smaller because we only have these

two buttons here so let's set this to SM

which should be small so now it should

collapse a little bit later

so you can still it's still expanded

and here then collapses

I think that's more appropriate you can

set this back to LG if you add more

stuff to the navbar that just gets too

long so now we actually want to check if

the user is locked in and only show the

nodes in this case again we have to

handle this in the app TSX file but I

actually want to organize the code that

shows our nodes into a separate file

because it doesn't really belong into

app TSX it's not called organization and

also it will make the code messy when we

now have to add another conditioner that

checks if the user is null or not so

what we do is we create another

component

in the components folder

which we call nodes page locked in

viewer.tsx

create a functional component with the

same name

and then we want to cut out some code

from the ftsx file and move it over

there

the authentication models will stay in

the ftsx file but all these added and

add nodes dialogues belonging to our

newer logged in viewer because there

should only be available if a user is

logged in so we cut out node to edit

show add node dialog

the loading Spinners and everything

all the way up here to this button

cut this out

paste it over here

but since those are multiple elements we

have to put into a fragment like this

now we have to fix some import

statements and you can do this by just

removing the last letter

and then Auto completion will help you

on importing this again

at least for the components

add edit note dialog

the other stuff here is mostly still

over here

we need to copy over some states

basically all of those

move them in here

import use state

Auto completion doesn't work

let's copy it from over here

we need our node model

here we have to import this manually as

well because of the name

so we copy this line

put it in here

we have to fix the folder where it's

coming from I think we only have to add

the dot here yeah that works

and we need our style utils let's copy

this as well

paste it here fix the import as well

should look like this I think

import a spinner from react bootstrap

and our notes grid is still over there

of course we need that as well and we

also need our delete node and load nodes

functions actually the whole user effect

so we cut our use effect with load nodes

we cut our delete node and our whole

node squared

and even though it's a bit messy right

now it will be much better organized

after we have done this

so let's paste this here

let's do some imports missing

notes API

diodes is missing

this one here notes page

this is by the way why I call this notes

page module zss and not app module CSS

because I knew that we have to refactor

this later

okay and we need to import the row from

react bootstrap

and coil

and our node component

and this looks good

I think we got everything so let's

organize the import statements properly

for which there is a shortcut shift alt

or

which organizes them properly and gets

rid of the one we don't use

format and save the file and let's do

the same over here shift alt over

shift IDF to align everything properly

and let's save this

then we want to create a little notes

page locked out viewer but don't worry

this will be a

fast because you just print some text

there so another component

notes page locked out viewer dot TSX

we create a functional component

this one doesn't need to take any

arguments

and it will return a paragraph tag which

says please log in

to zero nodes of course you can always

make this more sophisticated

in your real app but for this tutorial

this will do files

okay and now we have to connect

everything in our app TSX file set up

the models and fetch the user and

everything and then we will be able to

log in and out from our front end so

this was a lot of work but we are almost

done with this part okay first of all we

need a state for the locked in user

when we open our page which Ibex

executes this app component we will try

to fetch the locked in user from the

back end by making a request to the get

authenticated user endpoint and remember

we are automatically sending our

credential cookies so we either get the

user back if we are logged in or we get

the 401 response if we are not logged in

in which case we will just ignore this

and then we can use our website as a not

locked in user so we call this locked in

user and The Zeta Zed locked in user

which is a used State we have to import

this again from react

let's copy it from over here

we will need to use effect as well

use state

of type user or Nile

if there is no user logged in and we

initialize this with no

and we have to import our user type here

we will also two states that indicate if

the sign up or the login model are

showing

So Below const

show

sign up model

and set a shower sign up model

which is the use state that we

initialize with faults

entry duplicators for login

so show login model and set show login

model

like this

then we need a user effect because as I

said as soon as we open this page we

want to try loading the user

which is a side effect

so we add a user effect like this

and before we forget it we add an empty

array down here so that we only execute

this one time when we open the page in

here we put an async function

that we call fetch locked in user

doesn't need any arguments

and below

we call this function and I explained

earlier where we have to do this because

we can't make this function that we pass

to use effect async we have to do it

over this intermediate function

and this gets a try catch block

if there is an error including our 401

response we actually don't want to show

a dialogue to the user we just want to

lock the arrow to the console

because otherwise every time the page is

opened without cookies it would show an

error message which we don't want now

later we will Implement a way to

distinguish between different errors so

that we could still show an error

message if it is not for one response

but for now this is sufficient

and here we will try to fetch the user

and save the return value in a variable

so Constitution equates a weight user

notes API we have to import this

dot get locked in user which we had set

up earlier or the import statement is

not correct

like this

doesn't need any input because again it

will automatically send the cookie that

we have stored

and if this went without an error then

we want to set our locked in user state

to what we get back

and we are almost done

to our nav bar down here

we want to pass the locked in user and

enough bar will then use this

information to decide what content to

show but we will see this in a bit

on login click it will set a show login

model to true

and on sign up click it will set show

sign up model tutorial

and in on logout successful we know that

we successfully destroyed the session

then we want to set locked in user back

to null

and the beauty of declarative UI is that

all of this will stay in sync

automatically when we set the locked in

user to null our navbar will

automatically be re-rendered with the

Nile logged in user and the same after

logging in but you will see there's an

action in a short moment

here for a sign up model we use our show

sign up model state

and here show login model

and up here we want to show the content

of this page depending if we are logged

in or not so we have to add a fragment

because otherwise we can't add this

conditional here

here we check for the locked in user

if there is a locked in user we want to

display the notes page locked in viewer

and otherwise

the notes page locked out View

again this automatically re-runnels when

this logged in user State changes and

these two components don't take any

props because they are completely

self-contained they handle their own

state

let's actually take these models and

move them out of this container it

doesn't matter because the models are

not affected by the container

but for better overview I want to have

them in this outer diff here

and now that I save this file you can

see that our navbar already displays the

locked in view really cool but we still

have to fill this callbacks down here so

on dismiss in the sign up model we'll

set our sign up model back to false

on this Mist down here we'll set your

login model to false

and remember when we designed in or log

in then we get the user back from the

API so that we don't have to run our

fetch locked in user again

instead we can set our user State

directly from the return value

so both of them

get a user test back because this is

what we defined here in this callback

in both of them we want to set the

logged in user to the return value so I

duplicate the cursor like this and I

type Z locked in user

and I pass the return value

like this

entry also want to close the models

again

so set show sign up model faults

and that show login model faults

and then we save everything

okay and now let's try the different

states so when we log out the user

should be set to null if it went

successful and our nodes should

disappear and we should see the locked

out view on there it is we will fix the

padding later but for now this is cool

let's try to log in Florian tour with a

wrong password first

invalid credentials we will put this

error message into the log and dialog

later instead of this alert dialog

because this is a bit annoying but for

now this is fine

log in it works the browser suggests to

save the password don't do this right

now and now we can see our notes again

and enough bar updates and again this is

the beauty of declarative UI everything

is synchronized through our state

automatically basically as long as we

declare it correctly of course right now

nodes are not tied to a specific user

yet so if I log out to a Florian tour

and log in with Florian one or just

Florian then we see the same notes oh I

forgot my credentials okay one two three

four five six right here

then we see the same nodes as in the

other account we will make it so that

each user has their own nodes later in

this tutorial but at least signing in

and out Works already

let's also try out if the cookie

expiration works so I go into our

backend code once again

and I'm gonna set this to a I don't know

20 seconds but I will we wrote this in a

moment just to see if this expires

correctly so I saved this I log out here

then I log in again to create a new

session

and then I wait 20 seconds and refresh

the page and see if we are still logged

in we shouldn't because I set the cookie

max age to a 20 seconds but this will

automatically refresh the session if we

do something on the page where the

session is still valid but if we don't

do anything this will expire okay 20

seconds have passed and when I refresh

this we are not locked in anymore

because the session expired but I want

to keep this at one hour or however long

you want you can also increase this

value and yeah the next step is to

actually tie nodes to a specific user

accounts so that's what we will do now

in order to tie a node to a specific

user we have to make a little change to

the node schema in our backend code so

let's search for the notes model

in our backend here

here we want to add one additional field

to the schema I'm going to put it at the

top you can also put it somewhere else

doesn't matter

we want to store the ID of the user that

created this nodes so later when we

retrieve nodes we can only retrieve the

notes for a particular user

the type of this field will be

mongoose's object ID type that we

already used earlier that's the one we

store in our session so we already have

schema here imported so we can just type

schema

dot types

dot object idea

and with that required to draw so that

every node needs a user ID attached to

it

comma and then we save these changes

and then in our notes routes we want to

do the same as we did in our get

authenticated user function inside the

user's controller

we want to check the idea that's stored

in the session and if there is no ID

stored in the session we want to return

a 401 response because the user is not

authenticated and they shouldn't be able

to retrieve or update or delete nodes

but this means that we have to repeat

this piece of code with the same error

message in many different endpoints

instead of repeating this for every

endpoint it makes sense to extract this

logic into our own middleware and then

we can use this middleware like we used

any other middleware by attaching it to

the routes that we want to protect

so let's do that now

in the source folder of our backend we

create a new folder

which we call middleware

here you can store all kinds of

middleware that you create yourself

and let's call it off.ts

in middleware is basically just a

request Handler just like our endpoint

controllers

so we create an export const

let's call it requires of

of type request Handler

wreck rest next

we already know that

and in here we simply check if the SS

session in the request object

that contains the user ID in other words

if a user is logged in

that's what we did in get authenticated

user earlier up here

then we want to call next and next

without an error simply occult the next

middleware so it forwards the request

and the response object to the next

middleware in the row which will then be

the endpoints itself

else if there is no authenticated user

we want to throw an HTTP error now we

could wrap this into a try catch block

and throw an error here but we can also

just

call next and forward the error directly

and since we don't have any other code

in here that can throw this is more

concise

remember we trigger our error middleware

at the very end simply by passing the

arrow to the next function this is also

what we did in all our endpoints just

that those were the arrows that we

caught in the try catch block but we can

also forward an error to the next

function directly and here we want to

use our 401

around that says

use are not authenticated

with the correct spelling of course

and now we can use this middleware on

all endpoints that we want to protect

and we don't have to repeat this chord

and now let's use this for our endpoints

and let's start with our get

authenticated user endpoint here so what

we do is we remove this check here this

will be replaced by our new middleware

and then we can also remove this

intermediate variable we can keep it but

we can also just

press rec.session.usid here directly

because we don't use it in another place

we save this then we go to the user's

routes

and use this middleware here we want to

use it for the get authenticated user

endpoint

let's see if Auto Import works it does

requires off

it adds this import here at the top and

the Order of these middlewares of course

matter we first want to check if the

user is authenticated before we call our

endpoint Handler otherwise this one here

would be executed first and then we

would check for off which doesn't make

much sense

so to see if this still works let's save

our code

and then open our website again

so the session has timed out meanwhile

let's refresh the page and it says user

not authenticated so we are still

getting our 401 response

but we shouldn't get it anymore after

logging in

so let's refresh it once again

and we get our authenticated user with a

200 response so it seems like our

endpoint still works properly just that

we extracted the authentication logic

into this middleware and now we can

reuse it on other endpoints as well and

we basically want to use it on all nodes

and points right because you can't

really interact with notes if you are

not authenticated so let's do that now

and now we can decide if we want to add

our requires of metalware only to

specific node endpoints in which case we

could add them here but we actually want

to add it to all of them so we can make

it easier and edit one level higher we

can add the middleware right here before

we forward to any of our notes routes

so here before notes routes

we also color requires of

and now just like that all our nodes and

points are protected by our

authentication middleware let's try it

out in Postman

first of all let's remove this once

again for a short moment just to see

that we can still retrieve all notes if

we don't have this middleware

so we want to make a get request to a

slash API slash nodes

here which returns us all notes right

now

now let's put the middleware back in

and there are no cookies set right now

so we shouldn't be authenticated

and now it says user not authenticated

with a 401 response which is triggered

by our middleware and this should also

work for creating new nodes updating or

deleting notes and everything else we

add to the notes routes so let's try

deleting a node from our database I

already refresh this just take a random

note here this idea

slash notes slash this idea a delete

request we are not authenticated user

not authenticated but right now this

only means that a user has to be logged

in to interact with the nodes but once

they are locked in every user can still

interact with all nodes because we

haven't added any logic that allows the

user to only retrieve their own nodes or

modify their own nodes so let's do that

now in our notes controller so the

authentication check is already in place

we only Reach This endpoint if we are

authenticated so now what we want to do

is we want to get the authenticated user

idea so const authenticated user idea

from the session so rec.session dot user

idea

but now we still have a little bit of a

type problem because authenticated user

ID could be possibly undefined there is

no guarantee that we set user ID on the

session now we kind of know that there

is a user ID because we have this

middleware in between that checks for

the user idea and throws the 401 error

if there is none but for one typescript

doesn't notice it's not smart enough to

recognize the middleware and say okay

the user ID will definitely be defined

but secondly even we can't really know

it because we can accidentally remove

this middleware and then this user ID

could be undefined and as I explained

earlier using undefined values in our

code is a bit dangerous because it could

make our app misbehave the one way to

handle this is just to be confident that

we added our middleware everywhere and

whenever we can't use an undefined value

we can use the normal assertion operator

on the exclamation mark but it's

actually better to have another check in

place that makes sure that the user ID

actually has a value so for this I want

to create another function that does

this check we put this into the YouTube

folder of our backend code

new file let's call it assert is

defined.ts and let's copy the name

because the function that we put in

there will have the same name

from here we want to export one function

with this name

and this function will take a generic

type argument which we do like this with

a pair of angle brackets and a big T in

between and then in between the

parentheses we write via colon tier

while it's just a variable name you can

give this any name you want and if you

haven't worked with generic types before

which is a feature that many languages

have this T basically allows us to pass

any type to this function so why don't

we use any instead of tier because we

actually want to get a non-nullable type

back there's a feature for that in

typescript which we do like this we add

the colon for the return type but

instead of defining a simple type

we write asserts which is a special

typescript keyword

and then again of this type tier and

then we add curly braces for the

function body now if this is confusing

to you don't worry you don't need to

understand this in detail and this

function will be very small it's just a

nice feature to use but as a simple

explanation this function allows us to

pass any type to it and then it will

check that this type is not null and

then on the outside where we use this

function we get the non-nullable type

bag that's basically it and this also

works for undefined so if we use this

for our possibly undefined user ID here

we can use this function and then know

that it is indeed an object idea

otherwise dysfunction will throw an

error which we do in the function body

so here we check if

exclamation marker value so if value is

undefined or null

then we want to throw an error

because again it's better to throw an

error if there's something wrong in our

code rather than using the wrong value

and having the server misbehave and in

here we pass an error message something

that allows us to later identify the

error so let's write expected and then

in single quotes buyer

to be defined

but received and then we can

add value itself which will then say

another undefined depending on what the

value is

and that's all for this function

if you want to learn more about the

syntax you can read the documentation

but for our example here this is all we

need and in here we want to use this new

function let's put it into the try block

so that if this function throws our

whole Server doesn't crash only this

endpoint here will return a 500 response

which is appropriate because we messed

something up in our code when this

happens

so we call assert is defined

and pass the authenticated user idea

and this is actually all we have to do

when we use this authenticated user ID

afterwards it will have the appropriate

type because typescript is smart enough

to know infer this type because of this

special syntax here

this function asserts that authenticated

user idea is defined so it has a value

again you don't have to do this but it's

a nice security measure and I think it's

a cool typescript feature to learn about

and now in our find call down here we

only want to return the nodes for that

specific user so we add a pair of

calibrators to add the filter here

we want to check the user idea of our

node model that we just added a moment

ago

and we want to compare it with the

authenticated user idea which Noah

definitely has a value because we are

past this assert as defined check

before we add this to the remaining

endpoints let's quickly try it out

let's remove the requires of middleware

from the notes routes once again

and let's try to make a get request

without being authenticated

an unknown error occurred it's a 500

response with this generic error message

because it's not a HTTP error we threw

here and in our FTS file we only handle

HTTP errors and otherwise we file back

to this an unknown error occurred

message but I think this is fine because

when an error like this happens the user

doesn't really need to know what

happened in our code instead we just

lock this error which will print the

whole message to the console so it

should be visible in our backend

terminal

yeah expected value to be defined but

received undefined and as long as we

know it everything is fine the user

doesn't have to see this error message

now let's add this to our remaining

endpoints here

get node is the next one

here we also want to get the

authenticated user ID so let's copy

paste this line

then at the start of the try block we

want to check assert as defined to make

sure this has a value

so we have to reuse this everywhere and

then we have to add some code that only

allows the user to access this node if

the user ID is fit right so after the

note was found we can check if this node

belongs to this user

so we do if

exclamation mark

note dot user idea which is of type

object idea and to compare objects IDs

we have this equals function here that

belongs to this type

we want to compare it with the

authenticated user idea

so exclamation marks so if they don't

match then we want to throw another

error

throw create HTTP error for one response

for not authorized

you cannot access this node

maybe without the exclamation mark

and now this node endpoint is protected

properly

the next one is create note again we

need to extract the authenticated use ID

from this session

let's do it here

we need to check that it's defined so we

copy this as well the start of our try

block

and now when we create this node we also

have to pass the user idea it's a

required field now so this wouldn't work

without the user ID and since we have

our off middleware we shouldn't be able

to get to this create nodes function

unless we are authenticated

so we want to store the authenticated

user idea in the node as well

then we copy this authenticated user ID

once again

for update node

we copy assert as defined

put it here

and then we want to do the same thing as

we did for get node we want to copy this

block here you cannot access this node

and do this check after we checked if

this node actually exists

now of course you can always extract

some of this validation logic into a

separate function that you can put for

example directly into this controller

file for Simplicity I will just copy

paste the code that we need on different

endpoints because maybe you also want to

use different error messages for the

different endpoints in which case you

have to write the stuff over and over

again

and one more time for delete note so

again we copy this line

paste it here we copy assert as defined

paste it here

and we need our

check for the user idea as well

after we check that the node exists

and save everything

this will now after saving everything

when we refresh our front end these

nodes here should disappear because they

are not tied to a user they don't have a

user ID attached to them but now we only

get notes with our authenticated user ID

back which is stored in the session

cookie

this one so let's refresh this page

you don't have any notes yet

let's create a node for this user

authenticated

note

this is my private note

okay there's still something off with

the formatting I know why we will fix

this in a moment for now let's log out

with this user with Florian

log in with florian2

who doesn't see this note

because it's not tied to a specific user

account

Florian 2 snort

this note is

a secret

so again this is attached to this user

account

log out into the other one

and we won't see this note

only our own one

nice

now let's fix this formatting here real

quick

earlier in our notes page modules yes S5

we created this node squid class with

width 100 but we never used it anywhere

so we go into our notes page logged in

View and when we scroll down we have a

typo here we call it node grid but the

class is called notes grid now it should

be fixed

yeah it looks better now

let's add the second note

authenticated

note number two

and the layout looks good now

and when we look into our database

we will see that our new nodes now have

a user idea attached to them our old

nodes don't because we created them

before we require the user idea but here

our new nodes have this user idea so

these other notes are basically off and

now no one will be able to receive them

you can delete them from the database

you can keep them as a memory I don't

care

and our backend code is finished for now

we now created the fully blown server

with user authentication and different

endpoints of course there are more

features and little things you can add

but you can always figure this out

yourself or keep an eye open for my

future courses that I'm building where I

also want to cover more advanced topics

but this is already pretty cool the

course is not quite over yet because we

still have to make some improvements to

our front end first of all the styling

isn't great yet there are still some

problems here we like the missing

padding but even more important there

are some improvements we want to make to

the way we handle errors so that we

don't only always show the alert dialog

which is really annoying and I also want

to show you how you can navigate between

different pages in react because we

haven't done this yet we only have this

one page right now we will add

additional pages and then navigate

between them so that they are even

represented in relative ul's on our

front end like localhost 3000 slash

privacy for example and remember but

after that there is another video

waiting for you only notes Channel where

we deploy this whole thing to a real

server and if you want to put this

project into your portfolio for example

to get hired later it's a good idea to

actually deploy something to production

rather than only putting the project on

your GitHub profile because this way you

can prove that the thing you build

actually works and it's easier for

recruiters and employers to access your

project and try it out without access to

your GitHub account so you don't want to

miss out on the part where we deployed

this whole thing

to navigate between different pages in

our react app we can use this very

popular package called react router

because remember in a react app

everything is one single page basically

and the only thing we can really do is

replacing components that are rendered

on the screen but react router basically

gives this process more structure by

mapping different components that we use

as pages to different relative URLs so

that we can have something like a slash

privacy page where we render the page

component for the privacy policy slash

nodes and so on

as usual the documentation for this

package is humongous but we don't need

to know all of this you can just follow

along but we need to install it so let's

open the terminal for the front end

so I'm going to ZD into the front end

and we run npmi

react

router Dom that's the name of the whole

package that we need

and start a sucker

and right now here in our ftsx file our

notes page is hard coded yeah into the

page what we want to do is we want to

extract this into a separate file so

that we can replace this part here when

we navigate to different pages

so let's create a new folder in our

front end Source folder here

which we call pages

and inside this Pages folder we create a

file

code notes page.tsx

where we want to extract this piece of

code here into

so let's

split the editor

create a functional component with the

same name

and then we cut out this container here

put it over here

fix the import statements container from

react bootstrap

notes page locked in viewer from our own

components

and the locked out viewer

we also need a styles

which we can cut out here

paste here

but this page needs the currently logged

end user to know which of the views here

to render so we have to pass this as a

property

so we create an interface notes page

props

which receives the locked in user

which can be logged in or not so it's

either user

or no

if the user isn't logged in

and then we add a prop down here

locked in user and the type of these

props is notes page Pros

and now the same as before we check this

user to decide if we render the locked

in view or the locked audio and the rest

works the same as before

we can also remove this unused import

statements over here

shift alt or

and they are gone

before we set this up let's create

another page that we can navigate to

gonna close this

and create another file in the pages

folder

which I call a privacy page

dot TSX

recreate the functional component with

the same name

and I actually hired a lawyer just to

make this course that came up with a

elaborate privacy policy

he told me to write this

we care about your privacy

promise

this way you are safe and no one can

ever sue you of course that's a joke I

can't take any liability for your

privacy policy or any other legal topics

this is not legal advice

let's save this and let's actually

create a third page I want to have a

fallback page for when we try to access

a URL that doesn't exist so we want a

page not found page so we create another

file in the pages folder

which require not a found page

dot TSX

again this contains a div

with a paragraph

that says page not found

of course you can make this always more

elaborate

okay back into our app TSX file in order

to implement react router Dom we have to

wrap this whole diff here

into this browser router tag

this basically activates this routing

functionality

and this is the place where we want to

navigate between our different pages the

navbar is unaffected by this because the

navbar stays in place no matter what

page we are on right and our models can

also show on any page because they are

triggered by the buttons in our navbar

so in between these two parts where our

nodes page code was before

we add a container from react bootstrap

again container centers the content and

gives it some padding and also I want to

add some styling to it later and in here

we add this routes tag this one here

routes from react router

as the name implies this allows us to

set up routes in here between which we

can navigate and now registering these

different routes is actually quite easy

for each route we create a route tag

this time it's not routes it's route

close this tag

and then we give it two attributes the

first one is the path so the relative

URL to this page

for the first one we just use a slash

because we want to show our notes page

on the base URL you can also put this on

slash nodes and add a different home

page but that's something you can do

yourself

then we have to define the element which

is the component that we want to render

for this page

so between curly braces

we pass our notes page component that we

created earlier

which takes the locked end user as a

prop

ER and then let's add the other Pages as

well

so we create another route

the second one will go to a slash

privacy

and for the element we want to render

the Privacy page

and for any URL that we didn't specify

we want to file back to our not found

page

which you can do like this we add

another route

but for the path

repairs slash and the star

this fits any URL but before it checks

this one it checks the ones above it so

if none of these match it will fall back

to this one here

and for the element

we pass our not found page

and as simple as that our routes are set

up let's save everything

open our cool Notes app

and there seems to be something wrong

with an import here

in the notes page TSX file and the

import to the

CSS module is wrong

so notes page dot TSX

I guess that's two dots now let's try it

out

and now it works again so let's try it

out manually let's type in slash privacy

in the URL and here's our nice privacy

policy of course the styling is not good

you can improve this yourself if you

want

and then let's type in a URL that

doesn't exist and we fall back to our

page not phone page

and now before we go to the next step

let's fix the padding here so what we

can do is we can take the container of

this page and just add some padding to

the top and it will be applied to all

our Pages here

so back into ftsx

we need a new CSS module for our app TSX

file because all the other CSS move to

these different pages and components we

created so we create another file in

styles

which we call app.module.css

and again this module will be scoped to

the ftsx file and not clash with any

other class names and here I want to

create a page container class

on which we set a padding

gonna use 32 pixels for the first value

which are the vertical values so top and

bottom and for the left and right side

I'm going to use 0 because everything is

centered anyway

and then we import this in ftsx

Imports diodes from

dot slash Styles slash app Dot

module.css

and then we scroll down to our container

here

and add this class

Styles Dot Page

container

and now when we save this and open our

quill Notes app again we have this

padding here applied

which will work on any page now

looks much better

now let's add a menu point to our navbar

with which we can navigate to our

privacy page and let's make this brand

text here behave like a link tool so we

can click it to get back to our notes

page

so back into our code we want to go into

our navbar component

so Above This enough with MSR tour we

create another nav tag

we put it outside of this part here

because these buttons will be on the

right side and I want to have the links

on the left side this is why it goes

outside of this margin start Auto attack

here and also from bootstrap we have

this nuff link components

which just at a properly stated link to

the navbar that looks good

this one with a privacy

and it needs an href attribute which is

the link where we want to link this tool

we want to go to slash privacy

so let's save this and try it out

we now have this link up here and when

we click it we go to the Privacy page

but if you pay close attention the way

this works is not quite optimal yet

since this is a normal link it will

actually refresh the whole page which

means that the user that we stored in

memory disappears for a moment and we

also see the navbar flashing up because

the whole page is replaced let's take a

look at it again it looks weird you can

see that we are locked out for a moment

so to speak why because it's fetching

the user again

we don't want it to behave like this

instead we want this to behave like a

real app we had enough ball stays in

place and only these parts down here are

replaced right

this is where we can't use a normal href

link for internal app navigation because

it will always refresh the page to

handle this internal app navigation we

want to use a special link component

from the react router package

we have to import this manually I

checked it a moment ago the auto

completion didn't work so we import it

like this link between curly braces

from react router Dom down here

and then we go inside the nuff link

and we wrap this privacy text

into this reactor rather Dom link

and then we cut out the slash privacy

here remove the href attribute because

we want to let the react router domlink

navigate

which we do we add this tool prop

now the syntax is where we were both

with the snuff link and this link inside

it we will actually improve this in a

moment but for Simplicity I want to show

it like this first so we go to the cool

Notes app again and now the styling is

completely off as you can see the color

doesn't work properly anymore which is

the case because we invested these

different components but we will fix

this in a moment

the important thing is when we now click

this we will navigate to the Privacy

page but the navbar will not refresh and

the user will stay logged in click it

and as you can see it's a much smoother

transition

and even when we press the back button

the behavior is the same

it doesn't refresh the whole page

but now let's fix the styling here

what we can do is we can keep using the

nuff link but we can render it as a link

from the react router Dom package and

again I figure this out through Google

this is a special syntax that we can use

on this bootstrap components and this

feature is called render props it's a

certain design pattern and reacts that

you can also build yourself if you need

it and some packages like react

bootstrap use that for certain

components so what we can do is on the

nav link we can pass this as prop

with one else not two and here we can

tell react bootstrap to use the styling

and everything from the nuff link but

actually render a different component

when this is displayed on the screen and

in here we can pass the link from react

router Dom

and the cool thing is now that we render

this as a react router Dom link it also

behaves like a react router dumpling

this is why we now see this error that

tells us that we need this two attribute

that's the two attribute down here now

that we render this link up here we have

to pass this to attribute here as well

and now we can remove this intermediate

link here in between

and now basically we are using a react

router Dom link but we are using the

styling of a normal bootstrap nuff link

so when we save this and go back to our

app now The Styling is correct again and

it behaves

like a react router link

okay now let's also make the cool Notes

app brand text here clickable

so we go into navbar brand

and here we use this as attribute as

well we want to render a react router

link

and we want to navigate tour slash as a

string so this is just the home page

and it already is

you can zip this trade out and now this

one here is clickable as well you can go

to privacy and back to the home page

cool stuff

okay our page itself is almost complete

but there's one more important topic I

want to teach you and that's how we can

distinguish between different errors on

our front end because right now for

every arrow we do the exact same thing

we lock the error message and show an

alert dialog but you might want to

handle different errors differently so

that's what we will learn next

distinguishing between different arrows

on the front end allows us to handle

them differently for example when we try

to log in with invalid credentials and

we get a 401 error back then we probably

want to display this differently than

internal Zara arrows for example so if

the credentials are incorrect we want to

display a little error text here above

the input Fields so what we do is we go

into our front end code

and create a new file here

we put it into a front-end Source here

we create a new folder first

which we call errors

and in here we create a file called http

arrows.ts

and in here we Define some classes that

allow us to distinguish between

different errors that we receive now I

guess we could also use the HTTP errors

package that we used on the back end but

I think this is a bit Overkill because

it has all these functions to create

errors but on the front end we don't

want to create errors we only receive

them and want to distinguish between

them so I think we don't need to add

this package instead we will just create

some small classes that allow us to

distinguish between these different

errors so what we do is we create a

class called HTTP error

extends error

we use a class instead of an interface

this time because error is also a class

and we want to extend the normal error

to add our own fields to it

and here we add a Constructor if you

have any programming experience then you

know what the Constructor is the same as

the normal error class our class will

take an optional message that we can

store in this error and show later the

question mark colon

trippy of type string

and then we want to pass this message to

the superclass to Stuart in the normal

error message field so we call Super

and pass the message here

the reason why we overwrite The

Constructor is because we also want to

set the name attribute of the error

and set it to this dot Constructor

dot name

and this means that when we create a

subclass of HTTP error it will use the

name of the class itself and put it into

this name field and now below we want to

do exactly that we want to create a

fewer subclasses of HTTP error that then

allow us to distinguish between

different error codes and we export

these because we want to use them on the

outside we don't want to use the generic

HTTP error on the outside only the

subclasses are meant to be used

throughout our code so we write export

class and the first one is for 401

responses when we are not authorized so

we colored

unauthorized error

and it extends

our HTTP error class

and again our HTTP hour class does is

basically putting the name of

unauthorized error into the name field

of the error class

and every class needs a body but we can

keep this body empty because we don't

want to do anything special in here we

just need this name to distinguish

between the different error codes

and we will also add a documentation

comment here

with a slash and tour style symbols

and here we can write a message that we

will then see when we hover over this

class I'm just gonna set this to a 401

so now when we hover over on authorized

around we can see for one actually let's

write

status code 401

this just makes it a bit easier later to

remember what the status code each error

was and then we create the second one

below

export class

we call this one conflict error

which we use for four or nine responses

for example when we try to sign up with

an email that already exists

it also extends HTTP error with an empty

body

and create a documentation command as

well

status code 409

and I'm also going to add another

comment here at the bottom

which was a it's more error classes if

you need

distinction this is just a reminder for

you that you can always add more error

classes here

then we go into our notes API file here

in our Network folder

and all the way up into fetch data where

we now want to distinguish between these

different arrows because right now we

always throw this generic error class

so we go above this line

and we simply check for the status codes

so that we know whichever we have to

throw so if

response dot status

is equal to 401

then we want to throw

an unauthorized error

which will also contain the error

message

and we actually have to add the new

keyword here in front of it for normal

errors you don't have to do this you can

if you want but since this is our own

custom class we have to add a new

keyword in order to instantiate it

then we do an else if because now we

want to check if response dot status is

equal to 409

in which case we want to throw

a conflict error

which will also take the error message

and only if both of those are not the

case we want to go to the else block and

throw our normal error

and we can also make the error message a

bit more elaborate so we see which

status code we got from the error

message itself

so I'm going to pass a string that says

request failed with status colon

then I append response dot status

and add something more to the string

message colon

and error message

you don't have to do this but I think

it's a good idea

now let's save this and update a few

places in our app first of all let's go

into our login model

and instead of RS showing this alert

message when we get a 401 response back

because the password or the username was

wrong we want to show an error message

that is embedded in the dialog directly

instead the first of all we need a state

for this

that decides if this error message is

shown or not

so const let's call it error text

and set error text

equals use State Auto Import often

doesn't work for you state I don't know

why

let's take it from somewhere else

here you state

we actually don't need use effect

we call you state

we set the type to a string or another

because if there is no error we want to

set this to Nile

then here in the catch block we want to

check

if

error

instance of

which is a keyword that we can use to

compare the type of this error if this

is an instance of an authorized error

which has the status code 401 we can

remember this by hovering over it

then we want to set the error text

to error Dot message

and if this is any other type of error

we want to do the same as before we want

to show the alert dialog or just lock it

or whatever you want

and we will lock the error in both cases

so we put it outside of the if block

and now we also need an element in the

model body here that actually displays

this error let's put it here inside the

model body but above the form

we check if error text is defined so

error text and to Embers enzymes

then we want to show an alert which is

another bootstrap component

and this alert will show the error text

from the state

and we set the variant to Danger which

gives this some nice styling it makes it

red

let's save it and try it out

let's go to our quill Notes app

and try to log in with invalid

credentials and now we see this message

here instead but any error that's not a

401 error will just show the usual alert

dialog as we had before let's do the

same for our sign up model

so we open the design about the TSX file

again we need a state

const

error text and set error text

use State again we have to import this

manually

use state of type string or null

and we initialize it with null

and then down here

we want to check if error instance off

and this time we use conflict error

which is the status code that we return

When the username or the email is

already in use right 409

then we want to set the error text

to error.message

else we want to use the same alert as we

had before and we want to lock the error

in both cases

again we need our

Alert warning here in the model body

so error text

to Ampersand science

alert

variant Danger

and for the text we display the error

text

okay let's try this out as well

so we open the sign up model and I use a

username that already exists test at

test.com

we try to sign up and with the username

already taken please choose a different

one or log in instead and this is the

error message that's coming from our

server

from our

user controller

username already taken and the other one

which you can try out as well

so we use a different username but in

email that already exists I forgot which

email I used earlier florian2a test.com

a user with this email address already

exists

and we get the error message directly

from the server because we read it from

the response body

and then pass it to our error here

and then we display this in the UI

through this error.message field

and of course you can use the same

approach to distinguish between

different errors in different places in

your app and this way decide what you

want to do with them

all right we have successfully created

our first mon app this is a special

moment that you will always remember and

of course you will like this video and

share it with someone that could need it

because this helps me and you are a very

thankful person that wants to give back

although I heard remember that there is

another video where we deploy this whole

thing only notes Channel you can find

the link in the video description below

you definitely have to watch this as

well because building this app and then

not deploying it would be a waste also

of course there are a lot more features

we could add to our Merin app and keep

an eye open on this channel because I

want to make more web development

tutorials so subscribe if you haven't

yet and if you build a cool project on

top of our moon app rebuild here if you

have some cool features that you added

or a project that you deployed or added

to your portfolio that I would be very

happy if you tag me on Twitter and just

show it to me tag me ads either at

coding in floor or flow and score Volta

which is my personal account doesn't

matter which one and then I wish you

best of luck and happy coding take care