English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 142 lectures (14h 32m) | 4.38 GB
Learn Typescript theory in depth, then apply it in practical projects: Node REST API with Express, TypeORM and more
This course covers in-depth the Typescript language and includes several practical projects. It comes with a running Github repo.
This Course in a Nutshell
One of the biggest novelties in the Javascript frontend development space in the last few years is that the use of Typescript has become almost universal.
To the point that it almost does not make sense anymore to start a new project and not use Typescript, given its huge advantages, and almost no downsides.
And this includes projects not only in Node, but also in React, Angular, and any other Javascript-based frontend framework.
Typescript is a strongly typed language that is a superset of Javascript, meaning that Javascript programs are valid Typescript programs (depending on the settings we use for the compiler), but not the other way around.
So in a nutshell, this means that you can see Typescript as a better and improved version of Javascript.
But even though superficially similar, Typescript due to its powerful type system is actually a completely different language than Javascript.
The static type system of Typescript provides many advantages as it allows us to catch many program errors at development instead of at runtime, and it enables powerful development tooling such as precise auto-completion and different types of refactoring.
But to benefit from the power of the type system, we actually don’t have to add type annotations everywhere and end up with code that looks like Java or C#, and sacrifice flexibility, development speed and readability.
The type system can automatically infer the types of most variables automatically, without us having to declare them explicitly, meaning that we can essentially write type-safe Javascript-like code with minimal type annotations.
This powerful type inference is really the killer language feature that makes Typescript the preferred way of starting both a frontend and a backend project today: we get all the benefits of a static type system essentially for free, with no downsides.
Course Overview
This course is divided into multiple sections, that you can take directly depending on your previous level of familiarity with the language. So there are multiple learning paths available for you, depending on your previous experience.
The course will start with a deep dive into all the language features starting with the most basic ones but covering also in detail the most advanced features.
So if you are already familiar with some of the features you can skip ahead, and focus only on the features that you aren’t aware of yet.
We will present the language features from the most elementary ones to the most advanced, and we will cover first the features that are most commonly used.
For completeness, we will also cover a lot of features that are rarely used, but we will point that out explicitly, especially if it’s a feature that you are very unlikely to ever use while coding at the application level.
Besides the language features, we are going to dedicate a full section to the configuration of the Typescript compiler, and go over every option you have available.
We will make it clear when a compiler feature is rarely needed when compared with features that you will be using all the time.
We will still cover everything for completeness, but we want to give you the option to focus only on the most commonly used compiler options if that is what you prefer.
After this initial section covering all language features, we are going to cover also in detail Object-oriented programming, Generics and Decorators, each in their own section.
These 3 sections are mostly independent of the rest of the course and can be taken separately.
After the language sections, we enter the part of the course that covers practical projects.
These practical projects are as close to what you would develop in the real world as possible. This means that these are still small projects that you can comfortably build without spending too much time, but they contain all the building blocks and illustrate all the same design elements that you would have to put in place in a real application.
For example, we are going to build a complete example of a REST API in Node using Typescript and TypeORM, a Typescript-friendly ORM for Node. The server will be designed will all the typical elements of a production system in mind.
For example, the API will be fully secure, and it will require the user to be properly authenticated with a JWT. The API will support multiple levels of access, from a read-only user to an admin user that can edit the data.
Next, once the backend is completed, we are going to build also a couple of frontends with Typescript, namely an Angular frontend, each one in its own separate project.
This way, you will have built your complete system (both frontend and backend) using only one single common language: Typescript.
Table of Contents
This course will go over the following topics:
- Introduction to Typescript
- The Typescript Type System
- The most powerful feature of Typescript: type inference
- In-depth coverage of all the Typescript language features, from the most simple to the most advanced
- In-depth coverage of all the features available in the Typescript compiler
- Object-oriented programming
- Typescript Generics in depth
- Typescript Decorators in depth
- Practical Typescript Project – Secure Node REST API with TypeORM
What Will You Learn In this Course?
In this course, you will learn everything that you need to know to build both the backend and the frontend of your application using the same language: Typescript.
You will know all the features of the language in-depth, and you will be aware of the distinction between the features that you will be using almost every day, from the features that you will only sparingly use.
You will also know in detail the multiple features that you have available in the Typescript compiler.
You will know how to build real-world projects with Typescript, including how to develop your backend with Node and Typescript, and also how to build your frontend in Typescript using modern frameworks.
Table of Contents
Introduction To Typescript
1 Typescript The Ultimate Bootcamp Helicopter View
2 IMPORTANT
3 Setting Up the Development Environment Node Git and IDE
4 Why Typescript Understand the Key Benefits of the Language
5 Compiling Your First Typescript Program
6 The Typescript compiler noEmitOnError flag
7 Running a Typescript Program in a Browser
Deep Dive Into The Typescript Type System
8 Understanding the differences between const let and var
9 Typescript primitive types numbers strings and booleans
10 Typescript Template Strings
11 Understanding Type Inference The most powerful feature of Typescript
12 When to use Typescript Type Annotations and Why
13 Typescript Static Type System vs Javascript Dynamic Type System
14 Typescript Primitive Types Objects
15 Typescript Nested Object Types
16 Understanding the Differences Between Null and Undefined
17 Typescript Optional Chaining How To Avoid NullRelated Errors
18 Understanding The Typescript Null Coalescing Operator
19 Typescript Optional Chaining Best Practices For When To Use It Or Not
20 Typescript Primitive Types Arrays
21 Typescript Enums Our First Custom Type
22 Understanding The Typescript Any Type And Why You Should Avoid It
23 Avoid Implicit Any Types With The noImplicitAny Compiler Flag
24 Understanding Typescript Union Types Nullable Variables
25 Typescript Strict Null Checks and the strictNullChecks Compiler Flag
26 Typescript Non Null Assertion Operator
27 Understanding Typescript Literal Types When Are They Useful
28 Understanding Typescript Type Aliases Our First Custom Type
29 Typescript Interfaces Defining Custom Object Types
30 Typescript Type Aliases vs Interfaces When to Use Which And Why
31 Understanding Typescript Type Assertions
Deep Dive Into Typescript Modules Imports and Exports
32 Introduction To Typescript Modules Exports and Imports
33 Typescript Module ReExports Building an Import Barrel
34 Typescript Modules Default Exports And The Import As Syntax
Typescript Commonly Used Language Features
35 Arrow Functions vs Normal Functions Understanding The This Context
36 Typescript Default Function Parameters
37 The Typescript Object Spread Operator
38 Typescript Object Destructuring
39 Typescript Array Spread and Destructuring Operators
40 Typescript Rest Function Arguments
41 Debugging Typescript In The Browser StepByStep Tutorial
42 Debugging Typescript In Node StepByStep Tutorial
43 Typescript Shorthand Object Creation Notation
Typescript Functions In Depth
44 Introduction to Typescript Functions
45 Typescript Functions At Runtime Function Values
46 Typescript Custom Function Types
Typescript Advanced Language Features
47 Typescript Tuples How To Use Them
48 Understanding The Typescript Unknown Type
49 Understanding Typescript Type Narrowing and Type Predicates
50 Understanding Typescript Never Type
51 Typescript Intersection Types
Typescript Compiler Option In Depth tsconfigjson
52 Introduction to tsconfigjson The target Property
53 Using a Custom Name for the Compiler Configuration File
54 Controlling What Files To Compile The files tsconfigjson property
55 Controlling What Files To Compile include and exclude
56 The tsconfigjson outdir and rootDir properties
57 The tsconfigjson module property
58 Choosing What Libraries To Include Wth tsconfigjson lib and nolib properties
59 Typescript Compiler baseUrl Option
60 Understanding typeRoots types and the skipLibCheck Compiler Options
61 Including Plain Javascript in a Typescript project allowJs and checkJs
62 Typescript Compiler Miscellaneous Options
Object Oriented Programming in Typescript
63 Introduction To Typescript Classes
64 Writing Our First Typescript Class The Constructor
65 Typescript Classes Member Variables
66 Typescript ReadOnly Class Member Variables
67 Typescript Getters and Setters
68 Does Typescript Support Multiple Constructors
69 Understanding The This Keyword When Used In a Class
70 Understanding Typescript Static Variables
71 Understanding Typescript Static Class Methods
72 Introduction To Object Oriented Inheritance
73 The Extends Keyword Creating a Child Class
74 Understanding the Protected Keyword
75 Typescript Abstract Classes
76 ObjectedOriented Interfaces
77 The Singleton In Typescript An ObjectOriented Design Pattern
Typescript Generics In Depth
78 New Section Introduction To Typescript Generics
79 Commonly Used Generic Libraries
80 The Typescript Optional Interface
81 The Typescript Read Only Interface
82 Introduction To Generic Functions
83 Generic Functions With Multiple Generic Parameters
84 Typescript Generics Type Constraints and the extends Keyword
85 Typescript Generics Understanding the keyof Operator
86 Typescript Generic Classes
Typescript Decorators In Depth
87 Introduction To Typescript Decorators How Do They Work
88 Introduction To Typescript Method Decorators
89 Understanding The MethodDecorator Function Signature
90 Typescript Method Decorators StepByStep Implementation
91 Applying Multiple Typescript Decorators To The Same Method
92 Typescript Class Decorators
93 Typescript Property Decorators
Typescript Practical Project Building a Node REST API with TypeORM and Express
94 New Section Building a Secure Node REST API From Scratch In Typescript
95 Kickstarting Our Node Project With npm init
96 Setting Up An Express Server From Scratch
97 Writing Our First Express Endpoint
98 How To Add HotReload To Our Typescript Development Environment
99 Parsing Command Line Arguments in a Node Program
100 Adding Support For Multiple Environments Using dotenv
101 Making The Server Port Number Configurable
102 Setting Up The Winston Logging Library
103 Setting a Cloud SQL Database With Heroku and Postgres
104 Introduction To TypeORM
105 Setting Up a Database Connection With TypeORM
106 Setting Up Our First TypeORM Model
107 Modelling a One To Many Relationship in TypeORM
108 Generating a Database Schema Using TypeORM
109 Trying Out TypeORM Populating The Database
110 Populating a Database With TypeORM Repositories
111 Writing a Database Cleanup Script With TypeORM
112 Implementing a Data Retrieval Express Endpoint Using TypeORM
113 Eager Fetching a One To Many Relationship Using TypeORM
114 Error Handling In Asynchronous Express Endpoints
115 Overridding the Express Default Error Handling Behavior
116 Adding CORS Capabilities To An Express Server
117 Filtering Query Results In TypeORM Part 1
118 Filtering Query Results In TypeORM Part 2
119 Implementing The Find Course Lessons Endpoint
120 Performing a SQL Join With TypeORM
121 Setting Up an Express JSON Body Parser
122 Implementing an Express PATCH Update Endpoint
123 Controlling The Transaction Isolation Level With TypeORM
124 Implementing a POST Create Entity Endpoint
125 Implementing an Express DELETE Endpoint
Securing a Node REST API With Typescript
126 New Section Introduction Securing a Node REST API With Typescript
127 Setting Up The TypeORM Users Entity
128 Populating the USERS Table With User Credentials
129 Creating Password Digests Using the Node Crypto Module
130 Hashing a Password To Store It In The Database
131 Implementation of a Create User POST Endpoint
132 Implementing a Login Endpoint Initial Skeleton
133 Login Endpoint Validating The User Password
134 Understanding JWTs JSON Web Tokens
135 Setting Up The jsonwebtoken Node Library
136 Creating And Signing An Authentication JWT
137 Designing an Express Authentication Middleware
138 StepByStep Implementation of an Authentication Middleware
139 Role Based Authorization Using an Express Middleware
Conclusion
140 Other Courses
141 Bonus Lecture
142 Conclusions and Key Takeaways
Resolve the captcha to access the links!