Valentino Gagliardi

Decoupled Django

Understand and Build Decoupled Django Architectures for JavaScript Front-ends

1st ed.
Valentino Gagliardi
Colle di Val D’Elsa, Italy
ISBN 978-1-4842-7143-8e-ISBN 978-1-4842-7144-5
https://doi.org/10.1007/978-1-4842-7144-5
© Valentino Gagliardi 2021
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed.
The use of general descriptive names, registered names, trademarks, service marks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.
The publisher, the authors and the editors are safe to assume that the advice and information in this book are believed to be true and accurate at the date of publication. Neither the publisher nor the authors or the editors give a warranty, expressed or implied, with respect to the material contained herein or for any errors or omissions that may have been made. The publisher remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

This Apress imprint is published by the registered company APress Media, LLC part of Springer Nature.

The registered company address is: 1 New York Plaza, New York, NY 10004, U.S.A.

To my grandfather, Valentino. I will always miss you.

Introduction

If you’re reading this, I’m glad! It means you are interested in Django, one of the most powerful and flexible web frameworks out there.

When I discovered Django years ago, I realized I could make perfectly working prototypes faster than with any other web framework; prototypes that later would become robust, rock-solid web applications.

These days, with JavaScript all the rage, the temptation to jump on the JavaScript-full-stack bandwagon is strong, and sometimes this tendency makes beginners think that everything must be built with JavaScript. It shouldn’t. Even if I work primarily with JavaScript, Django is still my safe harbor for building stuff quickly.

At the same time, used with cognition, modern frontend libraries like Vue.js and React pair well with Django, which can work completely decoupled from the frontend. This book is an attempt to cover a part of the vast spectrum of decoupled architectures with Django and JavaScript, with an eye on the last developments in the asynchronous Django land, and on the integration between Django and GraphQL. Here’s a breakdown of what you can expect from each chapter.

  • In Chapters 1, 2, and 3, we introduce the terminology, what makes a decoupled architecture, how modern JavaScript is supposed to work in Django, and how the Django REST framework can help you build REST APIs.

  • In Chapter 4, we discuss the advantages and drawbacks of a decoupled architecture.

  • In Chapters 5 and 6, we begin to build a Django project with the Django REST framework and Vue.js to show how Vue can work from within Django templates.

  • In Chapter 7, we discuss security for REST APIs, and deployment of our Django/Vue.js project.

  • In Chapter 8, we move to React and Next.js to show how such a framework can be paired with Django. We cover Next.js basics and data fetching.

  • Chapter 9 covers testing, both for the REST API and for the JavaScript frontend.

  • Chapter 10 covers authentication for decoupled setups and shows you how to use session-based authentication for single-page apps with the help of NGINX.

  • Finally, in Chapters 11 and 12, we cover GraphQL in Django, with a look at running Django asynchronously.

All the system commands presented in this book assume that the reader is using a Linux or MacOS system. As for the prerequisites, a basic knowledge of TypeScript and modern frontend libraries is expected.

Have fun!

Acknowledgments

This book is the product of my love for Django and its community.

I’d also like to express my gratitude to the Italian Python community in particular, one of the most welcoming out there!

