Node.js Course Built for AI-Paired Learning

This chapter focuses on What Node.js is and where it is used, The V8 engine and libuv, Node.js release lines and LTS and the practice needed to use these concepts confidently in real projects.

• What Node.js is and where it is used
• The V8 engine and libuv
• Node.js release lines and LTS
• Installing and managing versions
• The REPL and running scripts
• The process object
• Command line arguments
• Environment variables
• Exit codes and graceful shutdown
• Signals and process events
• The global object in Node
• Differences from the browser environment
• Node built-in modules overview
• The node: prefix for built-ins
• Reading the official documentation
• The event loop phases
• The call stack and the thread pool
• Blocking against non-blocking operations
• setImmediate against setTimeout
• process.nextTick and microtasks
• Measuring event loop lag
• Debugging with the inspector

This chapter focuses on The CommonJS module system, require, module.exports and exports, Module caching and singletons and the practice needed to use these concepts confidently in real projects.

• The CommonJS module system
• require, module.exports and exports
• Module caching and singletons
• ES modules in Node.js
• The type field in package.json
• File extensions and dual packages
• Interop between CommonJS and ESM
• Top-level await in modules
• Dynamic import
• Module resolution algorithm
• Subpath imports and exports maps
• npm basics and the registry
• package.json fields that matter
• Semantic versioning ranges
• Lock files and reproducible installs
• Dependencies against devDependencies
• Peer and optional dependencies
• npm scripts and lifecycle hooks
• npx and one-off tools
• Workspaces and monorepos
• Auditing and updating dependencies
• Publishing a package

This chapter focuses on The error-first callback convention, Converting callbacks to promises, util.promisify and the practice needed to use these concepts confidently in real projects.

• The error-first callback convention
• Converting callbacks to promises
• util.promisify
• The promises variants of core modules
• async/await in Node code
• Sequential against parallel execution
• Promise.all and partial failure
• Concurrency limits and pooling
• AbortController and AbortSignal
• Timeouts on async operations
• Retry with exponential backoff
• The EventEmitter class
• Emitting and listening to events
• once and removing listeners
• Error events and crashes
• Max listeners warnings
• Async iterators over events
• AsyncLocalStorage for request context
• Unhandled rejections
• Uncaught exception handling
• Graceful degradation on failure
• Structuring async service code

This chapter focuses on The fs module and its three APIs, Reading files synchronously and asynchronously, Writing and appending files and the practice needed to use these concepts confidently in real projects.

• The fs module and its three APIs
• Reading files synchronously and asynchronously
• Writing and appending files
• File descriptors and handles
• Copying, renaming and deleting
• Creating and reading directories
• Recursive directory operations
• Watching files for changes
• File metadata with stat
• Permissions and access checks
• Temporary files and directories
• The path module
• Joining and resolving paths
• Cross-platform path handling
• The URL module and file URLs
• Buffers and binary data
• Encoding and decoding text
• TextEncoder and TextDecoder
• Working with JSON files safely
• CSV parsing basics
• Handling large files without loading them
• Atomic writes and data safety

This chapter focuses on Why streams exist, Readable streams, Writable streams and the practice needed to use these concepts confidently in real projects.

• Why streams exist
• Readable streams
• Writable streams
• Duplex and Transform streams
• Flowing and paused modes
• The data, end and error events
• pipe and its error handling gaps
• stream.pipeline and cleanup
• Backpressure explained
• Highwater marks and buffering
• Creating a custom readable stream
• Creating a custom transform stream
• Object mode streams
• Async iteration over streams
• Web Streams in Node
• Converting between stream types
• Compressing with zlib
• Hashing with crypto streams
• Streaming file uploads
• Streaming HTTP responses
• Processing large datasets line by line
• Measuring throughput and memory

This chapter focuses on The HTTP protocol refresher, Creating a server with the http module, The request and response objects and the practice needed to use these concepts confidently in real projects.

• The HTTP protocol refresher
• Creating a server with the http module
• The request and response objects
• Reading request bodies
• Parsing query strings
• Setting status codes and headers
• Content types and negotiation
• Serving static files
• Manual routing
• Cookies and their attributes
• Sessions and state
• HTTPS and TLS basics
• HTTP/2 support
• Keep-alive and connection reuse
• Making outbound requests with fetch
• Timeouts and retries on outbound calls
• Proxies and forwarded headers
• Compression middleware
• CORS explained
• WebSockets and real-time messaging
• Server-sent events
• Load balancing and sticky sessions

This chapter focuses on Choosing SQL or NoSQL, Connecting to PostgreSQL from Node, Connecting to MySQL from Node and the practice needed to use these concepts confidently in real projects.

• Choosing SQL or NoSQL
• Connecting to PostgreSQL from Node
• Connecting to MySQL from Node
• Connecting to MongoDB from Node
• Connection pooling
• Query builders and ORMs
• Prisma overview
• TypeORM and Sequelize overview
• Modelling entities and relations
• Migrations and versioning the schema
• Seeding development data
• Transactions and rollbacks
• Isolation levels in practice
• Preventing SQL injection
• Pagination strategies
• Indexing for query performance
• Caching with Redis
• Cache invalidation patterns
• Repository and data access layers
• Testing against a real database
• Handling database failures
• Backup and recovery awareness

This chapter focuses on The OWASP top risks for APIs, Input validation at the boundary, Output encoding and injection and the practice needed to use these concepts confidently in real projects.

• The OWASP top risks for APIs
• Input validation at the boundary
• Output encoding and injection
• Password hashing with bcrypt or argon2
• Salting and work factors
• JWT structure and signing
• Access and refresh token flows
• Session-based authentication
• Secure cookie flags
• Role and permission checks
• Rate limiting and throttling
• Brute force protection
• Helmet and security headers
• CSRF protection strategies
• File upload security
• Path traversal prevention
• Secrets management
• Dependency vulnerability scanning
• Logging without leaking data
• Encryption with the crypto module
• Random values and token generation
• A security checklist before release

This chapter focuses on Profiling CPU usage, Heap snapshots and memory leaks, Common leak sources in Node and the practice needed to use these concepts confidently in real projects.

• Profiling CPU usage
• Heap snapshots and memory leaks
• Common leak sources in Node
• Garbage collection behaviour
• Reducing synchronous work
• Worker threads for CPU-bound tasks
• Sharing data with worker threads
• Child processes and spawning
• The cluster module
• Process managers and restarts
• Horizontal scaling considerations
• Statelessness and shared session stores
• Queues and background jobs
• Scheduling recurring work
• Caching layers and their placement
• Connection limits and tuning
• Benchmarking endpoints
• Load testing methodology
• Interpreting latency percentiles
• Timeouts and circuit breakers
• Graceful shutdown under load
• Capacity planning basics

This chapter focuses on The built-in test runner, Unit testing services, Integration testing endpoints and the practice needed to use these concepts confidently in real projects.

• The built-in test runner
• Unit testing services
• Integration testing endpoints
• Test databases and fixtures
• Mocking external services
• Contract testing overview
• Coverage reporting
• Structured logging
• Correlation ids across requests
• Log levels and noise control
• Metrics and health endpoints
• Distributed tracing basics
• Error tracking services
• Configuration management
• Twelve-factor principles
• Dockerising a Node service
• Multi-stage builds and image size
• Running in a container safely
• CI pipelines for Node projects
• Blue-green and rolling deploys
• Project: building the complete service
• Project: deployment, monitoring and review