NestJS + Prisma: как строить backend без бесконечного слоя репозиториев ради репозиториев

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

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

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

На сочетании NestJS и Prisma эта проблема особенно заметна. Потому что NestJS сам по себе очень располагает к структурности. У него есть модули, сервисы, dependency injection, понятные точки входа, guards, pipes, interceptors и все остальное, что создает ощущение зрелого application framework. Prisma, в свою очередь, предлагает достаточно выразительный и уже неплохо типизированный клиент для работы с данными. И вот именно в этой связке команде особенно легко сделать одно лишнее движение: поверх Prisma Client начать строить толстый слой репозиториев, которые на деле просто дублируют его API, ничего не добавляя ни к выразительности, ни к тестируемости, ни к реальной независимости бизнес-логики.

Получается довольно странная архитектурная картина. Внизу есть Prisma. Над ним лежат UserRepository, OrderRepository, InvoiceRepository, ProductRepository и еще десяток похожих сущностей. Но если присмотреться, почти все они занимаются одним и тем же: переименовывают prisma.user.findUnique в findUserById, prisma.order.create в createOrder, а иногда еще щедро оборачивают это в пару строк дополнительного кода. Формально слой появился. По смыслу — система стала только длиннее. Бизнес-логика не упростилась, зависимости не стали особенно тоньше, а количество мест, через которые надо протащить любое изменение в запросе, внезапно выросло.

Именно поэтому связка NestJS + Prisma особенно хорошо подталкивает к более важному вопросу: где абстракция действительно нужна, а где она просто выглядит архитектурно солидно? Потому что Prisma уже сам по себе является довольно высоким уровнем доступа к данным. Это не сырой SQL-драйвер, не низкоуровневый query builder и не голое ORM-API прошлого поколения, которое требовало обширной прослойки для того, чтобы с ним было приятно жить. Prisma уже дает модели, типы, вложенные операции, транзакции, выборки, include/select, часть инвариантов на уровне схемы и относительно читаемую форму доступа к данным. И именно поэтому привычка автоматически городить над ним универсальный repository layer все чаще выглядит как инерция старой архитектурной религии, а не как обоснованная инженерная необходимость.

Это не значит, что репозитории всегда вредны. Было бы слишком просто сказать: “Prisma хороший, значит репозитории никогда не нужны”. Конечно, нужны — в некоторых задачах, при некоторых границах модулей, при сложных доменных сценариях, при нескольких источниках данных, при специальных требованиях к изоляции или выразительности прикладного слоя. Но очень важно отделить эти случаи от другой, куда более частой ситуации: репозитории возникают просто потому, что в голове команды существует догма “правильный backend обязан иметь repositories”. Вот именно с этой догмой связка NestJS + Prisma спорит особенно убедительно — не потому, что отменяет слоистость, а потому, что снимает один из главных аргументов в ее пользу.

Почему репозитории вообще стали такой привычной частью backend-мышления

Чтобы не попасть в поверхностное отрицание, полезно сначала понять, откуда вообще взялась эта привычка. Слой репозиториев долгое время казался естественным элементом серьезной архитектуры по вполне понятным причинам. Во-первых, многим ORM и persistence API прошлых лет действительно требовалась дополнительная изоляция. Они были либо слишком сырыми, либо слишком навязчивыми, либо слишком неудобными как прямой dependency для прикладных сервисов. Во-вторых, паттерн Repository хорошо ложился на DDD-язык и на желание отделить бизнес-модель от деталей хранения. В-третьих, команды хотели тестируемости и не хотели, чтобы вся логика запроса к базе торчала прямо в application service.

Все это разумные исторические причины. Но здесь есть одна тонкая ловушка: архитектурные паттерны очень редко умирают в тот момент, когда исчезают условия, породившие их массовое использование. Они продолжают жить как символы зрелости. И вот так получается, что даже когда конкретный инструмент уже сам по себе дает удобный и достаточно высокий API, команда все равно чувствует внутреннее давление “достроить правильный слой сверху”. Не потому, что без него больно. А потому, что без него как будто недостаточно солидно.

