NODE.JS Backend Development
Embark on an exciting journey into the world of backend development tools, where coding prowess meets innovation. Backend development tools are the architects behind seamless digital experiences, enabling robust server-side functionalities. From databases to server frameworks, these tools empower developers to create dynamic and scalable applications. Join us in mastering the art of backend development tools, and unlock the potential to build the digital future
(1342) Enrolled
RS 9999/-
Register Now
Introduction :
1. Introduction
2. What is Node.js?
3. Join our Online Learning Community
4. Installing Node.js and Creating our First App
5. Understanding the Role & Usage of Node.js
6. Course Outline
7. How To Get The Most Out Of The Course
8. Working with the REPL vs Using Files
9. Using the Attached Source Code
Optional: JavaScript - A Quick Refresher:
10. Module Introduction
11. JavaScript in a Nutshell
12. Refreshing the Core Syntax
13. let & const
14. Understanding Arrow Functions
15. Working with Objects, Properties & Methods
16. Arrays & Array Methods
17. Arrays, Objects & Reference Types
18. Understanding Spread & Rest Operators
19. Destructuring
20. Async Code & Promises
21. Template Literals
22. Wrap Up
23. Useful & Links
Understanding the Basics:
24. Module Introduction
25. How The Web Works
26. Creating a Node Server
27. The Node Lifecycle & Event Loop
28. Controlling the Node.js Process
29. Understanding Requests
30. Sending Responses
31. Request & Response Headers
32. Routing Requests
33. Redirecting Requests
34. Parsing Request Bodies
35. Understanding Event Driven Code Execution
36. Blocking and Non-Blocking Code
37. Node.js – Looking Behind the Scenes
38. Using the Node Modules System
39. Wrap Up
Assignment 1: Time to Practice – The Basics
40. Useful & Links
Improved Development Workflow & Debugging :
41. Module Introduction
42. Understanding NPM Scripts
43. Installing 3rd Party Packages
44. Global Features vs Core Modules vs Third-Party Modules
45. Using Nodemon for Autores
46. Global & Local npm Packages
47. Understanding different Error Types
48. Finding & Fixing Syntax Errors
49. Dealing with Runtime Errors
50. Logical Errors
51. Using the Debugger
52. Reing the Debugger Automatically After Editing our App
53. Debugging Node.js in Visual Studio Code
54. Changing Variables in the Debug Console
55. Wrap Up
56. Useful & Links
Working with Express.js :
57. Module Introduction
58. What is Express.js?
59. Installing Express.js
60. Adding Middleware
61. How Middleware Works
62. Express.js – Looking Behind the Scenes
63. Handling Different Routes
64. Assignment 2: Time to Practice – Express.js
g Requests
65. Limiting Middleware Execution to POST Requests
66. Using Express Router
67. Adding a 404 Error Page
68. Filtering Paths
69. Creating HTML Pages
70. Serving HTML Pages
71. Returning a 404 Page
72. A Hint!
73. Using a Helper Function for Navigation
74. Styling our Pages
75. Serving Files Statically
Assignment 3: Time to Practice – Navigation
76. Wrap Up
77. Useful & Links
Working with Dynamic Content & Adding Templating Engines:
78. Module Introduction
79. Sharing Data Across Requests & Users
80. Templating Engines – An Overview
81. Installing & Implementing Pug
82. Outputting Dynamic Content
83. Official Pug Docs
84. Converting HTML Files to Pug
85. Adding a Layout
86. Finishing the Pug Template
87. Avoiding an Error
88. Working with Handlebars
89. Converting our Project to Handlebars
90. Adding the Layout to Handlebars
91. Working with EJS
92. Working on the Layout with Partials
93. Wrap Up
Assignment 4: Time to Practice – Templating Engines
94. [OPTIONAL] Assignment Solution
95. Useful & Links
The Model View Controller (MVC) :
96. Module Introduction
97. What is the MVC?
98. Adding Controllers
99. Finishing the Controllers
100. Adding a Product Model
101. Storing Data in Files Via the Model
102. Fetching Data from Files Via the Model
103. Refactoring the File Storage Code
104. Wrap Up
105. Useful & Links
Optional: Enhancing the App
106. Module Introduction
107. Creating the Shop Structure
108. Working on the Navigation
109. Registering the Routes
110. Storing Product Data
111. Dising Product Data
112. Editing & Deleting Products
113. Adding Another Item
114. Useful & Links
Dynamic Routes & Advanced Models :
115. Module Introduction
116. Preparations
117. Applied Changes
118. Adding the Product ID to the Path
119. Extracting Dynamic Params
120. Loading Product Detail Data
121. Rendering the Product Detail View
122. Passing Data with POST Requests
123. Adding a Cart Model
124. Using Query Params
125. Pre-Populating the Edit Product Page with Data
126. Linking to the Edit Page
127. Editing the Product Data
128. Adding the Product-Delete Functionality
129. Deleting Cart Items
130. Dising Cart Items on the Cart Page
131. Deleting Cart Items
132. Fixing a Delete Product Bug
133. Wrap Up
134. Useful & Links
SQL Introduction :
135. Module Introduction
136. Choosing a Database
137. NoSQL Introduction
138. Comparing SQL and NoSQL
139. Setting Up MySQL
140. Connecting our App to the SQL Database
141. Basic SQL & Creating a Table
142. Retrieving Data
143. Fetching Products
144. Fetching Products – Time to Practice
145. Inserting Data Into the Database
146. Fetching a Single Product with the “where” Condition
147. Wrap Up
148. Useful & Links
Understanding Sequelize :
149. Module Introduction
150. What is Sequelize?
151. Connecting to the Database
152. Defining a Model
153. Syncing JS Definitions to the Database
154. Inserting Data & Creating a Product
155. MUST READ: findById() in Sequelize 5
156. Retrieving Data & Finding Products
157. Getting a Single Product with the “where” Condition Products
159. Updating Products
160. Deleting Products
161. Creating a User Model
162. Adding a One-To-Many Relationship
163. Creating & Managing a Dummy User
164. Using Magic Association Methods
165. Fetching Related Products
166. One-To-Many & Many-To-Many Relations
167. Creating & Fetching a Cart
168. Adding New Products to the Cart
169. Adding Existing Products & Retrieving Cart Items
170. Deleting Related Items & Deleting Cart Products
171. Adding an Order Model
172. Storing Cartitems as Orderitems
173. Resetting the Cart & Fetching and Outputting Orders
174. Wrap Up
175. Useful & Links
Working with NoSQL & Using MongoDB :
176. Module Introduction
177. What is MongoDB?
178. Relations in NoSQL
179. Setting Up MongoDB
180. Installing the MongoDB Driver
181. Creating the Database Connection
182. Finishing the Database Connection
183. Using the Database Connection
184. Creating Products
185. Understanding the MongoDB Compass
186. Fetching All Products
187. Fetching a Single Product
188. Making the “Edit” & “Delete” Buttons Work Again
189. Working on the Product Model to Edit our Product
190. Finishing the “Update Product” Code
191. One Note About Updating Products
192. Deleting Products
193. Fixing the “Add Product” Functionality
194. Creating New Users
195. Storing the User in our Database
196. Working on Cart Items & Orders
197. Adding the “Add to Cart” Functionality
198. Storing Multiple Products in the Cart
199. Dising the Cart Items
200. Fixing a Bug
201. Deleting Cart Items
202. Adding an Order
203. Adding Relational Order Data
204. Getting Orders
205. Removing Deleted Items From the Cart
206. Wrap Up
207. Useful & Links
208. Two Adjustments (behind the scenes)
Working with Mongoose :
209. Module Introduction
210. What is Mongoose?
211. Connecting to the MongoDB Server with Mongoose
212. Creating the Product Schema
213. Saving Data Through Mongoose
214. Fetching All Products
215. Fetching a Single Product
216. Updating Products
217. Deleting Products
218. Adding and Using a User Model
219. Using Relations in Mongoose
220. One Important Thing About Fetching Relations
221. Working on the Shopping Cart
222. Loading the Cart
223. Deleting Cart Items
224. Creating & Getting Orders
225. Storing All Order Related Data
226. Clearing the Cart After Storing an Order
227. Getting & Dising the Orders
228. Wrap Up
229. Useful & Links
Sessions & Cookies:
230. Module Introduction
231. What is a Cookie?
232. The Current Project Status
233. Optional: Creating the Login Form
234. Adding the Request Driven Login Solution
235. Setting a Cookie
236. Manipulating Cookies
237. Configuring Cookies
238. What is a Session?
239. Initializing the Session Middleware
240. Using the Session Middleware
241. Using MongoDB to Store Sessions
242. Sessions & Cookies – A Short Summary
Assignment 5: Time to Practice – Sessions and Cookies
243. Deleting a Cookie or Bugs
245. Making “Add to Cart” Work Again
246. Two Tiny Improvements
247. Wrap Up
248. Code Adjustments
249. Useful & Links
Adding Authentication:
250. Module Introduction
251. What is Authentication?
252. How is Authentication Implemented?
253. Our Updated Project Status
254. Implementing an Authentication Flow
255. Encrypting Passwords
256. Adding a Tiny Code Improvement
257. Adding the Signin Functionality
258. Working on Route Protection
259. Using Middleware to Protect Routes
260. Understanding CSRF Attacks
261. Using a CSRF Token
262. Adding CSRF Protection
263. csurf() Alternatives
264. Fixing the Order Button
265. Providing User Feedback
266. Optional: Styling Error Messages
267. Finishing the Flash Messages
268. Adding Additional Flash Messages
269. Wrap Up
270. Useful & Links
Sending Emails:
271. Module Introduction
272. How Does Sending Emails Work?
273. Using SendGrid
274. Using Nodemailer to Send an Email
275. Potential Limitation for Large Scale Apps
276. Useful & Links
Advanced Authentication:
277. Module Introduction
278. Resetting Passwords
279. Implementing the Token Logic
280. Creating the Token
281. Creating the Reset Password Form
282. Adding Logic to Update the Password
283. Why we Need Authorization
284. Adding Authorization
285. Adding Protection to Post Actions
286. Why Editing Fails
287. Wrap Up
288. Useful & Links
Understanding Validation:
289. Module Introduction
290. Why Should We Use Validation?
291. How to Validate Input?
292. Setup & Basic Validation
293. Using Validation Error Messages
294. Built-In & Custom Validators
295. More Validators
296. Checking For Field Equality
297. Adding Async Validation
Assignment 6: Time to Practice – Validation
298. Keeping User Input
299. Adding Conditional CSS Classes
300. Adding Validation to Login
301. Sanitizing Data
302. Validating Product Addition
303. Validating Product Editing
304. Wrap Up
305. Useful & Links
Error Handling:
306. Module Introduction
307. Types of Errors & Error Handling
308. Analyzing the Error Handling in the Current Project
309. Errors – Some Theory
310. Throwing Errors in Code
311. Returning Error Pages
312. Using the Express.js Error Handling Middleware
313. Updating the App
314. Using the Error Handling Middleware Correctly
315. Status Codes
316. Available Status Codes
317. Wrap Up
318. Useful & Links
File Upload & Download:
319. Module Introduction
320. Adding a File Picker to the Frontend
321. Handling Multipart Form Data
322. Handling File Uploads with Multer
323. Configuring Multer to Adjust Filename & Filepath
324. Filtering Files by Mimetype
325. Storing File Data in the Database
326. Remove imageUrl from “Add Product”
327. Serving Images Statically
328. Downloading Files with Authentication
329. Setting File Type Headers
330. Restricting File Access
g Data vs Preloading Data
332. Using PDFKit for .pdf Generation
333. Generating .pdf Files with Order Data
334. Deleting Files
335. Fixing Invoice Links
336. Wrap Up
337. Useful & Links
Adding Pagination:
338. Module Introduction
339. Adding Pagination Links
340. Retrieving a Chunk of Data
341. Skip & Limit with SQL
342. Preparing Pagination Data on the Server
343. Adding Dynamic Pagination Buttons
344. Re-Using the Pagination Logic & Controls
345. Wrap Up
346. Useful & Links
Understanding Async Requests:
347. Module Introduction
348. What are Async Requests?
349. Adding Client Side JS Code
350. The JSON Data Format
351. Sending & Handling Background Requests
352. Manipulating the DOM
353. Useful & Links
Adding Payments:
354. Module Introduction
355. How Payments Work
356. Adding a Checkout Page
357. Using Stripe in Your App
358. Useful & Links
Working with REST APIs - The Basics:
359. Module Introduction
360. What are REST APIs and why do we use Them?
361. Accessing Data with REST APIs
362. Understanding Routing & HTTP Methods
363. REST APIs – The Core Principles
364. Creating our REST API Project & Implementing the Route Setup
365. Sending Requests & Responses and Working with Postman
366. REST APIs, Clients & CORS Errors
367. Sending POST Requests
368. Wrap Up
369. Useful & Links
Working with REST APIs - The Practical Application:
370. Module Introduction
371. REST APIs & The Rest Of The Course
372. Understanding the Frontend Setup
373. Planning the API
374. Fetching Lists of Posts
375. Adding a Create Post Endpoint
376. Adding Server Side Validation
377. Setting Up a Post Model
378. Storing Posts in the Database
379. Static Images & Error Handling
380. Fetching a Single Post
381. Image Names & Windows
382. Uploading Images
383. Updating Posts
384. Deleting Posts
385. Adding Pagination
386. Adding a User Model
387. Adding User Signup Validation
388. Signing Users Up
389. How Does Authentication Work?
390. ing with User Login
391. Logging In & Creating JSON Web Tokens (JWTs)
392. Using & Validating the Token
393. Adding Auth Middleware to All Routes
394. Connecting Posts & Users
395. Adding Authorization Checks
396. Clearing Post-User Relations
Assignment 7: Time to Practice – Working with REST APIs
397. Wrap Up
398. Useful & Links
Understanding Async Await in Node.js:
399. Module Introduction
400. What is Async Await All About?
g “Then Catch” to “Async Await”
402. Top-level “await”
Assignment 8: Time to Practice – Async Await
403. The User Name is Missing!
404. Wrap Up
405. Useful & Links
Understanding Websockets & Socket.io:
406. Module Introduction
407. What Are Websockets & Why Would You Use Them?
408. Websocket Solutions – An Overview
409. Setting Up Socket.io on the Server
410. Establishing a Connection From the Client
411. Identifying Realtime Potential
412. Sharing the IO Instance Across Files
413. Synchronizing POST Additions
414. Fixing a Bug – The Missing Username
415. Updating Posts On All Connected Clients
416. Sorting Correctly
417. Deleting Posts Across Clients
418. Wrap Up
419. Useful & Links
Working with GraphQL:
420. Module Introduction
421. What is GraphQL?
422. Understanding the Setup & Writing our First Query
423. Defining a Mutation Schema
424. Adding a Mutation Resolver & GraphiQL
425. Adding Input Validation
426. Handling Errors
427. Connecting the Frontend to the GraphQL API
428. Adding a Login Query & a Resolver
429. Adding Login Functionality
430. Adding a Create Post Mutation
431. Extracting User Data From the Auth Token
432. Sending the “Create Post” Query
433. Fixing a Bug & Adding New Posts Correctly
434. Adding a “Get Post” Query & Resolver
435. Sending “Create Post” and “Get Post” Queries
436. Adding Pagination
437. Uploading Images
438. Fetching the imageUrl
439. Viewing a Single Post
440. Updating Posts
441. Deleting Posts
442. Adding Posts & Pagination
443. Managing the User Status
444. Using Variables
445. Fixing a Pagination Bug
446. Wrap Up
447. Useful & Links
Deploying our App:
448. Module Introduction
449. Deploying Different Kinds of Apps
450. Deployment Preparations
451. Using Environment Variables
452. Using Production API Keys
453. Setting Secure Response Headers with Helmet
454. Compressing Assets
455. Setting Up Request Logging
456. More on Logging
457. Setting Up a SSL Server
458. Using a Hosting Provider
459. Understanding the Project & the Git Setup
460. A Deployment Example with Heroku
461. Storing User-generated Files on Heroku
462. Deploying APIs
463. Useful & Links
Testing Node.js Applications:
464. Module Introduction
465. What is Testing?
466. Why & How?
467. Setup and Writing a First Test
468. Testing the Auth Middleware
469. Organizing Multiple Tests
470. What Not To Test!
471. Using Stubs
472. Testing Controllers
473. Testing Asynchronous Code
474. Setting up a Testing Database
475. Testing Code With An Active Database
476. Cleaning Up
477. Hooks
478. Testing Code That Requires Authentication
479. Wrap Up & Mastering Tests
480. Useful & Links
Node.js as a Build Tool & Using npm:
481. Module Introduction
482. npm & Node.js
483. Using npm
484. Versioning in package.json
485. What is a Build Tool?
486. Using Node.js in Build Processes
487. Useful & Links
Modern JavaScript & NodeJS:
488. Module Introduction
489. What is this Module About?
490. Working with ES Modules & Node
491. More on ES Modules
492. Node Core Modules & Promises
493. Module
NodeJS & Type Script:
494. Module Introduction
495. TypeScript: What & Why?
496. TypeScript Setup
497. Assigning Types
498. Type Inference & Type Casting
499. Configuring TypeScript
500. Working with Union Types
501. Using Object & Array Types
502. Working with Type Aliases & Interfaces
503. Understanding Generics
504. A First Summary
505. Node & TypeScript: Setup
506. Getting ed with Node and TypeScript
507. Writing TypeScript Express.js Code
508. Adding REST Routes with TypeScript
509. Finishing the REST Routes
510. Testing the API
511. Using Type Casting
512. Moving to a Better Project Structure
513. Wrap Up
514. Module
An Introduction to Deno:
515. Module Introduction
516. What is Deno?
517. Why Deno?
518. Deno Setup
519. Writing First Deno Code
520. The Deno Runtime (Namespace) API
521. Using the Runtime API
522. Working with Deno Permissions
523. Repeating the Example with Node
524. How Deno Features Are Organized
525. Using the Standard Library
526. Creating a Webserver
527. Using the Oak Framework with Deno
528. More on Module URLs
529. An Example Node REST API
530. Re-building the REST API with Deno
531. Should You Switch From Node to Deno?
532. Module
Deno, CRUD & Databases (MongoDB):
533. Module Introduction
534. App Setup
535. Handling CORS Errors
536. Connecting Deno to MongoDB
537. Using the MongoDB Client Module
538. Finishing the Deno MongoDB CRUD Operations
539. Wrap Up
540. Module
Roundup :
541. Course Roundup
542. Course Slides
543. Bonus: More Content!