Production TypeScript

Narrowing, Generics, Advanced Type Programming & Tooling

7 modules, 35 lessons: The Compiler And Mental Model; Primitives, Literals And Top/Bottom Types; Object Shapes, Interfaces And Types; Type Narrowing And Control Flow; Generics And Parameterized Types; Advanced Type Programming And Utilities; Modules, Tooling And The OpenAPI Spine.

Intermediate · 2 hours · 35 lessons · 40 labs

Who it is for

Intermediate level.

For JavaScript developers who want to write TypeScript that catches mistakes before they reach users, on the frontend or the backend.

What you don't need yet:

What helps:

Before you start:

Take next:

Learning paths:

Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.

Labs

40 labs, 33 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.

What is free

Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.

Course outline

The Compiler And Mental Model

  1. Why TypeScript: Contracts, Erased Types And Soundness (2 labs): You can explain how TypeScript acts as a compile-time static type system, why types vanish at runtime through erasure, and how structural typing differs from nominal typing.
  2. The Compiler Pipeline: tsc, AST And Code Emission (2 labs): You can describe the four phases of the TypeScript compiler pipeline from source text to AST to type checking and emission, and configure noEmitOnError.
  3. tsconfig.json: target, lib, strict And NodeNext (1 lab): You can author a production tsconfig.json configured with strict mode, modern module resolution, and correct library declarations.
  4. Type Annotations, Type Inference And Contextual Typing (2 labs): You can distinguish between explicit type annotations and type inference, leverage contextual typing in higher-order functions, and avoid redundant type annotations.
  5. Verify Your Environment: Running tsc And Bun TypeScript (1 lab): You can verify your TypeScript compiler installation, run TypeScript files directly with Bun or Node, and validate your development environment.

Primitives, Literals And Top/Bottom Types

  1. Primitive Types: String, Number, Boolean, Bigint And Symbol (1 lab): You can declare and manipulate primitive types in TypeScript and avoid the wrapper object anti-pattern.
  2. Literal Types: String, Number, Boolean Literals And const (2 labs): You can employ literal types to represent exact domain values like HTTP methods and status codes, and use const assertions to prevent type widening in configuration dictionaries.
  3. any Versus unknown: Defensive Typing In Practice (1 lab): You can distinguish between any and unknown, eliminate any-leakage from your applications, and safely parse untrusted external data using unknown with runtime type narrowing.
  4. void, undefined And null: Exact Optional Property Types (1 lab): You can correctly differentiate between void, undefined, and null in API schemas, and leverage exactOptionalPropertyTypes to separate omitted keys from explicit undefined values.
  5. never: The Bottom Type And Exhaustive Switch Checking (2 labs): You can describe the mathematical role of never as the bottom type, implement the assertNever pattern for exhaustive switch statements, and catch unhandled union variants at compile time.

Object Shapes, Interfaces And Types

  1. Type Aliases Versus Interfaces: Declaration Merging (1 lab): You can evaluate the architectural tradeoffs between interfaces and type aliases, and employ declaration merging to extend third-party application contracts.
  2. Optional Properties, Readonly And Index Signatures (1 lab): You can protect entity state with readonly modifiers, model dynamic dictionaries using index signatures, and handle dictionary lookups safely.
  3. Union Types, Intersections And Property Conflicts (1 lab): You can compose complex data models using union and intersection types, avoid property conflicts that collapse to never, and access common properties safely.
  4. Discriminated Unions: Tagged Variants And Pattern Matching (1 lab): You can design discriminated unions to make illegal states unrepresentable in frontend and backend workflows, and pattern match cleanly on discriminant tags.
  5. Tuples: Fixed Length, Labeled Elements And Variadic Tuples (1 lab): You can declare fixed-length positional data with tuples, document intent using labeled tuple elements, and manipulate dynamic argument lists with variadic tuples.

Type Narrowing And Control Flow

  1. Typeof Guards, Truthiness And Equality Narrowing (1 lab): You can leverage control flow analysis to narrow union types using typeof type guards, truthiness checks, and literal equality comparisons.
  2. The in Operator And Instanceof Narrowing (1 lab): You can narrow heterogeneous object shapes using the in operator and distinguish class hierarchies at runtime using instanceof.
  3. Custom Type Predicates: Functions Returning is Type (1 lab): You can author custom type predicate functions returning parameter is Type to encapsulate validation logic and narrow arrays without unsafe type assertions.
  4. Assertion Signatures: asserts condition And Invariants (1 lab): You can implement assertion functions using asserts condition syntax to validate runtime invariants and narrow scopes without introducing nested conditional branches.
  5. Exhaustive Narrowing With never In Production Handlers (1 lab): You can synthesize all narrowing techniques to build bulletproof domain event dispatchers with guaranteed compile-time exhaustiveness.

Generics And Parameterized Types

  1. Why Generics: Functions, Identities And Type Variables (1 lab): You can author generic functions and parameterized types that capture and propagate concrete types while eliminating type duplication.
  2. Generic Interfaces, Classes And Type Aliases (1 lab): You can design generic interfaces, type aliases, and classes to build reusable data access repositories and stateful containers.
  3. Generic Constraints: extends, keyof And Indexed Access (1 lab): You can apply generic constraints and indexed access types to build type-safe property accessors and record transformations.
  4. Default Generic Arguments And Multi-Type Parameters (1 lab): You can design multi-parameter generics with sensible defaults to build flexible API client wrappers and response envelopes.
  5. Const Type Parameters: Retaining Literal Types In Functions (1 lab): You can apply const type parameters to preserve exact literal types and readonly tuple structures without requiring caller-side const assertions.

Advanced Type Programming And Utilities

  1. Core Utilities: Partial, Required, Readonly, Pick And Omit (1 lab): You can transform domain models into specialized creation, patch, and read DTOs using Partial, Required, Readonly, Pick, and Omit.
  2. Union Utilities: Exclude, Extract, NonNullable And Awaited (1 lab): You can manipulate union types and unpack promise resolutions using Exclude, Extract, NonNullable, and Awaited.
  3. Function Utilities: ReturnType, Parameters And Constructor (1 lab): You can extract function parameters and return types to author type-safe middleware interceptors and metrics wrappers.
  4. Conditional Types: Ternary Types And Type Inference With infer (1 lab): You can write conditional types with infer to extract embedded type variables and perform branch logic in the type system.
  5. Mapped Types, Key Remapping With as And Template Literals (1 lab): You can combine mapped types, key remapping with as, and template literal types to generate strongly typed event listeners and accessors.

Modules, Tooling And The OpenAPI Spine

  1. ECMAScript Modules, CJS Interop And verbatimModuleSyntax (1 lab): You can configure ECMAScript modules, apply type-only imports, and enforce verbatimModuleSyntax for predictable code emission.
  2. Declaration Files, Ambient Namespaces And Module Augmentation (1 lab): You can author declaration files, ambient namespaces, and module augmentations to extend third-party types and global scopes.
  3. The satisfies Operator: Safe Validation Without Widening (1 lab): You can apply the satisfies operator to validate complex configuration objects against contracts without widening property types.
  4. Modern Decorators: Stage 3 Standards And Class Metadata (1 lab): You can write standard Stage 3 method and class decorators using ClassMethodDecoratorContext to intercept execution and manage metadata.
  5. The Spine Artifact: Generating Typed Models From OpenAPI (1 lab): You can derive and consume strongly typed models and API client SDKs from OpenAPI specifications to anchor full-stack applications.