Table of Contents

Preface

1

Developing for Drupal

Introducing Drupal (for developers)

How did we get to Drupal 10?

Developing for Drupal

Technologies that drive Drupal

PHP

Databases and MySQL

The web server

Drupal architecture

Drupal’s major subsystems

Tools for developing in Drupal

Summary

2

Creating Your First Module

Creating a module

Your first hook implementation

Route and controller

Services

Using services in Drupal

Injecting the service into our Controller

Invoked Controllers

The Form API

Altering forms

Custom submit handlers

Rendering forms

Service dependencies

Blocks

Our first block plugin

Block configuration

Working with links

The URL

The link

Which way to link?

Event Dispatcher and redirects

Redirecting from a Controller

Redirecting from a subscriber

Dispatching events

Summary

3

Logging and Mailing

Logging

The Drupal logging theory

Our own logger channel

Our own logger

Logging for Hello World

Logging recap

Mail API

The theory behind the Mail API

Implementing hook_mail()

Sending emails

Altering someone else’s emails

Custom mail plugins

Mail API recap

Tokens

The Token API

Using tokens

Defining new tokens

Tokens recap

Summary

4

Theming

Business logic versus presentation logic

Twig

Theme hooks

Theme hook suggestions

Render arrays

The structure of a render array

The render pipeline

Assets and libraries

Libraries

Common theme hooks

Lists

Links

Tables

Attributes

Layouts

Defining layouts

Rendering a layout

Theming our Hello World module

Summary

5

Menus and Menu Links

The menu system

Menus

Menu links

MenuLink trees

Rendering menus

Working with menu links

Defining menu links

Manipulating menu links

Defining local tasks

Defining local actions

Defining contextual links

Summary

6

Data Modeling and Storage

Different types of data storage

The State API

TempStore

Private TempStore

Shared TempStore

Tempstore recap

The UserData API

Configuration API

Introduction

Configuration storage

Configuration recap

Entities

Content versus configuration entity types

Entity type plugins

Fields

Entity types recap

TypedData

Why TypedData?

What is TypedData?

The low-level API

Content entities

TypedData recap

Interacting with the Entity API

Querying entities

Loading entities

Reading entities

Manipulating entities

Creating entities

Rendering content entities

Pseudo-fields

Entity validation

Summary

7

Your Own Custom Entity and Plugin Types

Our custom content entity type

Entity updates

Our custom plugin type

Our custom configuration entity type

The Importer plugin

Content entity bundles

Our own Drush command

Summary

8

The Database API

The Schema API

Running queries

Select queries

Pagers

Insert queries

Update queries

Delete queries

Transactions

Query alters

Update hooks

Post update hooks

Summary

9

Custom Fields

A recap of Field type plugins

Field type

Field widget

Field formatter

Field settings

Using our custom field type as a base field

Summary

10

Access Control

Introduction to the Drupal access system

Roles and permissions under the hood

Defining permissions

Checking the user credentials

Route access

Custom route access

Programmatically checking access on routes

Bonus – dynamic route options for access control

CSRF protection on routes

Altering routes

Entity access

Injecting services into Entity handlers

Entity access hooks

Field access

Entity access in routes

Node access grants

Block access

Summary

11

Caching

Introduction to caching

Cacheability metadata

Cache tags

Cache contexts

max-age

Using the cache metadata

Placeholders and lazy building

Lazy builders

Using the Cache API

Creating our own cache bin

Summary

12

JavaScript and the Ajax API

JavaScript in Drupal

Drupal behaviors

Drupal settings

The Ajax API

Ajax links

Ajax in forms

The States (Form) system

Summary

13

Internationalization and Languages

Introduction to the multilingual ecosystem

Language

Content translation

Configuration translation

Interface translation

Internationalization

Content entities and the translation API

Summary

14

Batches, Queues, and Cron

Batch-powered update hooks

Batch operations

Creating the batch

Batch operations

Cron

Queues

Introduction to the Queue API

Cron-based queues

Processing a queue programmatically

The Lock API

Summary

15

Views

Entities in Views

Exposing custom data to Views

Views data

Custom Views field

Field configuration

Custom Views filter

Custom Views argument

Views theming

Views hooks

Summary

16

Working with Files and Images

The filesystem

Stream wrappers

Managed versus unmanaged files

Using the File and Image fields

Working with managed files

Attaching managed files to entities

Helpful functions for dealing with managed files

Managed file uploads

Our own stream wrapper

Working with unmanaged files

Private filesystem

Images

Image toolkits

Image styles

Rendering images

Summary

17

Automated Testing

Testing methodologies in Drupal

PHPUnit

Registering tests

Unit tests

Mocked dependencies

Kernel tests

TeamCleaner test

CsvImporter test

Functional tests

Configuration for Functional tests

Hello World page test

Hello World form test

Functional JavaScript tests

Time test

CsvImporter test

Summary

18

Drupal Security

Cross-Site Scripting (XSS)

Sanitization methods in Drupal

Double escaping

SQL Injection

Cross-Site Request Forgery (CSRF)

Summary

Index

Other Books You May Enjoy