Офлайн-first в React Native: синхронизация, конфликты и честный UX
Текст написан с позиции августа 2026 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
У офлайн-режима в мобильных приложениях странная репутация. На словах его хотят все: продакт пишет в требованиях «должно работать без сети», дизайнер рисует аккуратную плашку «нет подключения», разработчик кивает и добавляет кэш запросов. А потом приложение попадает в метро, в лифт, на склад с бетонными стенами или в загородный дом с одной полоской LTE — и выясняется, что «работает без сети» означало «показывает последний экран, пока пользователь ничего не трогает».
Почему так происходит? Потому что офлайн почти всегда добавляют как фичу поверх уже готовой архитектуры, где сервер — единственный источник правды, а клиент — тонкая витрина над REST или GraphQL. В такой модели отсутствие сети — это ошибка, которую надо красиво обработать. В модели offline-first отсутствие сети — это нормальное состояние, одно из нескольких, и приложение обязано в нём жить, а не выживать.
Сразу погашу ложное ожидание. Offline-first — это не библиотека, которую можно подключить, и не флаг в конфиге. Это решение о том, кто владеет данными в каждый момент времени, и это решение проходит через всё: схему хранения, контракт с бэкендом, обработку ошибок, интерфейс и тестирование. Его цена реальна, и для многих приложений она не окупается. Но если ваши пользователи действительно работают в условиях плохой связи — курьеры, полевые сотрудники, медицина, логистика, заметки и трекеры — то альтернатива ему не «проще», а просто тихо ломается в проде.
Локальная база становится источником правды, а сервер — точкой согласования
Главный сдвиг, без которого всё остальное не работает, звучит так: интерфейс читает данные только из локального хранилища. Не из ответа сервера, не из кэша запросов, а из базы на устройстве. Сеть в этой картине — фоновый процесс, который подтягивает изменения в базу и отправляет локальные изменения наружу. Экран вообще не знает, онлайн ли мы сейчас: он подписан на данные, а данные меняются либо от действий пользователя, либо от синхронизации.
В экосистеме React Native к середине 2026 года выбор локального хранилища уже не экзотика. Есть SQLite в разных обёртках — expo-sqlite, op-sqlite, — есть WatermelonDB со своей моделью синхронизации, есть Realm, будущее которого после свёртывания Atlas Device Sync многие команды оценивают осторожно, есть быстрые key-value хранилища вроде MMKV для настроек и мелкого состояния. Важно не столько, что именно выбрать, сколько понять роль: это не кэш, который можно в любой момент сбросить, а полноценная база с миграциями, версиями схемы и ответственностью за целостность.
Именно здесь чаще всего случается подмена. Команда берёт персистентный кэш запросов — например, сохраняет состояние TanStack Query на диск — и считает, что офлайн готов. Для чтения это действительно неплохо работает. Но кэш запросов организован вокруг ответов сервера, а не вокруг сущностей предметной области. Он не знает, что задача из списка «сегодня» и та же задача на экране детали — один и тот же объект, и не умеет локально применять изменения, которые сервер ещё не видел. Персистентный кэш — это офлайн-чтение, а offline-first — это офлайн-запись, и между ними архитектурная пропасть.
Каждое действие пользователя — запись в outbox, а не запрос
Если интерфейс пишет в локальную базу, то как изменения попадают на сервер? Самый предсказуемый ответ — очередь мутаций, или outbox. Когда пользователь создаёт, редактирует или удаляет что-то, приложение делает две вещи в одной локальной транзакции: применяет изменение к данным и кладёт в отдельную таблицу запись об операции — что сделано, над какой сущностью, с какими полями, в какой момент. Синхронизатор потом разбирает эту очередь по порядку и отправляет операции на сервер.
Почему это важно делать именно в одной транзакции? Потому что иначе появляется окно, в котором данные уже изменены, а операция в очередь не попала — приложение убили, батарея села, ОС выгрузила процесс в фоне. На мобильных платформах это не редкий edge case, а обычный вторник. Outbox, записанный атомарно вместе с изменением, превращает «надеюсь, долетит» в «долетит, когда появится возможность».
Отдельный вопрос — что именно хранить в очереди: целое состояние объекта или намерение. Отправлять снимок всего объекта проще, но тогда два устройства, отредактировавшие разные поля, затрут друг друга. Хранить намерения — «поменять статус на done», «добавить комментарий», «переименовать» — сложнее в реализации, зато сервер получает операции, которые можно осмысленно применять поверх чужих изменений. Это не вопрос вкуса, а вопрос того, насколько дорого вам потом будет разбирать конфликты.
Порядок тоже имеет значение. Нельзя отправить комментарий к задаче раньше, чем саму задачу. Поэтому очередь обычно обрабатывается последовательно, а идентификаторы сущностей генерируются на клиенте — UUID или ULID, — чтобы связи между объектами были известны ещё до того, как сервер о них узнал. Временные локальные id, которые потом подменяются серверными, — частый источник багов, которые проявляются только при плохой сети и потому почти не воспроизводятся на столе разработчика.
Повтор запроса безопасен, только если сервер умеет его узнать
Мобильная сеть коварна не тем, что пропадает, а тем, что пропадает посередине. Запрос ушёл, сервер его обработал, а ответ потерялся. Клиент видит таймаут и делает то единственное разумное, что может, — повторяет. Если сервер не отличает повтор от нового запроса, у пользователя появляется два одинаковых заказа, два платежа или две одинаковые записи в журнале.
Лекарство давно известно — idempotency key. Каждая операция в outbox получает уникальный ключ в момент создания, и этот ключ отправляется с каждой попыткой. Сервер запоминает обработанные ключи и на повтор возвращает тот же результат, не выполняя операцию заново. Важно, что ключ рождается вместе с намерением пользователя, а не вместе с HTTP-запросом: если генерировать его при каждой отправке, вся защита бессмысленна.
Здесь же живут ретраи. Экспоненциальная задержка с джиттером, ограничение числа попыток, разделение ошибок на временные и постоянные. Сетевой таймаут или 503 — повторяем. Ошибка валидации или 409 — повторять бессмысленно, операцию нужно либо разрешить как конфликт, либо пометить как отклонённую и показать пользователю. Самая вредная реализация — бесконечный повтор отклонённой операции, которая стоит в голове очереди и блокирует всё, что за ней. Такая очередь выглядит живой в логах и мёртвой для пользователя.
Если сформулировать совсем прямо, офлайн-режим — это не клиентская задача, а контракт. Без идемпотентных эндпоинтов, без серверных версий записей и без внятных кодов ошибок клиент не может быть надёжным, сколько бы логики в него ни вложили. Это стоит обсудить с бэкендом до первой строчки кода, а не после первого инцидента с задвоенными заказами.
Какую стратегию конфликтов выбрать, если идеальной не существует?
Конфликт возникает, когда два источника изменили одни и те же данные, не зная друг о друге. Пользователь отредактировал карточку в самолёте, а коллега за это время отредактировал её же с компьютера. Хорошая новость: конфликтов в реальной жизни обычно гораздо меньше, чем кажется при проектировании. Плохая: когда они случаются, решение, принятое молча и неправильно, стоит доверия к продукту.
Last-write-wins — самая простая стратегия: побеждает последнее изменение. Она предсказуема и дёшева, но у неё два подвоха. Во-первых, «последнее» по чьим часам? Часы на устройствах врут, поэтому порядок лучше определять серверной версией или моментом приёма, а не временем клиента. Во-вторых, LWW на уровне целого объекта молча выбрасывает чужую работу. Для настроек профиля или статуса «прочитано» это нормально. Для текста заметки — нет.
Слияние на уровне полей — заметный шаг вперёд почти без роста сложности. Если одно устройство поменяло заголовок, а другое — дедлайн, конфликта нет вовсе: оба изменения применяются. Конфликт остаётся только там, где оба тронули одно и то же поле, и уже там можно применить LWW или спросить пользователя. Для большинства бизнес-приложений с формами и карточками это разумный компромисс: он требует хранить намерения или хотя бы диффы, но не требует новой математики.
Server-authoritative — сервер решает, клиент подчиняется. Клиент отправляет операцию, сервер применяет её по своим правилам, проверяя инварианты, и возвращает итоговое состояние. Если операция противоречит бизнес-правилам — например, товар уже закончился или заявку закрыл менеджер, — она отклоняется, и клиент откатывает своё оптимистичное изменение. Это самая честная модель там, где есть деньги, остатки, права доступа и всё, что нельзя «слить» без потери смысла.
И наконец, CRDT — структуры данных, которые сходятся к одному состоянию на всех репликах без координации. Yjs и Automerge давно вышли из исследовательской стадии, и соблазн взять их «на всякий случай» понятен. Но CRDT решают конкретную задачу — совместное редактирование одного и того же документа, прежде всего текста и вложенных структур, разными людьми одновременно. Если у вас этой задачи нет, вы платите размером метаданных, сложностью миграций, отладкой состояния, которое трудно прочитать глазами, и необходимостью объяснять команде модель, которую через полгода никто не захочет трогать. CRDT — это не уровень зрелости офлайн-архитектуры, а инструмент под совместный редактор.
На практике в одном приложении почти всегда живут несколько стратегий одновременно: LWW для пользовательских настроек, слияние полей для карточек, серверная авторитетность для всего, что связано с остатками и деньгами. Ошибка не в том, чтобы смешивать, а в том, чтобы не зафиксировать явно, какая сущность по какому правилу живёт. Это решение должно быть записано так же, как схема базы, а не угадываться по коду синхронизатора.
Интерфейс должен говорить правду о том, что сохранено
Optimistic UI — естественный спутник offline-first: пользователь нажал кнопку, изменение сразу видно, ожидание сети никого не блокирует. Но у оптимизма есть обратная сторона. Если интерфейс показывает «сохранено», а на самом деле изменение лежит в очереди третий час, приложение врёт. И пользователь узнает об этом в самый неудобный момент — когда коллега скажет «я ничего не вижу» или когда он переустановит приложение и потеряет неотправленные данные.
Честный UX в офлайн-приложении различает минимум три состояния: «сохранено на устройстве», «синхронизировано» и «требует внимания». Первое — норма, его не нужно подсвечивать тревожно. Второе можно показывать тихо, едва заметной галочкой или не показывать вовсе. Третье — отклонённая операция, конфликт, который нельзя решить автоматически, — должно быть видно явно и с понятным действием: повторить, сравнить версии, отменить.
Отдельно стоит показывать общий статус синхронизации: сколько изменений ждут отправки и когда была последняя успешная синхронизация. Не в виде красного баннера «нет сети», который пугает и ничего не объясняет, а в виде спокойной информации, к которой можно обратиться, если что-то кажется странным. Фраза «3 изменения ждут отправки, последняя синхронизация 14 минут назад» снимает больше тикетов в поддержку, чем любая анимация.
И ещё одна деталь, о которой часто забывают: выход из аккаунта и удаление данных. Если в outbox лежат неотправленные изменения, logout без предупреждения — это тихая потеря данных. Приложение должно честно сказать, что часть работы ещё не на сервере, и предложить дождаться синхронизации. Это мелочь в коде и огромная разница в доверии.
Признак «онлайн» почти ничего не говорит о сети
Самая распространённая ошибка в офлайн-логике — доверять флагу подключения. NetInfo и аналоги сообщают, что у устройства есть сетевой интерфейс, но не гарантируют, что запрос дойдёт: captive portal в отеле, VPN, который отвалился, мобильная сеть, которая формально есть, но отдаёт пакеты раз в десять секунд. Флаг «онлайн» полезен как подсказка, когда стоит попробовать синхронизацию, но не как решение, что синхронизация возможна. Источник правды о сети — результат реального запроса.
Отсюда вытекает и подход к тестированию. Проверять офлайн-сценарии, выключая Wi-Fi на телефоне, — значит тестировать самый простой и самый редкий случай: полного отсутствия сети. Реальные проблемы живут в плохой сети. Высокая задержка, потеря пакетов, обрыв соединения посередине ответа, сервер, который принял запрос и упал до ответа. Network Link Conditioner на iOS, эмуляция профилей сети в Android-эмуляторе, прокси с инъекцией задержек и ошибок — всё это должно быть частью регулярной проверки, а не героическим разовым расследованием.
Самая ценная часть тестов при этом не на устройстве. Синхронизатор, очередь, правила слияния — это чистая логика, которую можно проверять юнит- и интеграционными тестами с фейковым транспортом. Сценарии вида «две реплики меняют одно поле, затем одна отправляет, вторая получает таймаут и повторяет» пишутся один раз и ловят регрессии, которые руками не найти никогда. Если синхронизатор нельзя протестировать без живой сети, это сигнал, что он слишком переплетён с транспортом.
Во что обходится владение данными на клиенте
Пора проговорить цену, потому что без неё картина получается слишком гладкой. Offline-first удваивает количество мест, где живёт схема данных. Каждое изменение модели теперь требует миграции на сервере и миграции локальной базы, причём локальная должна корректно отработать на устройстве, которое не обновлялось полгода и хранит неотправленные операции в старом формате. Версионирование outbox — тема, о которой вспоминают обычно после первого релиза, сломавшего очередь у части пользователей.
Вторая статья расходов — отладка. Когда сервер единственный источник правды, баг воспроизводится по запросу и ответу. Когда правда распределена между сервером и тысячами устройств с разной историей синхронизации, баг часто звучит как «у одного клиента пропала задача неделю назад». Без журнала операций, без идентификаторов синхронизации в логах и без возможности выгрузить состояние локальной базы для диагностики такие истории не расследуются, а закрываются как «не воспроизводится».
Третья — безопасность и приватность. Данные на устройстве — это данные, которые могут утечь вместе с устройством. Шифрование локальной базы, политика очистки, поведение при отзыве доступа: если пользователя удалили из рабочего пространства, его телефон должен об этом узнать и стереть то, что больше не принадлежит ему. Это не сложно, но это нужно спроектировать, а не обнаружить.
Поэтому важно не свалиться в другую крайность. Приложению, которое открывают дома на Wi-Fi, чтобы посмотреть ленту, offline-first почти наверняка не нужен: хватит аккуратного кэша для чтения и понятной ошибки при записи. Банковское приложение, где каждая операция обязана пройти через сервер прямо сейчас, тоже не выиграет от очереди мутаций — там честнее явно запретить действие без сети. Смысл есть там, где пользователь создаёт ценность в момент, когда сети нет, и потеря этой ценности стоит дороже, чем сложность архитектуры.
Синхронизация — это отдельная подсистема, а не набор хуков
Если что-то и стоит вынести из всего сказанного на уровень архитектуры, то это изоляция. Синхронизатор должен быть самостоятельным модулем с понятным интерфейсом: он читает outbox, отправляет операции, принимает изменения с сервера, применяет правила слияния и пишет в базу. Компоненты React к нему отношения не имеют. Они читают базу и записывают намерения, всё. Когда логика повторов живёт в useEffect конкретного экрана, а разрешение конфликтов — в обработчике кнопки, система становится непредсказуемой ровно в тех условиях, ради которых её строили.
Такая изоляция даёт и практический бонус: синхронизатор можно запускать в фоне через механизмы фоновых задач платформы, тестировать отдельно от UI и при необходимости заменить транспорт — с REST на WebSocket или на готовый sync engine — не переписывая экраны. Готовые решения вроде PowerSync или ElectricSQL берут на себя заметную часть этой работы, и для многих команд это разумный выбор. Но даже с ними стоит понимать модель изнутри: какую стратегию конфликтов они применяют по умолчанию, где хранится очередь и что происходит с отклонённой операцией. Инструмент снимает реализацию, но не снимает ответственность за решения.
Итог
Offline-first в React Native — это не про работу без интернета, а про перераспределение владения данными. Локальная база становится источником правды для интерфейса, сервер — точкой согласования, outbox — гарантией, что намерение пользователя не потеряется, idempotency keys — гарантией, что оно не выполнится дважды. Конфликты решаются не одной универсальной стратегией, а явным выбором для каждого типа данных: LWW там, где потеря безопасна, слияние полей там, где правки независимы, серверная авторитетность там, где есть инварианты, и CRDT только там, где действительно есть совместное редактирование.
Всё это стоит денег: миграций, отладки, тестов под плохую сеть, переговоров с бэкендом о контракте. И именно поэтому решение о offline-first должно приниматься осознанно, по реальным сценариям пользователей, а не по строчке в требованиях. Там, где оно оправдано, оно даёт то, чего не даст никакая оптимизация запросов: приложение, которому можно доверять в лифте, в поле и в самолёте.
Если оставить один практический вывод, то такой: прежде чем выбирать базу или библиотеку синхронизации, ответьте на три вопроса — кто владеет каждой сущностью, что происходит с изменением, которое сервер отклонил, и как интерфейс скажет пользователю правду о том, что ещё не сохранено на сервере. Если ответы есть, технология выбирается за вечер. Если их нет, никакая технология не спасёт.