Лион Уильям - Разработка веб-приложений GraphQL с React, Node.js и Neo4j [2023, PDF, RUS]

Предисловие от издательства........................................................................10
Вступление.........................................................................................................11
Благодарности...................................................................................................12
О книге................................................................................................................13
Кому адресована эта книга............................................................................. 13
Организация книги......................................................................................... 13
О примерах программного кода..................................................................... 14
Требования к программному обеспечению.................................................. 14
Живое обсуждение книги................................................................................ 15
Другие онлайн-ресурсы.................................................................................. 15
Об авторе...........................................................................................................16
Об иллюстрации на обложке..........................................................................16
Часть I. Введение в стек GraphQL...................................................................17
Глава 1. Что такое стек GraphQL?...................................................................18
1.1. Обзор стека GraphQL................................................................................. 18
1.2. GraphQL...................................................................................................... 20
1.2.1. Определения типов в GraphQL................................................................... 20
1.2.2. Запросы GraphQL......................................................................................... 22
1.2.3. Преимущества GraphQL.............................................................................. 25
1.2.4. Недостатки GraphQL.................................................................................... 27
1.2.5. Инструменты GraphQL................................................................................ 28
1.3. React...........................................................................................................30
1.3.1. Компоненты React....................................................................................... 31
1.3.2. JSX................................................................................................................. 31
1.3.3. Инструменты React..................................................................................... 31
1.4. Apollo..........................................................................................................33
1.4.1. Apollo Server................................................................................................. 33
1.4.2. Apolo Client.................................................................................................. 33
1.5. База данных Neo4j..................................................................................... 33
1.5.1. Графовая модель свойств............................................................................ 34
1.5.2. Язык запросов Cypher................................................................................. 34
1.5.3. Инструменты Neo4j..................................................................................... 35
1.6. Как все это сочетается............................................................................... 38
1.6.1. React и Apollo Client: выполнение запроса............................................... 38
1.6.2. Apollo Server и серверная часть GraphQL................................................... 39
1.6.3. React и Apollo Client: обработка ответа..................................................... 41
1.7. Что мы будем строить в этой книге......................................................... 42
1.8. Упражнения............................................................................................... 42
Итоги................................................................................................................43
Глава 2. Графовое мышление с GraphQL.......................................................44
2.1. Данные приложения – это граф............................................................... 44
2.2. Графы в GraphQL....................................................................................... 46
2.2.1. Моделирование API с применением определений типов:
разработка на основе GraphQL.................................................................... 46
2.2.2. Выборка данных с помощью функций разрешения................................. 53
2.2.3. Наша первая функция разрешения............................................................ 54
2.3. Объединение определений типов и функций разрешения
в Apollo Server............................................................................................. 57
2.3.1. Apollo Server................................................................................................. 57
2.3.2. Apollo Studio................................................................................................. 57
2.3.3. Реализация функций разрешения............................................................. 59
2.3.4. Выполнение запросов с помощью Apollo Studio....................................... 62
2.4. Упражнения............................................................................................... 63
Итоги................................................................................................................63
Глава 3. Графы в базе данных.........................................................................64
3.1. Обзор Neo4j................................................................................................ 64
3.2. Моделирование графовых данных в Neo4j............................................. 65
3.2.1. Графовая модель свойств............................................................................ 66
3.2.2. Ограничения базы данных и индексы....................................................... 69
3.3. Вопросы моделирования данных............................................................ 69
3.3.1. Узел и свойство............................................................................................ 69
3.3.2. Узел и отношение........................................................................................ 70
3.3.3. Индексы....................................................................................................... 70
3.3.4. Специфика типов отношений.................................................................... 70
3.3.5. Выбор направления отношений................................................................. 70
3.4. Инструменты: Neo4j Desktop.................................................................... 70
3.5. Инструменты: Neo4j Browser.................................................................... 71
3.6. Cypher.........................................................................................................72
3.6.1. Сопоставление с образцом......................................................................... 72
3.6.2. Свойства....................................................................................................... 72
3.6.3. CREATE......................................................................................................... 73
3.6.4. MERGE.......................................................................................................... 76
3.6.5. Определение ограничений на Cypher........................................................ 77
3.6.6. MATCH.......................................................................................................... 78
3.6.7. Агрегаты....................................................................................................... 79
3.7. Использование клиентских драйверов Neo4j.......................................... 79
3.8. Упражнения............................................................................................... 80
Итоги................................................................................................................80
Глава 4. Библиотека Neo4j GraphQL...............................................................81
4.1. Распространенные проблемы GraphQL................................................... 82
4.1.1. Низкая производительность и проблема n + 1 запросов.......................... 82
4.1.2. Типовой код и продуктивность разработчиков........................................ 82
4.2. Введение в средства интеграции GraphQL с базой данных................... 83
4.3. Библиотека Neo4j GraphQL....................................................................... 83
4.3.1. Настройка проекта...................................................................................... 84
4.3.2. Генерирование схемы GraphQL из определений типов............................ 88
4.4. Основы запросов GraphQL........................................................................ 90
4.5. Упорядочение и разбиение на страницы................................................ 93
4.6. Вложенные запросы.................................................................................. 94
4.7. Фильтрация................................................................................................ 95
4.7.1. Аргумент where............................................................................................ 95
4.7.2. Вложенные фильтры.................................................................................... 96
4.7.3. Логические операторы: AND, OR................................................................ 97
4.7.4. Фильтрация выборки................................................................................... 98
4.8. Работа с датой/временем........................................................................ 100
4.8.1. Использование типа Date в запросах....................................................... 100
4.8.2. Фильтры по полям с типами Date и DateTime......................................... 101
4.9. Работа с пространственными данными................................................ 102
4.9.1. Выборка данных типа Point...................................................................... 102
4.9.2. Фильтрация по расстояниям.................................................................... 103
4.10. Добавление своей логики в GraphQL API............................................. 104
4.10.1. Директива @cypher................................................................................. 104
4.10.2. Реализация собственных функций разрешения................................... 108
4.11. Определение схемы GraphQL в существующей базе данных............. 110
4.12. Упражнения........................................................................................... 111
Итоги.............................................................................................................. 112
Часть II. Создание пользовательского интерфейса...................................113
Глава 5. Создание пользовательского интерфейса
с помощью React.............................................................................................114
5.1. Обзор React.............................................................................................. 115
5.1.1. JSX и элементы React................................................................................. 115
5.1.2. Компоненты React..................................................................................... 116
5.1.3. Иерархия компонентов............................................................................. 117
5.2. Create React App....................................................................................... 117
5.2.1. Создание приложения React с помощью Create React App..................... 117
5.3. Состояние и подключаемые обработчики React Hooks........................ 124
5.4. Упражнения............................................................................................. 128
Итоги.............................................................................................................. 128
Глава 6. Клиент GraphQL................................................................................130
6.1. Apollo Client............................................................................................. 131
6.1.1. Добавление Apollo Client в приложение React........................................ 131
6.1.2. Обработчики Apollo Client........................................................................ 134
6.1.3. Переменные GraphQL............................................................................... 138
6.1.4. Фрагменты GraphQL.................................................................................. 139
6.1.5. Кеширование в Apollo Client.................................................................... 141
6.2. Мутации GraphQL.................................................................................... 143
6.2.1. Создание узлов.......................................................................................... 143
6.2.2. Создание отношений................................................................................ 145
6.2.3. Изменение и удаление.............................................................................. 146
6.3. Управление состоянием клиента с помощью GraphQL........................ 147
6.3.1. Локальные поля и реактивные переменные........................................... 147
6.4. Упражнения............................................................................................. 151
Итоги.............................................................................................................. 152
Часть III. Задачи разработки полного цикла..............................................153
Глава 7. Добавление авторизации и аутентификации..............................154
7.1. Авторизация в GraphQL: простейший подход....................................... 155
7.2. Веб-токены JSON Web Token................................................................... 158
7.3. Директива схемы @auth......................................................................... 162
7.3.1. Правила и операции.................................................................................. 163
7.3.2. Правило авторизации isAuthenticated..................................................... 164
7.3.3. Правило авторизации roles....................................................................... 165
7.3.4 Правило авторизации allow....................................................................... 168
7.3.5. Правило авторизации where..................................................................... 169
7.3.6. Правило авторизации bind........................................................................ 171
7.4. Auth0: JWT как услуга.............................................................................. 172
7.4.1. Настройка Auth0........................................................................................ 172
7.4.2. Auth0 React................................................................................................. 175
7.5. Упражнения............................................................................................. 186
Итоги.............................................................................................................. 186
Глава 8. Развертывание приложения GraphQL..........................................187
8.1. Развертывание приложения GraphQL................................................... 187
8.1.1. Преимущества развертывания в бессерверном окружении.................. 188
8.1.2. Недостатки развертывания в бессерверном окружении........................ 189
8.1.3. Обзор подхода к развертыванию приложения GraphQL
в бессерверном окружении........................................................................ 189
8.2. База данных Neo4j Aura как услуга........................................................ 190
8.2.1. Создание кластера Neo4j Aura.................................................................. 191
8.2.2. Подключение к кластеру Neo4j Aura........................................................ 193
8.2.3. Выгрузка данных в Neo4j Aura.................................................................. 196
8.2.4. Исследование графа с помощью Neo4j Bloom......................................... 198
8.3. Развертывание приложения React с помощью Netlify Build................ 201
8.3.1. Добавление сайта в Netlify........................................................................ 202
8.3.2. Настройка переменных окружения для сборок Netlify.......................... 210
8.3.3. Предварительное развертывание в Netlify.............................................. 213
8.4. Развертывание GraphQL в виде бессерверной функции
с помощью AWS Lambda и Netlify Functions........................................... 216
8.4.1. GraphQL API в виде бессерверной функции............................................ 216
8.4.2. dev: интерфейс командной строки Netlify.............................................. 218
8.4.3. Преобразование GraphQL API в функцию Netlify................................... 219
8.4.4. Добавление собственного домена в Netlify............................................. 222
8.5. Наш подход к развертыванию................................................................ 224
8.6. Упражнения............................................................................................. 225
Итоги.............................................................................................................. 225
Глава 9. Продвинутые возможности GraphQL............................................227
9.1. Абстрактные типы GraphQL................................................................... 227
9.1.1. Интерфейсы............................................................................................... 228
9.1.2. Объединения............................................................................................. 229
9.1.3. Использование абстрактных типов
с библиотекой Neo4j GraphQL................................................................... 230
9.2. Разбиение на страницы с помощью GraphQL....................................... 242
9.2.1. Разбиение на страницы по смещению.................................................... 243
9.2.2. Разбиение на страницы с помощью курсора.......................................... 244
9.3. Свойства отношений.............................................................................. 248
9.3.1. Интерфейсы и директива @relationship................................................. 249
9.3.2. Создание свойств отношений.................................................................. 250
9.4. В заключение........................................................................................... 251
9.5. Упражнения............................................................................................. 252
Итоги.............................................................................................................. 253
Предметный указатель..................................................................................254