В случае Prisma эта инерция особенно хорошо видна. Многие разработчики смотрят на него как на ORM и автоматически начинают воспроизводить вокруг него старые практики, не задав себе вопрос: а действительно ли здесь тот же класс проблемы, который решали репозитории в других стеках? И очень часто оказывается, что нет. Или, по крайней мере, не в таком объеме, как раньше.

Prisma уже является абстракцией, и это важно признать

Одна из самых полезных мыслей в этой теме звучит почти банально, но именно ее часто забывают: Prisma Client — это уже не “деталь инфраструктуры” в самом низком смысле. Это достаточно богатая абстракция поверх базы данных. Она уже умеет выражать типовые запросы, отношения, вложенные операции, транзакции, фильтрацию, сортировку, агрегации, include/select и многое другое в форме, которая во многих приложениях вполне соответствует уровню прикладной работы с данными.

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

В этом месте очень полезно задавать простой вопрос: что именно новый слой добавляет? Если он добавляет язык предметной области, собирает нетривиальные сценарии выборки, изолирует действительно сложную persistence-специфику, скрывает несколько источников данных или помогает выразить осмысленные доменные операции — это одно. Если же он в основном переименовывает Prisma-методы и прокидывает аргументы дальше — это уже не архитектурная польза, а ceremony.

Чем плох “репозиторий ради репозитория”

Слой репозиториев становится вредным не потому, что само слово Repository плохое. Он становится вредным тогда, когда не несет собственной семантической работы. То есть когда его существование не меняет характер приложения, а только добавляет промежуточную ступень между Prisma и сервисом.

Это вредно сразу по нескольким причинам. Во-первых, любая новая сущность в архитектуре требует поддержки. Ее нужно читать, тестировать, рефакторить, согласовывать с остальной системой, объяснять новым людям. Если сущность не дает реального выигрыша, это чистый налог на когнитивную нагрузку. Во-вторых, лишний слой создает ложную иллюзию гибкости. Команда начинает думать, будто изолировала себя от Prisma, хотя на деле репозиторий все равно почти полностью повторяет его контракт и утягивает за собой те же assumptions. В-третьих, это тормозит развитие запросов. Любое изменение в форме выборки, include, фильтрации или вложенных операций теперь нужно протаскивать через слой, который по сути не имел собственной ценности с самого начала.

Но есть и более глубокая проблема. Репозиторий ради репозитория очень часто размазывает ответственность. Запросы, которые могли бы быть частью понятного прикладного сценария, начинают рассыпаться на набор инфраструктурных “методов доступа”, которые не совпадают с языком реального поведения системы. В итоге приложение получает не ясную доменную границу, а просто каталог CRUD-операций, замаскированный под архитектурную зрелость.

NestJS здесь подталкивает и к хорошему, и к лишнему

С NestJS ситуация интересная. С одной стороны, он очень хорошо помогает строить упорядоченный backend. Сервисы, модули, DI, guards, pipes — все это дает команде ясный организационный ритм. С другой стороны, именно из-за этого ощущения структурности NestJS иногда подталкивает к механическому умножению слоев. Команде кажется, что если есть controller, service и database layer, то между service и database обязательно должен быть repository, потому что “так красивее выглядит диаграмма”.

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

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

Когда Prisma можно использовать прямо в сервисах и это нормально

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

Если сервис берет зависимость на PrismaService, делает понятную выборку, проверяет инварианты, запускает транзакцию при необходимости и возвращает результат как часть application logic, это не выглядит архитектурным падением. Наоборот, очень часто это честнее, чем делать вид, будто ту же логику стало полезнее читать после того, как ее протащили через UserRepository с десятком однотипных методов.

Здесь работает простой критерий: если чтение сервиса от этого становится понятнее, а не наоборот, значит решение, вероятно, здоровое. Не нужно прятать Prisma из моральной неловкости. Нужно прятать его только там, где от этого действительно рождается лучший язык приложения.

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

Не все запросы должны жить в универсальном “репозитории сущности”

Еще одна старая привычка, которая особенно плохо чувствует себя рядом с Prisma, — это идея “один репозиторий на одну сущность”. Звучит аккуратно: UserRepository для пользователей, OrderRepository для заказов, ProductRepository для товаров. Проблема в том, что реальные прикладные запросы очень часто не подчиняются такой красивой механике.

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

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

Гораздо полезнее мыслить query-модулями и use-case логикой

