Типизация Redux с TypeScript: как добиться безопасности и не писать 500 строк ради action

•
Опубликовано
•
16 мин чтения

Текст написан с позиции октября 2021 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.

У Redux и TypeScript довольно сложная репутация в паре. На словах все выглядит идеально: Redux дает предсказуемость управления состоянием, TypeScript — строгость и защиту от массы ошибок, значит вместе они должны образовывать почти образцовую инженерную комбинацию. Но в реальной жизни у многих разработчиков именно здесь начинается усталость. Стоит только попытаться “типизировать все правильно”, как проект обрастает бесконечными интерфейсами для action, ручными union-типами, дублированием строковых констант, вспомогательными type guard’ами, отдельными фабриками, утилитами и десятками строк кода, которые формально нужны ради безопасности, но субъективно выглядят как налог на использование Redux.

Самая вредная реакция на эту усталость — услышать про типизацию Redux и решить, что лекарство простое: “ну просто опишите все типами”. Этот совет слишком грубый. Он не отвечает на главный практический вопрос: как получить реальную пользу от TypeScript в Redux-коде, не превратив приложение в музей бойлерплейта. Потому что проблема ведь не в том, что типизация не нужна. Проблема в том, что плохая типизация в Redux очень легко становится дороже тех ошибок, от которых она вообще должна защищать.

На этом фоне особенно важно признать простую вещь: хорошая типизация Redux — это не максимальное количество написанных типов. Это минимальное количество ручного кода, при котором TypeScript все еще надежно понимает модель состояния, сигнатуры dispatch, формат action, возвращаемые значения селекторов и поведение асинхронных сценариев. Как только количество типового шума становится слишком большим, система начинает работать против разработчика. Люди перестают ей доверять, начинают искать обходные пути, вставлять as any, копировать куски из старых файлов и в итоге теряют и строгость, и удовольствие от сопровождения.

Поэтому вопрос нужно ставить иначе. Не “как типизировать Redux максимально подробно”, а “как выстроить такую модель типизации, в которой безопасность возникает естественно из структуры кода, а не из постоянного ручного дублирования”. И, к счастью, осенью 2021 года уже довольно ясно, что такой путь есть. Он требует дисциплины, но не требует ритуала из пятисот строк ради простого action.

Почему Redux + TypeScript так часто скатывается в перегруз

Исторически проблема выросла из очень понятного желания. Разработчики хотели сделать Redux по-настоящему безопасным на уровне типов. У нас есть action с полем type, иногда с payload, есть reducer, который должен правильно сужать тип, есть dispatch, который должен знать, что именно можно отправлять, есть thunks, которые должны быть типизированы по состоянию и возвращаемым значениям. В теории все разумно. Но на практике ранние подходы слишком часто строились вокруг ручного описания всего этого мира.

Для каждого action создавался отдельный интерфейс. Затем руками составлялся общий union всех action данного модуля. Потом этот union прокидывался в reducer. Потом появлялся новый action — и нужно было не забыть поправить еще несколько мест. Потом асинхронные сценарии требовали дополнительных типов для request, success, failure. Потом команда начинала создавать генераторы и константы, чтобы хоть как-то удержать согласованность. Формально система становилась “строгой”. Фактически она начинала напоминать бумажный документооборот.

Самое неприятное здесь то, что огромная часть этого кода не несла новой бизнес-ценности. Она лишь поддерживала синхронизацию между сущностями, которые уже были логически связаны, но не были связаны на уровне самой структуры программы. TypeScript в таких схемах не выводил типы естественно, а обслуживал бесконечное количество ручных договоренностей. Именно это и создавало ощущение, что ради Redux-типизации приходится платить слишком высокую цену.

Главный принцип: типы должны вытекать из кода, а не дублировать его

Если пытаться сформулировать самый полезный практический ориентир для типизации Redux сегодня, он будет звучать так: лучшие типы — это те, которые выводятся из уже существующего кода, а не те, которые вы пишете как параллельную вселенную рядом с ним. Это очень важный сдвиг мышления. Он буквально меняет весь стиль Redux + TypeScript.

