Почему IT Smetanin не для новичков: что получит middle в проде
Открываю вчерашний PR. В контроллере — проверка статуса заказа, проверка прав пользователя и запись в базу. Всё в одном методе.
Код работает. Тест на основной сценарий проходит. Но я оставляю комментарий не к строке, а к самому решению:
Кто отвечает за то, что заказу разрешено перейти именно в этот статус?
Автор исправляет метод. Но вопрос остаётся: если завтра тот же переход понадобится мобильному приложению, админке или фоновой задаче, где разработчик найдёт правило? В контроллере? Скопирует проверку? Напишет ещё одну?
Это не лень. Часто разработчик просто решает текущую задачу и не видит, сколько других сценариев зависят от того же правила.
Коротко. IT Smetanin — для разработчиков, которые уже пишут боевой код и хотят увереннее принимать архитектурные решения, работать с границами модулей и понимать последствия изменений.
Одна проверка — несколько точек входа
У заказа есть статус. Допустимые переходы зависят от его текущего состояния: нельзя отправить неоплаченный заказ, нельзя отменить завершённый.
Пока заказом управляет один экран, проверку легко оставить рядом с обработчиком запроса. Но у живого продукта обычно больше одного входа.
Сначала проверки совпадают. Потом одно условие меняется в одном месте, а в остальных остаётся прежним. Сайт запрещает переход, приложение разрешает, админка обходит ограничение. Команда разбирает уже не одну ошибку, а расхождение между версиями одного бизнес-правила.
Я тоже так делал. В одном проекте проверка права на публикацию жила в контроллере. Через полгода появилась консольная команда для массовой публикации — и я скопировал ту же проверку туда. Ещё через месяц правило изменилось: публиковать мог не только автор, но и редактор. Контроллер я поправил, команду — забыл. Баг нашли пользователи.
Тогда я и задал себе вопрос: если правило изменится, сколько мест придётся исправить?
Правило разошлось.
Контроллер отвечает за запрос, а не за жизненный цикл заказа
Контроллеру есть чем заниматься: принять HTTP-запрос, проверить формат входных данных, вызвать сценарий и вернуть ответ. Ему не обязательно знать все условия, при которых заказ меняет статус.
На ревью я разделяю две вещи, которые часто смешивают:
- Права пользователя: имеет ли этот человек право выполнить действие?
- Правило предметной области: допустим ли такой переход для самого заказа?
Пользователь может иметь право управлять заказом, но конкретный переход всё равно запрещён состоянием заказа. И наоборот: переход может быть допустимым для заказа, но конкретному пользователю нельзя его выполнять.
Например, проверка перехода может выглядеть так:
Сам фрагмент ничего не решает, если canBeCancelled() проверяет только удобный для текущего экрана сценарий. Метод должен учитывать состояние заказа, а не то, откуда пришёл запрос.
Я не предлагаю создавать сервис, интерфейс и фабрику для каждого условия. Иногда дополнительный слой усложнит небольшой модуль сильнее, чем поможет. Архитектура — не соревнование по количеству классов.
Перед выделением отдельной ответственности я смотрю на три обстоятельства:
- правило используют несколько независимых сценариев;
- условия часто меняются;
- ошибка или расхождение между проверками дорого обходится продукту.
Если правило простое, используется в одном месте и почти не меняется, абстракция может оказаться лишней. Если от него зависят сайт, приложение, админка и фоновые процессы, оставлять четыре независимые проверки рискованно.
Не паттерн определяет границу. Её определяют связи и цена изменения.
Отмена заказа — это не только проверка статуса
Допустим, в задаче написано: «Добавить отмену заказа». Разработчик проверяет статус, добавляет кнопку и сохраняет новое значение. Основной сценарий работает.
Но в проде у этой операции есть продолжение.
Что произойдёт, если пользователь дважды нажмёт «Отменить»? Что вернёт API при повторном запросе? Может ли в это же время фоновая задача перевести заказ в другой статус? Что случится, если два запроса одновременно прочитают старое состояние?
Последний случай легко пропустить в обычном тесте.
Представим, что заказ оплачен. Почти одновременно приходят два запроса: один отменяет заказ, другой начинает его отправку. Оба процесса читают статус «Оплачен» и проверяют переход по одному и тому же исходному состоянию. Если система не защищает изменение от гонки, результат может зависеть от порядка записи.
Здесь уже недостаточно вынести canBeCancelled() в отдельный метод. Нужно решить, как система защищает переход:
- выполняет проверку и изменение в одной транзакции;
- блокирует запись на время операции, если это оправдано;
- проверяет версию или исходное состояние при сохранении;
- определяет, что делать со вторым запросом, если первый уже изменил заказ.
Конкретный механизм зависит от базы данных, нагрузки и требований к операции. Я не стал бы добавлять блокировки «на всякий случай». Но и оставлять конкурентные изменения без проверки нельзя, если они приводят к недопустимому состоянию заказа.
Есть ещё один контракт — ответ API. Повторная отмена может быть идемпотентной операцией, а может возвращать ошибку о недопустимом переходе. Оба варианта возможны, но клиент должен получать предсказуемый результат. Иначе мобильное приложение, сайт и админка начнут по-разному обрабатывать одну ситуацию.
Вот почему middle должен видеть не только условие в if, но и весь сценарий: от входного запроса до результата, который увидит пользователь.
Как обсуждать решение на ревью без вкусовщины
В команде может быть несколько сильных разработчиков, но каждый по-своему понимает, где должна находиться ответственность.
Один предлагает вынести проверку в сервис. Другой считает, что достаточно метода модели. Третий хочет добавить интерфейс, чтобы не зависеть от реализации. На ревью звучат знакомые аргументы: «так принято», «так чище», «потом пригодится».
Само по себе ни одно из этих предложений не доказывает, что решение подходит задаче.
Я возвращаю обсуждение к последствиям:
- Какое ограничение системы мы защищаем?
- Что изменится, если появится новый сценарий?
- Как проверить поведение без HTTP-запроса?
- Что произойдёт при повторном или параллельном запросе?
- Какой вариант будет проще изменить, когда появится новое требование?
Так команда обсуждает не любимые инструменты, а поведение системы. Иногда после такого разговора становится понятно, что нужен отдельный сценарий приложения. Иногда достаточно метода модели. Бывает и так, что предложенный раздутый класс ничего не упрощает — его лучше не создавать.
Общий язык не отменяет разногласий. Он позволяет проверить аргументы.
От принципов к работе с модулем
В IT Smetanin мы выстраиваем обучение от принципов к более крупным архитектурным решениям:
SOLID помогает увидеть, когда класс берёт на себя слишком много причин для изменения. Паттерны дают названия повторяющимся задачам проектирования и варианты их решения. Антипаттерны помогают распознавать решения, которые со временем усложняют систему: раздутые классы, дублирование правил, лишние зависимости.
MCDDP расширяет взгляд до модуля целиком: его данных, связей, сценариев и взаимодействия с остальной системой.
Я не хочу, чтобы после SOLID разработчик просто начал создавать больше интерфейсов и маленьких классов. Это легко превратить в новый ритуал: формально всё разделили, а менять систему стало труднее.
Паттерн тоже не должен становиться ответом до того, как сформулирована проблема. Сначала нужно понять, что меняется, кто зависит от этого изменения и какие ограничения система обязана сохранить. Только потом выбирать инструмент.
Практика: не переписывать весь репозиторий
Возьмите один модуль, с которым уже работаете. Например, заказы.
Не нужно сразу переносить все классы, вводить новые слои и менять структуру проекта. Выберите одно изменение, которое действительно предстоит сделать, и проследите его последствия.
| Уровень | Что проверить |
|---|---|
| Класс | Не смешивает ли он несколько причин для изменения |
| Зависимости | Не знает ли один компонент слишком много о других |
| Сценарий | Обрабатывает ли он повторные и недопустимые действия |
| Модуль | Понятно ли, какие правила он защищает и какие сценарии их используют |
| Границы системы | Не нарушает ли изменение контракт с другими частями приложения |
После этого сформулируйте решение словами: что вы меняете, почему ответственность находится именно здесь и какие риски закрываете.
Если после изменений стало больше классов — это ещё не результат. Если вы можете объяснить устройство модуля, показать ограничения и проверить поведение на важных сценариях, у решения есть инженерное обоснование.
Начните с небольшого изменения, которое всё равно предстоит сделать. Так проще увидеть цену старой структуры и не перепутать рефакторинг с перестановкой файлов.
С чего начать
Откройте сегодня один модуль, который часто меняется. Выберите одно правило и за 15–20 минут проследите, какие сценарии от него зависят, что может нарушить его работу и где придётся менять код при следующем требовании.
Пока ничего не переписывайте. Сначала найдите место, где решение перестаёт быть очевидным. Именно там стоит разбираться с ответственностью, зависимостями и компромиссами.
Сначала ясная граница. Потом рефакторинг.
Нужна помощь с архитектурой?
Расскажите о задаче — предложу реалистичный план по срокам и стеку.