Если уж говорить об архитектурной альтернативе, то в связке NestJS + Prisma намного продуктивнее часто оказывается не классический repository-per-entity, а более прикладной взгляд. То есть запросы и операции группируются не по таблицам, а по сценариям и областям ответственности.

Например, у вас может быть сервис или модуль для account management, который содержит операции чтения профиля, обновления настроек, работы с сессиями и правами. Или query-сервис для отчетов, который занимается только чтением и проекциями под нужды админки. Или order workflow service, который инкапсулирует всю последовательность действий по созданию и подтверждению заказа. Внутри таких границ Prisma используется как реальный инструмент запроса и записи, а не как источник вины, который надо спрятать за искусственным занавесом.

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

Когда репозиторий все-таки действительно полезен

На этом месте важно не впасть в простую противоположную догму. Репозитории не нужно отменять как класс. Есть ситуации, где они вполне оправданы и даже желательны.

Во-первых, когда у вас действительно есть выраженная доменная модель, и repository дает ей язык, который не совпадает напрямую с формой запросов Prisma. Например, вы хотите, чтобы определенный агрегат загружался и сохранялся как целостная бизнес-сущность с особыми инвариантами и не хотите, чтобы application layer думал категориями include, select и разных persistence-деталей. Во-вторых, когда доступ к данным идет не только через Prisma: несколько хранилищ, внешние сервисы, кэши, legacy-источники, поисковые движки и так далее. Тогда репозиторий может стать местом координации источников. В-третьих, когда вам действительно нужен тонкий слой изоляции для тестирования или замены persistence-стратегии — но именно потому, что это реальная потребность, а не архитектурная мантра.

Во всех этих случаях репозиторий приносит собственный смысл. Он не просто “переводчик методов Prisma”, а часть прикладной модели. И это принципиально меняет оценку. Репозиторий хорош там, где он выражает то, чего Prisma не выражает сам. Но если он только повторяет Prisma-доступ более длинным маршрутом, то ценность сомнительна.

Тестируемость — не такой однозначный аргумент, как кажется

Очень часто в пользу репозиториев приводят аргумент тестируемости. Мол, сервису нельзя напрямую зависеть от Prisma, потому что потом его трудно тестировать, а вот если между ними есть repository interface, то можно легко подменять реализацию. Формально это звучит очень убедительно. Практически — не всегда так однозначно.

Во-первых, тестировать можно на разных уровнях. И не всегда unit-тест с полностью замоканным хранилищем действительно дает больше уверенности, чем хороший integration test вокруг сервиса и тестовой базы. Во-вторых, если ради легкости мокинга команда строит целый слой псевдоабстракции, который сам по себе не улучшает архитектуру, это не бесплатный выигрыш. В-третьих, Prisma можно изолировать и без превращения всей системы в лес репозиториев: через ограниченные query-services, через transaction-scoped helpers, через более прикладные abstractions, через аккуратные boundaries между write- и read-сценариями.

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

Еще один вредный эффект лишних репозиториев — они замораживают эволюцию запросов

Prisma хорош тем, что позволяет довольно быстро и выразительно менять форму запросов по мере роста продукта. Добавить relation, поменять include, оптимизировать select, ввести новую агрегацию, перестроить nested write, вынести транзакцию — все это в нормальном прикладном коде можно делать относительно локально. Но если над каждым запросом стоит слой репозитория с искусственно стабильным API, любое изменение начинает пробивать сразу две поверхности: внутреннюю и внешнюю.

Это особенно неприятно в живых продуктах, где запросы почти никогда не остаются неизменными долго. Сегодня сервису достаточно одной формы чтения пользователя. Завтра нужен include ролей. Послезавтра — агрегированная статистика. Через неделю появляется административный кейс с другой проекцией той же сущности. Если вся эта эволюция должна каждый раз укладываться в красивую универсальную поверхность UserRepository, слой начинает либо пухнуть, либо тормозить изменения, либо насильно обобщать то, что по смыслу еще не стало общим.

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

PrismaService как инфраструктурная граница — этого часто достаточно

Во многих NestJS-проектах вполне разумной границей оказывается уже сам PrismaService. Это инфраструктурный провайдер, который инкапсулирует жизненный цикл клиента, подключение, graceful shutdown, возможно, общие helper’ы для транзакций и несколько организационных деталей. Дальше прикладные сервисы получают его через DI и используют там, где это уместно.