Плохой путь выглядит так: мы сначала вручную описываем типы action, state, dispatch и результатов, а потом стараемся, чтобы код им соответствовал. Хороший путь выглядит иначе: мы строим Redux-код так, чтобы TypeScript мог извлекать типовую информацию из action creators, reducer’ов, store и селекторов почти автоматически. Тогда типы становятся не отдельным проектом по сопровождению, а естественным отражением структуры приложения.

Именно поэтому в последние годы так сильно выросла ценность подходов, где action создаются через функции-генераторы, slice-конфигурации или другие формы, позволяющие вывести литеральные типы и payload без ручного дубляжа. Как только вы перестаете писать интерфейс “вручную рядом с action”, большая часть боли просто исчезает. Типы начинают следовать за кодом, а не требовать постоянного ручного надзора.

Проблема не в количестве action, а в ручных discriminated union

Очень многие разработчики, вспоминая болезненный опыт с Redux и TypeScript, на самом деле страдали не от самого Redux, а от способа типизации action. Классическая схема с отдельным интерфейсом на каждый action быстро становится невыносимой именно потому, что заставляет руками поддерживать discriminated union. То есть вы описываете структуру каждого действия отдельно, а затем еще и составляете общий union, по которому reducer должен уметь сужать ветки.

Это красиво выглядит в учебном примере и очень плохо масштабируется в живом коде. Любое новое действие требует дополнительной механической работы. Любое переименование или изменение payload рискует отразиться не в одном месте, а в целой цепочке связанных определений. И хотя TypeScript формально помогает, субъективное ощущение все равно такое, будто код просит слишком много внимания за слишком малую практическую выгоду.

Поэтому один из важнейших способов “не писать 500 строк ради action” — вообще перестать строить архитектуру на ручных action-интерфейсах там, где это можно избежать. Сегодня это уже не выглядит обязательной инженерной добродетелью. Наоборот, в большинстве прикладных проектов это скорее признак того, что выбрана слишком трудозатратная модель типизации.

Action creator как источник правды

Если вы хотите уменьшить бойлерплейт и при этом сохранить строгость, один из лучших ходов — сделать action creator главным источником типовой правды. Это очень здоровая идея. Вместо того чтобы отдельно описывать “какой бывает action” и отдельно писать функцию, которая этот action создает, вы строите код так, чтобы именно функция создания действия задавала его форму, а TypeScript уже извлекал тип из нее.

Почему это так важно? Потому что action creator — это реальное место, где действие появляется в системе. Там уже присутствуют и строковый тип, и payload, и часто логика нормализации входных данных. Если типизацию выстраивать вокруг этого узла, исчезает огромный слой дублирования. Reducer и dispatch получают возможность опираться на выведенные типы. Разработчик меняет одну сущность, а не две параллельные проекции одной и той же информации.

Это тот случай, когда хорошая типизация буквально уменьшает количество кода. Она не добавляет ритуалов, а убирает их. И именно это должно быть целью в Redux-проекте: сделать систему типов следствием реального интерфейса API вашего state layer, а не отдельной бюрократической надстройкой.

Redux Toolkit изменил разговор не случайно

Сегодня уже вполне ясно, что разговор о типизации Redux трудно вести всерьез, игнорируя Redux Toolkit. И дело не только в том, что это “рекомендуемый современный способ”. Дело в том, что Toolkit очень сильно уменьшает то количество ручной синхронизации типов, которое раньше и создавало основную боль.

Когда вы используете createSlice, createAction и связанные с ними инструменты, вы не просто пишете меньше кода. Вы меняете саму природу типизации. У action автоматически появляется литеральный type, payload становится выводимым, reducer-ветки получают контекст, а сам slice становится гораздо ближе к тому, чтобы быть самодостаточным модулем состояния. Ручной union всех action начинает выглядеть уже не как обязательная часть архитектуры, а как пережиток более тяжеловесного периода.

