Pro Kotlin Web Apps from Scratch: Building Production-Ready Web Apps Without a Framework

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Setting Up a Development Environment
    Get Started with IntelliJ IDEA Community Edition
        Download and Run IntelliJ IDEA
        Create a New Kotlin Project with IntelliJ IDEA
    Kotlin Hello, World!
        Kotlin Naming Conventions
        Write Some Code
        Run Your Code with IntelliJ IDEA
        Run Your Code with Gradle
    IntelliJ IDEA Tips and Tricks
        Look Out for the Progress Bar
        Remember to Refresh the Gradle Project in IntelliJ IDEA
        Embrace Auto-completion in IntelliJ IDEA
Chapter 2: Setting Up the Web App Skeleton
    Web Server Hello, World!
        Choosing Ktor
        Add the Ktor Library
        Start a Web Server
        Extracting to a Separate Function
        Using Lambdas
        Named Arguments Instead of Magic Numbers and Booleans
        Run Your Web App
    Logging
        Loggers on the Java Platform
        Configure Logging in Your Web App
        Write to the Log from Your Own Code
        A Note on “Magic” XML Config Files
    Useful Error Pages
Chapter 3: Configuration Files
    Create a Configuration File
        The Configuration File Anatomy
        Reading Values from Your Configuration File
    Make the Configuration Fail Early and Type-Safe
        Store Configuration in a Data Class
        Load Config into the Data Class
        Kotlin Null Safety
        Kotlin Platform Types
        Use the Data Class in Your Web App
        Use let Blocks to Avoid Intermediate Variables
    Provide Different Default Values for Different Environments
        Environment-Specific Config Files
        Define the Web App Environment
        Override Defaults with Environment-Specific Config
    Secret Config Values
        Don’t Store Secrets in Version Control
    Logging Config on Web App Startup
        Format the Output
        Masking Secrets
        Writing to the Log
Chapter 4: Decoupling Web Handlers from Specific Libraries
    Your Own HTTP Response Abstraction
        Representing HTTP Responses
        Multiple Response Types
        Convenience Functions for Headers
        Case-Insensitive Headers
        The fold Function
        Destructuring Assignment
    Connecting to Ktor
        Ktor Route Mapping
        Extension Functions
        Functions Returning Functions
        Map Headers
        Map TextWebResponse and Status Code
        Map JsonWebResponse
        Using the New Mapping
    A Note on Overengineering
Chapter 5: Connecting to and Migrating SQL Databases
    Connecting to a SQL Database
        The Connection Pool
        Installing the Database Driver
        Setting Up H2
        Updating WebappConfig
        Set Up the Connection Pool
        Creating a Connection
    The Initial Schema
        Installing Flyway
        Running Flyway During Startup
        Creating the Initial Schema
    Managing Schema Changes
        Don’t Edit Migrations After Run
        Adding More Schema
        Adding Non-nullable Columns
        Backward-Compatible Migrations
    Insert Seed Data
        Repeatable Migrations
        Updating Repeatable Migrations
    Handling Failed Migrations
        Failed Migrations Locally
        Failed Migrations in Production
        Rerunning Failed Migration
        Manually Performing Migration
Chapter 6: Querying a SQL Database
    Setting Up Querying
        Use SQL Directly
        Installing Kotliquery
        Mapping Query Results
    Execute SQL Queries
        Creating a Session
        Querying for Single Rows
        Querying for Multiple Rows
        Inserting Rows
        Updating and Deleting
        Positional vs. Named Parameters
        Additional Operations
    Querying from Web Handlers
        Creating a Helper Function
        A Note on Architecture
        Avoid Long-Running Connections
    Maps vs. Data Classes
        Passing Around Maps
        Passing Individual Properties
        Mapping to a Data Class
    Database Transactions
        Creating Transactions
        Transactions in Web Handlers
        Type-Safe Transactional Business Logic
        Nested Transactions
Chapter 7: Automated Tests with jUnit 5
    Setting Up Your Environment
        Adding jUnit 5 and kotlin.test
        Writing a Failing Test
        Running a Failing Test
        Making the Test Pass
    Writing Web App Tests
        Setting Up the Basics
        Writing a Failing Test
        Making the Test Pass
    Avoiding Leaky Tests
        Leaky Tests
        Avoiding Leaks with Transactions
        Avoiding Leaks with Relative Asserts
    Test-Driven Development
        Design and Verification
        Writing a Failing Test
        Making the Test Pass
    Notes on Methodology
        What About Front-End Tests?
        Real Database Writes vs. Mocks
        Unit vs. Integration Tests