Это решение часто недооценивают именно потому, что оно выглядит слишком простым. Но простота здесь и есть достоинство. У вас уже есть одна понятная инфраструктурная точка. Не нужно автоматически строить поверх нее десять декоративных слоев, если прикладной код от этого не выигрывает. Более того, такая схема хорошо сочетается с тем, как NestJS вообще организует зависимости: инфраструктурный провайдер внизу, application services выше, контроллеры как транспортный слой. Уже этого нередко хватает, чтобы код оставался обозримым.

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

Разделение на read и write иногда полезнее, чем сущностные репозитории

Если в проекте действительно ощущается потребность в дополнительном слое поверх Prisma, то очень часто более здоровым направлением оказывается не классическая сущностная репозиторная схема, а разделение по типу сценариев: чтение отдельно, изменение отдельно. Это особенно полезно там, где read-model быстро обрастает фильтрами, проекциями, пагинацией, сортировкой, денормализованными представлениями и специфическими ответами под UI, а write-model, наоборот, больше связан с инвариантами, транзакциями и последовательностью бизнес-операций.

В такой модели можно строить query services для сложного чтения и application/domain services для команд и изменений. Prisma при этом может использоваться и там и там, но уже в более осмысленных границах. Это обычно дает больше пользы, чем попытка засунуть и чтение, и запись, и агрегации, и произвольные списки, и доменные операции в единый репозиторий по модели. Потому что read и write в живом продукте редко развиваются симметрично.

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

Главный критерий: язык кода должен совпадать с языком продукта

Это, пожалуй, лучший практический фильтр. Посмотрите на ваш сервис или модуль и спросите: описывает ли его код реальные сценарии системы, или он в основном воспроизводит структуру persistence API с лишними промежуточными словами? Если в коде преобладают операции вроде “найти пользователя”, “обновить заказ”, “получить платеж по id”, но при этом каждая из них просто отсылает к одному вызову Prisma без нового смысла, есть хороший шанс, что вы обслуживаете архитектурную привычку, а не продукт.

Если же код говорит на языке сценариев — “зарегистрировать пользователя”, “подтвердить заказ”, “получить витрину отчета”, “собрать карточку кабинета”, “закрыть счетный период” — и Prisma внутри этих сценариев работает как инструмент доступа к данным, а не как идейный враг, которого нужно прятать, архитектура обычно получается честнее. Она совпадает с тем, как реально живет система.

Backend от этого становится не менее чистым, а более естественным. И это особенно хорошо видно как раз на NestJS + Prisma, потому что оба инструмента сами по себе уже достаточно выразительны, чтобы не заставлять вас строить фальшивую строгость поверх них.

Итог

Связка NestJS + Prisma очень хорошо показывает одну важную архитектурную истину: не всякий знакомый слой стоит воспроизводить только потому, что он когда-то считался признаком серьезного backend’а. Prisma уже сам является достаточно богатой абстракцией работы с данными, а NestJS уже дает достаточно организационных границ, чтобы строить понятный application layer. Если поверх этого автоматически наращивать бесконечный слой репозиториев, которые в основном дублируют Prisma Client, система чаще становится не чище, а просто длиннее и тяжелее для сопровождения.

Это не означает, что репозитории больше никогда не нужны. Они нужны там, где действительно добавляют собственный смысл: выражают доменный язык, координируют несколько источников данных, скрывают сложную persistence-специфику, служат реальной изоляцией, а не декоративной прослойкой. Но если их основная задача — переименовать методы Prisma и создать ощущение правильной слоистости, то цена такого решения почти всегда выше пользы.

Если сформулировать главный практический вывод совсем прямо, он будет таким: в хорошем backend на NestJS + Prisma абстракция должна появляться там, где она добавляет язык и управляемость, а не там, где она просто спасает команду от тревоги, что прямой доступ к Prisma выглядит недостаточно “архитектурно”. Как только это принимается всерьез, код обычно становится не менее зрелым, а, наоборот, более честным. И это гораздо лучшая основа для роста системы, чем бесконечный слой репозиториев ради репозиториев.

Автор

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

Обновлено

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