Важно понимать, что ценность Toolkit здесь не в моде и не в уменьшении количества строк как самоцели. Его настоящая сила в том, что он лучше совмещает Redux как архитектурную модель с TypeScript как системой вывода типов. Раньше эти две вещи нередко конфликтовали из-за избытка декларативного шума. Теперь они гораздо чаще работают в одном направлении.

Типизация состояния должна начинаться со store, а не с разбросанных интерфейсов

Еще одна частая ошибка — мыслить типизацию Redux “снизу вверх” через набор вручную написанных интерфейсов для отдельных кусочков state, а потом пытаться как-то собрать это в общую систему. На маленьком проекте это может выглядеть безобидно. На большом — быстро начинает порождать рассогласование между реальной конфигурацией store и тем, что команда считает его типом.

Гораздо надежнее строить типы от самого store. То есть считать корневой тип состояния производным от фактической конфигурации корневого reducer или store setup. Это очень практичная мысль. Она означает, что RootState не пишется руками как “примерно вот такая форма объекта”, а выводится из источника истины. Тогда любые изменения в структуре слайсов автоматически отражаются в типе состояния без необходимости помнить о ручной синхронизации.

То же самое относится и к типу dispatch. Если он выводится из реального store, а не описывается как абстрактная функция “принимает action”, система лучше знает о thunk’ах, middleware и прочих особенностях конфигурации. Это особенно важно в приложениях, где dispatch уже давно не равен просто отправке plain object action.

Typed hooks — маленький прием с большим эффектом

Один из самых недооцененных способов сделать Redux + TypeScript комфортнее — это правильно типизированные пользовательские обертки над useDispatch и useSelector. Формально это мелочь. На практике — почти обязательный элемент удобной кодовой базы.

Если по всему приложению каждый разработчик каждый раз вручную подсказывает типы селектора или работает с недостаточно точным dispatch, вы неизбежно получаете повторяющийся шум и места для небрежности. Как только появляются стандартные useAppDispatch и useAppSelector, связанные с выведенными типами store, большая часть этой механики просто исчезает из повседневного кода. Компоненты становятся чище, подсказки редактора — точнее, а вероятность того, что кто-то “на глазок” обойдет систему типов, заметно уменьшается.

Это хороший пример того, как качественная типизация работает не через большие декларации, а через несколько правильно выбранных точек интеграции. Вам не нужно типизировать все вручную. Нужно просто сделать так, чтобы типы были удобно доступны там, где разработчики работают с ними каждый день.

Payload — это не место для расползания any

Во многих Redux-проектах типобезопасность на самом деле умирает не на уровне state и не в reducer, а в payload action. Именно туда чаще всего просачивается неопределенность. Сначала кто-то быстро ставит any, чтобы “потом дописать”. Потом другой action копирует этот паттерн. Потом асинхронный сценарий начинает гонять недостаточно точные данные между слоями. И через некоторое время формально типизированная система уже не очень-то и защищает от реальных ошибок.

Поэтому очень важно считать payload одной из ключевых точек строгости. Но строгость здесь не должна означать вручную описанные армии интерфейсов. Наоборот, лучший путь — использовать выводимые типы там, где payload возникает естественным образом. Если action creator или thunk принимает аргумент определенной формы, эта форма и должна становиться источником типовой правды. Тогда payload не нужно дублировать в трех местах.

Чем точнее и ближе к источнику определены payload-типы, тем проще reducer’ам, селекторам и компонентам жить в согласованной системе. И тем реже команда будет ощущать, что TypeScript “мешает”. Обычно он мешает именно тогда, когда типы размазаны и дублируются, а не тогда, когда они выводятся по-честному.

Асинхронный Redux — место, где легко снова скатиться в бойлерплейт

Даже если action и reducer уже хорошо типизированы, настоящий стресс-тест для системы начинается в асинхронных сценариях. Запросы, ошибки, статусы загрузки, типы ответов, аргументы thunk’ов, возвращаемые значения dispatch — именно здесь старые подходы особенно быстро раздувались в бойлерплейт. Каждая асинхронная операция начинала жить как маленькая бюрократическая машина: request action, success action, failure action, отдельные интерфейсы, отдельные константы, ручная координация payload для каждого состояния.

Это как раз тот участок, где современный подход особенно выигрывает. Если использовать инструменты, которые умеют описывать асинхронный сценарий как одну сущность с выводимыми типами аргументов, результата и ошибки, количество ритуального кода резко падает. Важна не сама библиотечная магия, а то, что модель становится ближе к реальному сценарию. У вас есть одна операция загрузки пользователя, а не три формально раздельных action-интерфейса плюс отдельный ручной union.

Именно поэтому типизацию асинхронного Redux стоит воспринимать не как задачу “описать побольше сущностей”, а как задачу “не дробить один сценарий на лишние типовые фрагменты, если система может вывести их сама”.

Селекторы тоже часть системы типов, а не просто удобные функции

Когда говорят о типизации Redux, обычно больше внимания уделяют action и reducer. Но в реальной кодовой базе не менее важны селекторы. Именно через них большая часть компонентов получает доступ к данным store. И если селекторы типизированы слабо или возвращают слишком размытые значения, фронтенд-слой начинает терять ту самую безопасность, ради которой вообще затевалась вся типизация состояния.

Хорошая новость здесь в том, что селекторы обычно прекрасно типизируются при правильной основе. Если RootState выведен из store, селектор получает точный тип входа почти бесплатно. Остается только не портить картину возвращаемым any или чрезмерно широкими union’ами там, где можно сохранить конкретику. Особенно полезно это для производных селекторов: как только TypeScript понимает, какие именно куски состояния участвуют в вычислении, он начинает гораздо лучше страховать и от ошибочных обращений к полям, и от неочевидных рассогласований после рефакторинга.

С практической точки зрения это значит простую вещь: не стоит воспринимать селекторы как второстепенный слой, который “и так понятно”. В хорошо типизированном Redux-приложении они являются частью главной линии безопасности — между store и компонентом.

Нормальная типизация не должна требовать помнить всю систему в голове

Есть один хороший тест на качество типовой архитектуры Redux. Представьте разработчика, который пришел в проект недавно. Если для добавления нового action ему нужно помнить, какие интерфейсы где составляются в union, какой reducer принимает какой generic, в каком файле лежит общий тип dispatch и где еще нужно обновить служебные типы, система устроена слишком тяжело. Даже если она формально “строгая”.

Хорошая типизация отличается тем, что значительная часть правил встроена в структуру кода. Добавляешь новый case в slice — типы сами подхватывают изменения. Добавляешь новый selector — RootState уже известен. Используешь dispatch — typed hook уже знает сигнатуру. Запускаешь асинхронный сценарий — типы аргумента и результата следуют из одной точки определения. В такой системе разработчику не нужно ментально собирать архитектурную карту каждый раз, чтобы не нарушить типовую целостность.

Это очень важный критерий, потому что он отличает настоящую инженерную безопасность от декоративной строгости. Первая помогает работать. Вторая просто наказывает за забывчивость.

Где все еще можно переборщить даже с современными инструментами

Наличие Redux Toolkit и хороших практик не означает, что перегруз теперь невозможен. Переборщить по-прежнему можно, просто в других местах. Например, начать чрезмерно обобщать slice-фабрики, писать хитрые generic-обертки поверх thunk’ов, строить “универсальные” action-конструкторы, которые формально типобезопасны, но требуют слишком сложной ментальной модели. Или, что тоже часто бывает, переносить во внутренние утилиты столько типовой магии, что код становится труднее читать, чем если бы команда просто честно написала несколько конкретных случаев.

Это важное напоминание: цель не в том, чтобы сделать TypeScript максимально продвинутым. Цель в том, чтобы обеспечить безопасность при минимальном когнитивном налоге. Иногда слишком умная generic-конструкция на сто строк хуже, чем три ясных конкретных объявления. Если разработчики не понимают, как работает типовая магия, они быстро начинают ее бояться и обходить.

Поэтому здоровая типизация Redux — это всегда баланс. Достаточно абстракции, чтобы не дублировать одно и то же. Но не настолько много, чтобы обычное добавление action превращалось в археологию по внутренним helper-типам.

Когда ручные типы все-таки уместны

На этом фоне легко уйти в другую крайность и решить, что любые ручные типы — зло. Это тоже неверно. Есть ситуации, где явное описание типа оправдано и полезно. Например, публичный контракт сложного payload, который используется в нескольких независимых местах. Или тип сложной доменной сущности, которая живет шире, чем один slice. Или интерфейс для нормализованной структуры данных, с которой работают несколько операций.

Смысл не в том, чтобы никогда ничего не писать руками. Смысл в том, чтобы вручную описывать то, что действительно имеет самостоятельную ценность как часть предметной модели, а не то, что можно безопасно вывести из существующего кода. Это очень важная граница. Если действие существует только как результат action creator, нет большого смысла отдельно заводить для него искусственный интерфейс ради формальной красоты. Если же тип действительно отражает доменную реальность и живет не только внутри одного технического узла, явное определение вполне уместно.

То есть хороший стиль — не “никаких явных типов”, а “никакого бессмысленного дублирования”. Это гораздо более зрелая позиция.

Практический ориентир: типизируйте точки контакта, а не каждый винтик вручную

Если упростить все рекомендации до одного рабочего принципа, он будет таким: в Redux + TypeScript особенно важно типизировать точки контакта между слоями. Store должен точно задавать RootState и dispatch. Typed hooks должны доносить эти типы до компонентов. Action creators или slices должны задавать форму действий. Thunks должны ясно описывать вход и выход асинхронного сценария. Селекторы должны типобезопасно возвращать данные из состояния.

Когда эти точки организованы хорошо, внутренние детали уже не требуют такой массы ручного вмешательства. Именно здесь обычно и рождается ощущение “безопасно, но без боли”. Потому что типы работают в местах, где они реально пересекают разные части системы. А не оседают в бесконечных внутренних интерфейсах, которые нужны только для того, чтобы кое-как связать типизацию между собой.

Именно так Redux становится удобным союзником TypeScript, а не его жертвой.

Итог

Типизация Redux с TypeScript становится тяжелой не потому, что сама задача безнадежно сложна, а потому, что ее слишком долго решали через ручное дублирование всего подряд. Отдельный интерфейс на каждый action, огромные union-типы, разрозненные декларации состояния, ручная типизация dispatch и асинхронных сценариев — все это создавало ощущение, будто безопасность покупается ценой бесконечного бойлерплейта.

Сегодня уже довольно ясно, что лучший путь другой. Типы должны вытекать из store, slice, action creator, thunk и селектора как из источников правды. Redux Toolkit, выведение RootState и dispatch, typed hooks, точная работа с payload и более естественная типизация асинхронных операций позволяют получить реальную строгость без ритуала на сотни строк. Не потому, что магия все решила за разработчика, а потому, что структура кода стала дружелюбнее к выводу типов.

И если сформулировать главный практический вывод совсем прямо, он будет таким: безопасный Redux на TypeScript строится не на количестве написанных интерфейсов, а на количестве мест, где система способна вывести типы сама. Чем меньше вы заставляете себя вручную поддерживать параллельную типовую вселенную, тем выше шанс, что ваша типизация действительно будет помогать — а не просто требовать пятьсот строк ради очередного action.

Автор

Senior Principal JavaScript Developer, Tech Lead. Пишет о React, TypeScript, React Native, архитектуре фронтенда и бэкенда и о том, как AI меняет работу разработчика.

Обновлено

Читайте также