Chapter 8: Parallelizing Service Calls with Coroutines
    Preparing Your Web App
        Implementing a Fake Service
        Adding a Second Server
    Understanding Coroutines
        The delay Coroutine
        The Problem with Threads
        Suspending Instead of Locking
        Coroutine Contexts
        Coroutines in Ktor
    Parallelizing Service Calls
        Adding Dependencies
        Performing Parallelized Calls
        Handling Race Conditions
        Adding to Ktor
    Mixing Coroutines and Blocking Calls
        Wrapping Blocking Calls
    Coroutine Internals
        Kotlin vs. KotlinX
        Comparing with Arrow
        Using Low-Level Continuations
        Java Platform Implementation Details
Chapter 9: Building Traditional Web Apps with HTML and CSS
    Patterns and Organization
    Generating HTML
        Using the kotlinx.html DSL
        Using the Ktor HTML DSL
        The Power of the DSL
        Operator Overloading
        Adding Custom Tags
    CSS and Assets
        Serving Static Files
        Instant Reloading
    Reusable Layouts
        Adding a Layout
        Using the Layout
    Adding WebResponse for HTML
        Implementing HtmlWebResponse
        Extension Function Precedence
        Responding with HtmlWebResponse
        A Note on Abstractions
    User Security
        Password Hashing
        Using Bcrypt for Hashing
        Updating Your Migrations
    Adding a Login Form
        Wiring Up Your Web App
        Different Types of Sessions
        Adding a New Ktor Extension Function
        Configuring Session Cookies
        Logging In
        Protecting Routes with Authentication
        Logging Out
Chapter 10: Building API-Based Back Ends
    Handling API Calls
        Parsing Input
        Validating and Extracting Input
        Avoid Automatic Serialization
        Internal vs. External APIs
    Single-Page Apps
        Hosting Alongside API
        Hosting Separately with CORS
        Authenticating Users
    Native Apps
        Using Cookies for Authentication
        Using JWTs for Authentication
        Performing Authentication
Chapter 11: Deploying to Traditional Server Based Environments
    Packaging as Self-Contained JAR Files
        What’s a JAR File
        Self-Contained JAR Files
        Packaging with Gradle
        Building the JAR File
        Executing the JAR File
    Packaging for Production
        Building Docker Images
        Running Docker Images Locally
        Deploying to Production
Chapter 12: Building and Deploying to Serverless Environments
    Detaching Your Code
        Separating Handlers from Ktor
        Basic Structure
        Detached Web Handlers
    Run Web Handlers on AWS Lambda
        Making AWS Lambda Web Handlers
        Deploying to AWS Lambda
        Calling Your Existing Handlers
    Improving Performance
        Performance and Cold Starts
        Initialization Time vs. Execution Time
        Lazy Loading
        Initializing Correctly
        Migrations and H2
        Java Runtime Flags
        GraalVM, Kotlin/JS, and Kotlin Native
Chapter 13: Setup, Teardown, and Dependency Injection with Spring Context
    Why Spring and Dependency Injection?
    Setting Up Spring Context
    Adding Your Data Source
    lateinit in Kotlin
    Starting Your Web App
    Extended Usage
Chapter 14: Enterprise Authentication Using Spring Security
    Preparing Your Web App
        Setting Up Embedded Jetty
        Initializing the Servlet
        Adding Ktor to Your Servlet
    Using Spring Security
        Setting Up the Servlet Filter
        Configuring Spring Security
        Authenticating Users
        Filtering Requests
        Accessing the Logged-In User
Chapter 15: Choosing the Right Library
    What’s a Library?
    Popularity Is Largely Irrelevant
    Documentation and Stability Are Important
    Avoid Following the “X Way”
    Don’t Shy Away from Platform Libraries
    Boundaries and Layers
Chapter 16: An Assortment of Kotlin Tricks
    Delegation (by lazy)
    Inline Functions
    Reified Generics
    Contracts
    And So Much More
Appendix A: Using Jooby Instead of Ktor
    Starting a Server
    Mapping WebResponse
    Serving Assets
    Responding to Requests
    Authenticating with Forms
    Authenticating with JWTs
    Appendix B Using Hoplite Instead of Typesafe Config
    Loading Config Files
    Handling JVM Target Version Errors
    Handling Unknown Environment Variables
    Masking Secrets
    Appendix C Using Spek Instead of jUnit 5
    Writing Spek Tests
    Structuring Spek Tests
    Skipping Tests
    Running Individual Tests
Index