Table of Contents
Chapter 1:​ Introduction to the Decoupled World 1
Monoliths and MVC 1
What Makes a Decoupled Architecture?​ 2
Why and When to Decouple?​ 3
Hypermedia All the Things 5
Hypermedia as the Engine 7
Client-Server Separation 8
Stateless 8
Cacheable 8
Uniform Interface 10
An Introduction to GraphQL 11
Summary 15
Additional Resources 15
Chapter 2:​ JavaScript Meets Django 17
JavaScript and Django in Production 17
The Need for Module Bundlers 19
Webpack Fights Django (the Need for Code Splitting) 20
Modern JavaScript, Babel, and Webpack 22
A Word on TypeScript 23
JavaScript Frontend Libraries and Frameworks 24
Lightweight JavaScript UI Libraries 25
Universal JavaScript Applications 26
Static Site Generators 27
Testing Tooling 27
Other Ancillary JavaScript Tools 28
Summary 29
Additional Resources 29
Chapter 3:​ Modern Django and the Django REST Framework 31
What Is the Django REST Framework?​ 31
Class-Based Views in Django and the DRF 32
CRUD Viewsets in DRF 33
Models, Forms, and Serializers 34
From WSGI to ASGI 36
Getting Started with Asynchronous Django 37
Competing Asynchronous Frameworks and the DRF 39
Summary 40
Additional Resource 40
Chapter 4:​ Advantages and Disadvantages of Decoupled Architectures 41
Pseudo-Decoupled Django 41
Pseudo-Decoupled Without REST 41
Pseudo-Decoupled with REST 45
Fully-Decoupled Django 47
Fully-Decoupled with REST 48
Fully-Decoupled with GraphQL 50
Summary 51
Chapter 5:​ Setting Up a Django Project 53
Setting Up the Project 53
A Custom User 55
Interlude:​ Choosing the Right Database 56
Splitting the Settings File 56
Bonus:​ Running Django Under ASGI 59
Splitting the Requirements File 60
Summary 61
Chapter 6:​ Decoupled Django with the Django REST Framework 63
Building the Billing App 63
Building the Models 64
Enabling the App 66
Wireframing the Billing App 66
Pseudo-Decoupled with the Django REST Framework 68
Vue.​js and Django 68
Building the Vue App 73
Vue.​js, Django, and CSS 79
Building the REST Backend 80
Building the Serializers 81
Building the Views and the URL 82
Working with Nested Serializers 86
Fixing the Vue Frontend 87
Summary 89
Additional Resource 89
Chapter 7:​ API Security and Deployment 91
Django Hardening 91
Django Settings for Production 92
Authentication and Cookies in Django 94
Randomize the Admin URL 97
REST API Hardening 98
HTTPS Encryption and HSTS 98
Audit Logging 98
Cross-Origin Resource Sharing 99
Authentication and Authorization in the DRF 101
Disable the Browsable API 103
Deploying a Decoupled Django Project 104
Preparing the Target Machine 104
Configuring NGINX 105
Gunicorn and Django Production Requirements 106
Preparing Vue.​js in Production with Django 107
The Deployment 108
Summary 111
Additional Resource 111
Chapter 8:​ Django REST Meets Next.​js 113
Django as a Headless CMS 113
Building the Blog App 113
Building the Model 114
Enabling the App 115
Building the REST Backend 116
Building the Serializer 116
Building the Views and the URL 117
Introduction to the React Ecosystem 118
A Reintroduction to React 119
Introduction to Next.​js 120
Building the Next.​js Frontend 121
Pages and Routing 122
Data Fetching 125
Static Site Generation 128
Deploying Next.​js 131
Using React with Django 131
The Vue.​js Ecosystem 132
Summary 132
Additional Resource 132
Chapter 9:​ Testing in a Decoupled World 133
Introduction to Functional Testing 133
Getting Started with Cypress 134
Understanding Functional Testing for the Billing App 135
Creating the First Test 136
Filling and Submitting the Form 141
Introduction to Unit Testing 145
Unit Testing in the Django REST Framework 145
Django Settings for Testing 146
Installing the Dependencies and Configuring Requirements for Testing 147
Outlining Tests for the Billing REST API 147
Testing the Billing REST API 148
Summary 152
Additional Resource 152
Chapter 10:​ Authentication and Authorization in the Django REST Framework 153
Introduction to Token-Based Authentication and JWT 154
Token-Based Authentication:​ The Good and the Bad 154
JSON Web Tokens in Django:​ Advantages and Challenges 155
Session-Based Auth for Single-Page Apps 156
Some Words on Production and Development 157
Preparing NGINX for the New Setup 158
Handling the Login Flow with Django 159
Preparing the Vue.​js App for the New Setup 163
A Note About HttpOnly Cookies 165
Handling Authentication in the Frontend 166
Authorization and Permissions in the Django REST Framework 169
Summary 171
Additional Resource 171
Chapter 11:​ GraphQL in Django with Ariadne 173
Getting Started with Ariadne in Django 173
Installing Ariadne 174
Designing the GraphQL Schema 174
Loading the Schema in Ariadne 177
Wiring Up the GraphQL Endpoint 178
Working with Resolvers 182
Using Query Arguments in GraphQL 184
A Word on Schema-First vs Code-First 187
Implementing Mutations 187
Adding a Resolver for the Mutation 190
Introduction to GraphQL Clients 193
Building the React Frontend 194
Getting Started with Apollo Client 195
Creating a Select Component 196
Creating a Form Component 197
Creating the Root Component and Making Queries 197
Using Apollo Hooks for React 202
Summary 205
Additional Resources 205
Chapter 12:​ GraphQL in Django with Strawberry 207
Getting Started with Strawberry in Django 207
Installing Strawberry 208
Designing the GraphQL Schema in Strawberry 209
Types and Enums in Strawberry 210
Working with Resolvers (Again) 213
Queries in Strawberry and Wiring Up the GraphQL Endpoint 214
Input Types and Mutations in Strawberry 216
Working Asynchronously with the Django ORM 218
Working Again on the Frontend 220
Creating Invoices with a Mutation 220
What’s Next?​ 229
Summary 230
Additional Resources 230
Index 231
About the Author
Valentino Gagliardi
../images/505838_1_En_BookFrontmatter_Figb_HTML.jpg

is a freelance consultant with many years of experience in the IT industry. He spent the last several years as a frontend consultant, providing advice and help, coaching, and training on JavaScript and React. He worked as an instructor for many training agencies around the country, running in-person workshops and creating learning paths for aspiring developers. Author of The Little JavaScript Book, he loves to share his knowledge on his blog, with his tutorials reaching over 100k monthly visits. An avid Django user, he is active in the Python community as a speaker and as a coach for Django Girls.

 
About the Technical Reviewer
Marcin Gębala
../images/505838_1_En_BookFrontmatter_Figc_HTML.jpg

is a software engineer specializing in building web apps with Python and Django, which he has been doing professionally since 2014. He works as a staff engineer, leading the backend team, which develops the GraphQL API. He has spoken at several tech conferences, including GraphQL Summit and PyCon Korea, and his main topics of interest are open-source, Python, and GraphQL. In his free time, he is a runner, musician, and traveler. He is based in Wrocław, Poland.

 
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset