Как построить REST API с помощью JS, Node.js и Express.js¶

За последние несколько лет я создал и использовал множество API. За это время я сталкивался с хорошими и плохими практиками и переживал неприятные ситуации при использовании и создании API. Но были и замечательные моменты.

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

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

Именно поэтому я решил написать этот учебник. Я собрал все эти знания (хорошие и плохие) в одну статью, которая легко усваивается, и привел практический пример, которому можно следовать. В итоге мы создадим полноценный API, применяя одну лучшую практику за другой.

Прежде чем мы начнем, необходимо запомнить несколько моментов:

Лучшие практики - это, как вы уже догадались, не конкретные законы или правила, которым нужно следовать. Это условности или советы, которые сложились с течением времени и оказались эффективными. Некоторые из них уже стали стандартом. Но это не означает, что вы должны адаптировать их 1:1.

Они должны дать вам направление, чтобы сделать ваши API лучше с точки зрения пользовательского опыта (для потребителя и разработчика), безопасности и производительности.

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

Теперь, когда мы разобрались с этими вопросами, давайте приступим к работе!

Наш пример проекта¶

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

Мы создадим REST API для тренировочного приложения CrossFit. Если вы не знакомы с CrossFit, то это фитнес-метод и соревновательный вид спорта, сочетающий высокоинтенсивные тренировки с элементами нескольких видов спорта (олимпийской тяжелой атлетики, гимнастики и других).

В нашем приложении мы хотели бы создавать, читать, обновлять и удалять WOD (Workouts of the Day). Это поможет нашим пользователям (владельцам тренажерных залов) составлять планы тренировок и вести свои собственные тренировки в рамках одного приложения. Кроме того, они смогут добавлять важные советы по каждой тренировке.

Наша задача - разработать и реализовать API для этого приложения.

Необходимые условия¶

Для того чтобы продолжить работу, необходимо иметь некоторый опыт работы с JavaScript, Node.js, Express.js и архитектурой backend. Такие термины, как REST и API, не должны быть для вас новыми, и вы должны иметь представление о модели Клиент-Сервер.

Конечно, вы не обязаны быть экспертом в этих вопросах, но знакомства и, в идеале, некоторого опыта должно быть достаточно.

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

Несмотря на то, что данный API написан на JavaScript и Express, лучшие практики не ограничиваются этими инструментами. Они могут быть применены и к другим языкам программирования или фреймворкам.

Архитектура¶

Как уже говорилось выше, мы будем использовать Express.js для нашего API. Я не хочу придумывать сложную архитектуру, поэтому я хотел бы придерживаться трехслойной архитектуры:

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

Вся бизнес-логика будет находиться в Service Layer, который экспортирует определенные сервисы (методы), используемые контроллером.

Третий слой - это Слой доступа к данным, где мы будем работать с нашей базой данных. Мы будем экспортировать некоторые методы для определенных операций с базой данных, таких как создание WOD, которые могут быть использованы нашим сервисным слоем.

В нашем примере мы не будем использовать реальную базу данных, такую как MongoDB или PostgreSQL, поскольку я хотел бы сосредоточиться на лучших практиках. Поэтому мы используем локальный JSON-файл, который имитирует нашу базу данных. Но эту логику, конечно, можно перенести и на другие базы данных.

Базовая настройка¶

Теперь мы должны быть готовы создать базовую настройку для нашего API. Мы не будем усложнять и построим простую, но организованную структуру проекта.

Сначала создадим общую структуру папок со всеми необходимыми файлами и зависимостями. После этого проведем быстрый тест, чтобы проверить, все ли работает правильно:

1
2

# Create project folder & navigate into it
mkdir crossfit-wod-api && cd crossfit-wod-api

1
2

# Create a src folder & navigate into it
mkdir src && cd src

1
2

# Create sub folders
mkdir controllers && mkdir services && mkdir database && mkdir routes

1
2

# Create an index file (entry point of our API)
touch index.js

1
2
3
4
5

# We're currently in the src folder, so we need to move one level up first
cd ..

# Create package.json file
npm init -y

Установите зависимости для базовой установки:

1
2
3
4
5

# Dev Dependencies
npm i -D nodemon

# Dependencies
npm i express

Откройте проект в вашем любимом текстовом редакторе и настройте Express:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// In src/index.js
const express = require('express');

const app = express();
const PORT = process.env.PORT || 3000;

// For testing purposes
app.get('/', (req, res) => {
    res.send("<h2>It's Working!</h2>");
});

app.listen(PORT, () => {
    console.log(`API is listening on port ${PORT}`);
});

Интегрируйте новый скрипт под названием "dev " в файл package.json:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
    "name": "crossfit-wod-api",
    "version": "1.0.0",
    "description": "",
    "main": "index.js",
    "scripts": {
        "dev": "nodemon src/index.js"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "devDependencies": {
        "nodemon": "^2.0.15"
    },
    "dependencies": {
        "express": "^4.17.3"
    }
}

Сценарий обеспечивает автоматический перезапуск сервера разработки при внесении изменений (благодаря nodemon).

Запустите сервер разработки:

1

npm run dev

Посмотрите в терминал, там должно появиться сообщение о том, что "API прослушивает порт 3000".

Зайдите на localhost:3000 в браузере. Если все настроено правильно, вы должны увидеть следующее:

Отлично! Теперь у нас все готово для внедрения лучших практик.

REST API лучшие практики¶

Да! Теперь, когда у нас есть базовая настройка Express, мы можем расширить наш API с помощью следующих лучших практик.

Начнем с фундаментальных конечных точек CRUD. После этого мы будем расширять API с помощью каждой из лучших практик.

Версионирование¶

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

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

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

Текущая и новая версии, по сути, работают параллельно и не влияют друг на друга.

Но как отличить версии друг от друга? Одна из эффективных практик - добавление в URL сегмента пути, например v1 или v2.

1
2
3
4
5
6
7

// Version 1
'/api/v1/workouts';

// Version 2
'/api/v2/workouts';

// ...

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

Существует множество различных подходов к работе с версиями внутри Express API. В нашем случае я хотел бы создать внутри каталога src вложенную папку для каждой версии под названием v1.

1

mkdir src/v1

Теперь мы перенесем нашу папку routes в этот новый каталог v1.

1
2
3
4
5

# Get the path to your current directory (copy it)
pwd

# Move "routes" into "v1" (insert the path from above into {pwd})
mv {pwd}/src/routes {pwd}/src/v1

В новом каталоге /src/v1/routes будут храниться все наши маршруты для версии 1. Позже мы добавим "реальное" содержимое. А пока давайте добавим простой файл index.js для проверки.

1
2

# In /src/v1/routes
touch index.js

Внутри него мы запускаем простой маршрутизатор.

1
2
3
4
5
6
7
8
9

// In src/v1/routes/index.js
const express = require('express');
const router = express.Router();

router.route('/').get((req, res) => {
    res.send(`<h2>Hello from ${req.baseUrl}</h2>`);
});

module.exports = router;

Теперь нам нужно хукнуть наш маршрутизатор для v1 в корневой точке входа в src/index.js.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// In src/index.js
const express = require('express');
// *** ADD ***
const v1Router = require('./v1/routes');

const app = express();
const PORT = process.env.PORT || 3000;

// *** REMOVE ***
app.get('/', (req, res) => {
    res.send("<h2>It's Working!</h2>");
});

// *** ADD ***
app.use('/api/v1', v1Router);

app.listen(PORT, () => {
    console.log(`API is listening on port ${PORT}`);
});

Теперь посетите localhost:3000/api/v1 в браузере, и вы должны увидеть следующее:

Поздравляем! Вы только что структурировали проект для работы с различными версиями. Теперь мы передаем входящие запросы с "/api/v1" нашему маршрутизатору версии 1, который в дальнейшем будет направлять каждый запрос в соответствующий метод контроллера.

Прежде чем мы двинемся дальше, я хотел бы кое-что отметить.

Мы только что переместили папку routes в каталог v1. Остальные папки, такие как controllers или services, по-прежнему находятся в каталоге src. Пока что это нормально, поскольку мы создаем довольно небольшой API. Мы можем глобально использовать одни и те же контроллеры и сервисы в каждой версии.

Когда API будет расти и потребуются различные методы контроллеров, специфичные, например, для версии v2, будет лучше перенести папку controllers в каталог v2, чтобы вся логика, специфичная для этой версии, была инкапсулирована.

Другая причина может заключаться в том, что мы можем изменить сервис, который используется всеми остальными версиями. Мы не хотим ломать что-то в других версиях. Поэтому разумным решением будет перенести папку services также в папку конкретной версии.

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

Именование ресурсов во множественном числе¶

После настройки всего этого мы можем приступить к реальной реализации нашего API. Как я уже сказал, я хотел бы начать с наших фундаментальных конечных точек CRUD.

Другими словами, начнем реализовывать конечные точки для создания, чтения, обновления и удаления отработок.

Для начала давайте хукнем контроллер, сервис и маршрутизатор для наших тренировок.

1
2
3
4
5

touch src/controllers/workoutController.js

touch src/services/workoutService.js

touch src/v1/routes/workoutRoutes.js

Я всегда предпочитаю начинать с маршрутов. Давайте подумаем, как назвать наши конечные точки. Это связано с конкретной лучшей практикой.

Мы можем назвать конечную точку создания /api/v1/workout, потому что мы хотим добавить одну тренировку, верно? В принципе, в таком подходе нет ничего плохого - но это может привести к недоразумениям.

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

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

Именование ресурсов во множественном числе имеет то преимущество, что другим людям совершенно ясно, что это коллекция, состоящая из различных тренировок.

Итак, давайте определим конечные точки внутри нашего маршрутизатора тренировок.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// In src/v1/routes/workoutRoutes.js
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
    res.send('Get all workouts');
});

router.get('/:workoutId', (req, res) => {
    res.send('Get an existing workout');
});

router.post('/', (req, res) => {
    res.send('Create a new workout');
});

router.patch('/:workoutId', (req, res) => {
    res.send('Update an existing workout');
});

router.delete('/:workoutId', (req, res) => {
    res.send('Delete an existing workout');
});

module.exports = router;

Вы можете удалить наш тестовый файл index.js внутри src/v1/routes.

Теперь перейдем к нашей точке входа и подключим наш маршрутизатор v1.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// In src/index.js
const express = require('express');
// *** REMOVE ***
const v1Router = require('./v1/routes');
// *** ADD ***
const v1WorkoutRouter = require('./v1/routes/workoutRoutes');

const app = express();
const PORT = process.env.PORT || 3000;

// *** REMOVE ***
app.use('/api/v1', v1Router);

// *** ADD ***
app.use('/api/v1/workouts', v1WorkoutRouter);

app.listen(PORT, () => {
    console.log(`API is listening on port ${PORT}`);
});

Все прошло гладко, верно? Теперь мы перехватываем все запросы, идущие к /api/v1/workouts, с помощью нашего маршрутизатора v1WorkoutRouter.

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

Давайте создадим метод для каждой конечной точки. Пока достаточно просто отправить сообщение.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// In src/controllers/workoutController.js
const getAllWorkouts = (req, res) => {
    res.send('Get all workouts');
};

const getOneWorkout = (req, res) => {
    res.send('Get an existing workout');
};

const createNewWorkout = (req, res) => {
    res.send('Create a new workout');
};

const updateOneWorkout = (req, res) => {
    res.send('Update an existing workout');
};

const deleteOneWorkout = (req, res) => {
    res.send('Delete an existing workout');
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Теперь пришло время немного рефакторить наш маршрутизатор и использовать методы контроллера.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// In src/v1/routes/workoutRoutes.js
const express = require('express');
const workoutController = require('../../controllers/workoutController');

const router = express.Router();

router.get('/', workoutController.getAllWorkouts);

router.get('/:workoutId', workoutController.getOneWorkout);

router.post('/', workoutController.createNewWorkout);

router.patch(
    '/:workoutId',
    workoutController.updateOneWorkout
);

router.delete(
    '/:workoutId',
    workoutController.deleteOneWorkout
);

module.exports = router;

Теперь мы можем протестировать нашу конечную точку GET /api/v1/workouts/:workoutId, набрав в браузере localhost:3000/api/v1/workouts/2342. Вы должны увидеть нечто подобное:

Мы сделали это! Первый слой нашей архитектуры готов. Давайте создадим наш сервисный слой, реализовав следующую лучшую практику.

Принимать и отвечать данными в формате JSON¶

Взаимодействуя с API, вы всегда отправляете определенные данные с запросом или получаете их в ответ. Существует множество различных форматов данных, но JSON (Javascript Object Notation) является стандартизованным форматом.

Хотя в JSON присутствует термин JavaScript, он не привязан конкретно к нему. Вы также можете написать свой API на Java или Python, который также может работать с JSON.

В силу своей стандартизации API должны принимать данные в формате JSON и отвечать на них.

Давайте рассмотрим нашу текущую реализацию и посмотрим, как мы можем интегрировать эту лучшую практику.

Сначала мы создадим наш сервисный слой.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// In src/services/workoutService.js
const getAllWorkouts = () => {
    return;
};

const getOneWorkout = () => {
    return;
};

const createNewWorkout = () => {
    return;
};

const updateOneWorkout = () => {
    return;
};

const deleteOneWorkout = () => {
    return;
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Также рекомендуется называть методы сервиса так же, как и методы контроллера, чтобы между ними была связь. Начнем с того, что мы просто ничего не возвращаем.

Внутри нашего контроллера workout мы можем использовать эти методы.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

// In src/controllers/workoutController.js
// *** ADD ***
const workoutService = require('../services/workoutService');

const getAllWorkouts = (req, res) => {
    // *** ADD ***
    const allWorkouts = workoutService.getAllWorkouts();
    res.send('Get all workouts');
};

const getOneWorkout = (req, res) => {
    // *** ADD ***
    const workout = workoutService.getOneWorkout();
    res.send('Get an existing workout');
};

const createNewWorkout = (req, res) => {
    // *** ADD ***
    const createdWorkout = workoutService.createNewWorkout();
    res.send('Create a new workout');
};

const updateOneWorkout = (req, res) => {
    // *** ADD ***
    const updatedWorkout = workoutService.updateOneWorkout();
    res.send('Update an existing workout');
};

const deleteOneWorkout = (req, res) => {
    // *** ADD ***
    workoutService.deleteOneWorkout();
    res.send('Delete an existing workout');
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

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

Внутри сервисных методов мы будем обрабатывать бизнес-логику, например, преобразовывать структуры данных и взаимодействовать со слоем баз данных.

Для этого нам нужна база данных и набор методов, которые, собственно, и обеспечивают взаимодействие с базой данных. Наша база данных будет представлять собой простой JSON-файл, предварительно заполненный некоторыми отработками.

1
2
3
4
5

# Create a new file called db.json inside src/database
touch src/database/db.json

# Create a Workout File that stores all workout specific methods in /src/database
touch src/database/Workout.js

Скопируйте в файл db.json следующее:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

{
    "workouts": [
        {
            "id": "61dbae02-c147-4e28-863c-db7bd402b2d6",
            "name": "Tommy V",
            "mode": "For Time",
            "equipment": ["barbell", "rope"],
            "exercises": [
                "21 thrusters",
                "12 rope climbs, 15 ft",
                "15 thrusters",
                "9 rope climbs, 15 ft",
                "9 thrusters",
                "6 rope climbs, 15 ft"
            ],
            "createdAt": "4/20/2022, 2:21:56 PM",
            "updatedAt": "4/20/2022, 2:21:56 PM",
            "trainerTips": [
                "Split the 21 thrusters as needed",
                "Try to do the 9 and 6 thrusters unbroken",
                "RX Weights: 115lb/75lb"
            ]
        },
        {
            "id": "4a3d9aaa-608c-49a7-a004-66305ad4ab50",
            "name": "Dead Push-Ups",
            "mode": "AMRAP 10",
            "equipment": ["barbell"],
            "exercises": [
                "15 deadlifts",
                "15 hand-release push-ups"
            ],
            "createdAt": "1/25/2022, 1:15:44 PM",
            "updatedAt": "3/10/2022, 8:21:56 AM",
            "trainerTips": [
                "Deadlifts are meant to be light and fast",
                "Try to aim for unbroken sets",
                "RX Weights: 135lb/95lb"
            ]
        },
        {
            "id": "d8be2362-7b68-4ea4-a1f6-03f8bc4eede7",
            "name": "Heavy DT",
            "mode": "5 Rounds For Time",
            "equipment": ["barbell", "rope"],
            "exercises": [
                "12 deadlifts",
                "9 hang power cleans",
                "6 push jerks"
            ],
            "createdAt": "11/20/2021, 5:39:07 PM",
            "updatedAt": "11/20/2021, 5:39:07 PM",
            "trainerTips": [
                "Aim for unbroken push jerks",
                "The first three rounds might feel terrible, but stick to it",
                "RX Weights: 205lb/145lb"
            ]
        }
    ]
}

Как видно, здесь вставлены три тренировки. Одна тренировка состоит из id, name, mode, equipment, exercises, createdAt, updatedAt и trainerTips.

Начнем с самого простого - вернем все тренировки, которые хранятся в памяти, и приступим к реализации соответствующего метода в нашем Data Access Layer (src/database/Workout.js).

Опять же, я решил назвать метод здесь так же, как и в сервисе и контроллере. Но это совершенно необязательно.

1
2
3
4
5
6
7
8

// In src/database/Workout.js
const DB = require('./db.json');

const getAllWorkouts = () => {
    return DB.workouts;
};

module.exports = { getAllWorkouts };

Вернитесь в наш сервис тренировок и реализуйте логику для getAllWorkouts.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// In src/database/workoutService.js
// *** ADD ***
const Workout = require('../database/Workout');
const getAllWorkouts = () => {
    // *** ADD ***
    const allWorkouts = Workout.getAllWorkouts();
    // *** ADD ***
    return allWorkouts;
};

const getOneWorkout = () => {
    return;
};

const createNewWorkout = () => {
    return;
};

const updateOneWorkout = () => {
    return;
};

const deleteOneWorkout = () => {
    return;
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Возврат всех вычислений довольно прост, и нам не нужно выполнять преобразования, поскольку это уже JSON-файл. Нам также пока не нужно принимать никаких аргументов. Таким образом, эта реализация довольно проста. Но мы вернемся к этому позже.

Вернувшись в контроллер тренировок, мы получаем возвращаемое значение из workoutService.getAllWorkouts() и просто отправляем его в качестве ответа клиенту. Мы передали ответ базы данных через наш сервис в контроллер.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// In src/controllers/workoutControllers.js
const workoutService = require('../services/workoutService');

const getAllWorkouts = (req, res) => {
    const allWorkouts = workoutService.getAllWorkouts();
    // *** ADD ***
    res.send({ status: 'OK', data: allWorkouts });
};

const getOneWorkout = (req, res) => {
    const workout = workoutService.getOneWorkout();
    res.send('Get an existing workout');
};

const createNewWorkout = (req, res) => {
    const createdWorkout = workoutService.createNewWorkout();
    res.send('Create a new workout');
};

const updateOneWorkout = (req, res) => {
    const updatedWorkout = workoutService.updateOneWorkout();
    res.send('Update an existing workout');
};

const deleteOneWorkout = (req, res) => {
    workoutService.deleteOneWorkout();
    res.send('Delete an existing workout');
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Перейдите по адресу localhost:3000/api/v1/workouts в браузере, и вы увидите JSON-ответ.

Все прошло отлично! Мы отправляем данные в формате JSON. Но как быть с его приемом? Давайте подумаем, в какой конечной точке нам нужно получить от клиента данные в формате JSON. Конечная точка для создания или обновления тренировки нуждается в данных от клиента.

Внутри нашего контроллера тренировок мы извлекаем тело запроса на создание новой тренировки и передаем его в сервис тренировок. Внутри сервиса workout мы вставим его в наш DB.json и отправим созданную тренировку обратно клиенту.

Чтобы иметь возможность разобрать присланный JSON внутри тела запроса, нам необходимо сначала установить body-parser и настроить его.

1

npm i body-parser

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// In src/index.js
const express = require('express');
// *** ADD ***
const bodyParser = require('body-parser');
const v1WorkoutRouter = require('./v1/routes/workoutRoutes');

const app = express();
const PORT = process.env.PORT || 3000;

// *** ADD ***
app.use(bodyParser.json());
app.use('/api/v1/workouts', v1WorkoutRouter);

app.listen(PORT, () => {
    console.log(`API is listening on port ${PORT}`);
});

Теперь мы можем получать JSON-данные внутри наших контроллеров в req.body.

Для того чтобы проверить это, просто откройте ваш любимый HTTP-клиент (я использую Postman), создайте POST-запрос на localhost:3000/api/v1/workouts и тело запроса в формате JSON, как показано ниже:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

{
  "name": "Core Buster",
  "mode": "AMRAP 20",
  "equipment": [
    "rack",
    "barbell",
    "abmat"
  ],
  "exercises": [
    "15 toes to bars",
    "10 thrusters",
    "30 abmat sit-ups"
  ],
  "trainerTips": [
    "Split your toes to bars into two sets maximum",
    "Go unbroken on the thrusters",
    "Take the abmat sit-ups as a chance to normalize your breath"
  ]
}

Как вы могли заметить, некоторые свойства, такие как "id", "createdAt" и "updatedAt", отсутствуют. Это задача нашего API - добавить эти свойства перед вставкой. Мы позаботимся об этом в нашем сервисе тренировок позже.

Внутри метода createNewWorkout нашего контроллера тренировок мы можем извлечь тело из объекта запроса, выполнить некоторую проверку и передать его в качестве аргумента нашему сервису тренировок.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

// In src/controllers/workoutController.js
// ...

const createNewWorkout = (req, res) => {
    const { body } = req;
    // *** ADD ***
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        return;
    }
    // *** ADD ***
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    // *** ADD ***
    const createdWorkout = workoutService.createNewWorkout(
        newWorkout
    );
    // *** ADD ***
    res.status(201).send({
        status: 'OK',
        data: createdWorkout,
    });
};

// ...

Для улучшения проверки запросов обычно используется сторонний пакет, например express-validator.

Перейдем в наш сервис тренировок и получим данные в методе createNewWorkout.

После этого добавим к объекту недостающие свойства и передадим его новому методу в нашем слое доступа к данным, чтобы сохранить его в нашей БД.

Сначала мы создадим простую функцию Util Function для перезаписи нашего JSON-файла, чтобы сохранить данные.

1
2

# Create a utils file inside our database directory
touch src/database/utils.js

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// In src/database/utils.js
const fs = require('fs');

const saveToDatabase = (DB) => {
    fs.writeFileSync(
        './src/database/db.json',
        JSON.stringify(DB, null, 2),
        {
            encoding: 'utf-8',
        }
    );
};

module.exports = { saveToDatabase };

Затем мы можем использовать эту функцию в нашем файле Workout.js.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// In src/database/Workout.js
const DB = require('./db.json');
// *** ADD ***
const { saveToDatabase } = require('./utils');

const getAllWorkouts = () => {
    return DB.workouts;
};

// *** ADD ***
const createNewWorkout = (newWorkout) => {
    const isAlreadyAdded =
        DB.workouts.findIndex(
            (workout) => workout.name === newWorkout.name
        ) > -1;
    if (isAlreadyAdded) {
        return;
    }
    DB.workouts.push(newWorkout);
    saveToDatabase(DB);
    return newWorkout;
};

module.exports = {
    getAllWorkouts,
    // *** ADD ***
    createNewWorkout,
};

Все прошло гладко! Следующий шаг - использование методов базы данных внутри нашего сервиса workout.

1
2

# Install the uuid package
npm i uuid

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// In src/services/workoutService.js
// *** ADD ***
const { v4: uuid } = require('uuid');
// *** ADD ***
const Workout = require('../database/Workout');

const getAllWorkouts = () => {
    const allWorkouts = Workout.getAllWorkouts();
    return allWorkouts;
};

const getOneWorkout = () => {
    return;
};

const createNewWorkout = (newWorkout) => {
    // *** ADD ***
    const workoutToInsert = {
        ...newWorkout,
        id: uuid(),
        createdAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    // *** ADD ***
    const createdWorkout = Workout.createNewWorkout(
        workoutToInsert
    );
    return createdWorkout;
};

const updateOneWorkout = () => {
    return;
};

const deleteOneWorkout = () => {
    return;
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Ух ты! Это было весело, правда? Теперь вы можете обратиться к своему HTTP-клиенту, снова отправить POST-запрос, и вы должны получить только что созданную тренировку в формате JSON.

Если вы попытаетесь добавить ту же тренировку во второй раз, то получите код состояния 201, но без новой вставленной тренировки.

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

Теперь отправим GET-запрос на localhost:3000/api/v1/workouts, чтобы прочитать все тренировки. Я выбираю для этого браузер. Вы должны увидеть, что наша тренировка успешно вставлена и сохранена:

Остальные методы вы можете реализовать самостоятельно или просто скопировать мои реализации.

Сначала контроллер тренировки (можно просто скопировать все содержимое):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// In src/controllers/workoutController.js
const workoutService = require('../services/workoutService');

const getAllWorkouts = (req, res) => {
    const allWorkouts = workoutService.getAllWorkouts();
    res.send({ status: 'OK', data: allWorkouts });
};

const getOneWorkout = (req, res) => {
    const {
        params: { workoutId },
    } = req;
    if (!workoutId) {
        return;
    }
    const workout = workoutService.getOneWorkout(workoutId);
    res.send({ status: 'OK', data: workout });
};

const createNewWorkout = (req, res) => {
    const { body } = req;
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        return;
    }
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    const createdWorkout = workoutService.createNewWorkout(
        newWorkout
    );
    res.status(201).send({
        status: 'OK',
        data: createdWorkout,
    });
};

const updateOneWorkout = (req, res) => {
    const {
        body,
        params: { workoutId },
    } = req;
    if (!workoutId) {
        return;
    }
    const updatedWorkout = workoutService.updateOneWorkout(
        workoutId,
        body
    );
    res.send({ status: 'OK', data: updatedWorkout });
};

const deleteOneWorkout = (req, res) => {
    const {
        params: { workoutId },
    } = req;
    if (!workoutId) {
        return;
    }
    workoutService.deleteOneWorkout(workoutId);
    res.status(204).send({ status: 'OK' });
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Затем - сервис тренировки (можно просто скопировать все содержимое):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// In src/services/workoutServices.js
const { v4: uuid } = require('uuid');
const Workout = require('../database/Workout');

const getAllWorkouts = () => {
    const allWorkouts = Workout.getAllWorkouts();
    return allWorkouts;
};

const getOneWorkout = (workoutId) => {
    const workout = Workout.getOneWorkout(workoutId);
    return workout;
};

const createNewWorkout = (newWorkout) => {
    const workoutToInsert = {
        ...newWorkout,
        id: uuid(),
        createdAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    const createdWorkout = Workout.createNewWorkout(
        workoutToInsert
    );
    return createdWorkout;
};

const updateOneWorkout = (workoutId, changes) => {
    const updatedWorkout = Workout.updateOneWorkout(
        workoutId,
        changes
    );
    return updatedWorkout;
};

const deleteOneWorkout = (workoutId) => {
    Workout.deleteOneWorkout(workoutId);
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

И, наконец, методы нашей базы данных внутри Data Access Layer (можно просто скопировать все содержимое):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

// In src/database/Workout.js
const DB = require('./db.json');
const { saveToDatabase } = require('./utils');

const getAllWorkouts = () => {
    return DB.workouts;
};

const getOneWorkout = (workoutId) => {
    const workout = DB.workouts.find(
        (workout) => workout.id === workoutId
    );
    if (!workout) {
        return;
    }
    return workout;
};

const createNewWorkout = (newWorkout) => {
    const isAlreadyAdded =
        DB.workouts.findIndex(
            (workout) => workout.name === newWorkout.name
        ) > -1;
    if (isAlreadyAdded) {
        return;
    }
    DB.workouts.push(newWorkout);
    saveToDatabase(DB);
    return newWorkout;
};

const updateOneWorkout = (workoutId, changes) => {
    const indexForUpdate = DB.workouts.findIndex(
        (workout) => workout.id === workoutId
    );
    if (indexForUpdate === -1) {
        return;
    }
    const updatedWorkout = {
        ...DB.workouts[indexForUpdate],
        ...changes,
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    DB.workouts[indexForUpdate] = updatedWorkout;
    saveToDatabase(DB);
    return updatedWorkout;
};

const deleteOneWorkout = (workoutId) => {
    const indexForDeletion = DB.workouts.findIndex(
        (workout) => workout.id === workoutId
    );
    if (indexForDeletion === -1) {
        return;
    }
    DB.workouts.splice(indexForDeletion, 1);
    saveToDatabase(DB);
};

module.exports = {
    getAllWorkouts,
    createNewWorkout,
    getOneWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};

Отлично! Давайте перейдем к следующей лучшей практике и посмотрим, как правильно обрабатывать ошибки.

Отвечать стандартными кодами ошибок HTTP¶

Мы зашли уже довольно далеко, но еще не закончили. Теперь наш API способен выполнять базовые CRUD-операции с хранением данных. Это замечательно, но не совсем идеально.

Почему? Сейчас объясню.

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

Вам, наверное, знакомо это странное чувство, когда все работает с самого начала без каких-либо ошибок. Это здорово и приятно, но как разработчики мы больше привыкли к тому, что все работает неправильно. 😁

То же самое относится и к нашему API. Мы должны обрабатывать определенные случаи, которые могут пойти не так, как надо, или привести к ошибке. Это также повысит надежность нашего API.

Когда что-то идет не так (либо в запросе, либо внутри нашего API), мы отправляем обратно коды ошибок HTTP. Я видел и использовал API, которые постоянно возвращали код ошибки 400, когда запрос был ошибочным, без какого-либо конкретного сообщения о том, ПОЧЕМУ произошла эта ошибка или в чем она заключалась. Поэтому отладка становилась мучением.

Именно поэтому хорошей практикой является возврат соответствующих кодов ошибок HTTP для различных случаев. Это помогает потребителю или инженеру, создавшему API, легче определить проблему.

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

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

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

Начнем с метода createNewWorkout внутри нашего контроллера тренировок:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// In src/controllers/workoutController.js
// ...

const createNewWorkout = (req, res) => {
    const { body } = req;
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        return;
    }
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    const createdWorkout = workoutService.createNewWorkout(
        newWorkout
    );
    res.status(201).send({
        status: 'OK',
        data: createdWorkout,
    });
};

// ...

Мы уже отловили случай, когда тело запроса построено неправильно и в нем отсутствуют ожидаемые нами ключи.

Это хороший пример для отправки в ответ HTTP-ошибки 400 с соответствующим сообщением об ошибке.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// In src/controllers/workoutController.js
// ...

const createNewWorkout = (req, res) => {
    const { body } = req;
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "One of the following keys is missing or is empty in request body: 'name', 'mode', 'equipment', 'exercises', 'trainerTips'",
            },
        });
        return;
    }
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    const createdWorkout = workoutService.createNewWorkout(
        newWorkout
    );
    res.status(201).send({
        status: 'OK',
        data: createdWorkout,
    });
};

// ...

Если мы попытаемся добавить новую тренировку, но забудем указать свойство "mode" в теле запроса, то увидим сообщение об ошибке вместе с кодом ошибки 400 HTTP.

Разработчик, использующий API, теперь лучше осведомлен о том, на что следует обратить внимание. Он сразу понимает, что нужно зайти в тело запроса и посмотреть, не пропустил ли он одно из необходимых свойств.

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// In src/services/workoutService.js
// ...

const createNewWorkout = (newWorkout) => {
    const workoutToInsert = {
        ...newWorkout,
        id: uuid(),
        createdAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    const createdWorkout = Workout.createNewWorkout(
        workoutToInsert
    );
    return createdWorkout;
};

// ...

Одна вещь, которая может пойти не так, - это вставка в базу данных Workout.createNewWorkout(). Я предпочитаю обернуть этот процесс в блок try/catch, чтобы поймать ошибку, когда она произойдет.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// In src/services/workoutService.js
// ...

const createNewWorkout = (newWorkout) => {
    const workoutToInsert = {
        ...newWorkout,
        id: uuid(),
        createdAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    try {
        const createdWorkout = Workout.createNewWorkout(
            workoutToInsert
        );
        return createdWorkout;
    } catch (error) {
        throw error;
    }
};

// ...

Каждая ошибка, возникающая в методе Workout.createNewWorkout(), будет перехвачена в нашем блоке catch. Мы просто возвращаем ее обратно, чтобы позже скорректировать наши ответы внутри контроллера.

Давайте определим наши ошибки в файле Workout.js:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// In src/database/Workout.js
// ...

const createNewWorkout = (newWorkout) => {
    const isAlreadyAdded =
        DB.workouts.findIndex(
            (workout) => workout.name === newWorkout.name
        ) > -1;
    if (isAlreadyAdded) {
        throw {
            status: 400,
            message: `Workout with the name '${newWorkout.name}' already exists`,
        };
    }
    try {
        DB.workouts.push(newWorkout);
        saveToDatabase(DB);
        return newWorkout;
    } catch (error) {
        throw {
            status: 500,
            message: error?.message || error,
        };
    }
};

// ...

Как видно, ошибка состоит из двух частей - статуса и сообщения. Я использую здесь только ключевое слово throw, чтобы передать не строку, а другую структуру данных, которая требуется в throw new Error().

Небольшим недостатком простого отбрасывания является то, что мы не получаем трассировку стека. Но обычно отбрасыванием ошибок занимается сторонняя библиотека по нашему выбору (например, Mongoose, если вы используете базу данных MongoDB). Но для целей данного руководства это вполне достаточно.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// In src/controllers/workoutController.js
// ...

const createNewWorkout = (req, res) => {
    const { body } = req;
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "One of the following keys is missing or is empty in request body: 'name', 'mode', 'equipment', 'exercises', 'trainerTips'",
            },
        });
        return;
    }
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    // *** ADD ***
    try {
        const createdWorkout = workoutService.createNewWorkout(
            newWorkout
        );
        res.status(201).send({
            status: 'OK',
            data: createdWorkout,
        });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

// ...

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

Чтобы закончить эту тему и перейти к следующему совету, вы можете скопировать остальные реализованные методы в следующие файлы или попробовать сделать это самостоятельно:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// In src/controllers/workoutController.js
const workoutService = require('../services/workoutService');

const getAllWorkouts = (req, res) => {
    try {
        const allWorkouts = workoutService.getAllWorkouts();
        res.send({ status: 'OK', data: allWorkouts });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

const getOneWorkout = (req, res) => {
    const {
        params: { workoutId },
    } = req;
    if (!workoutId) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "Parameter ':workoutId' can not be empty",
            },
        });
    }
    try {
        const workout = workoutService.getOneWorkout(
            workoutId
        );
        res.send({ status: 'OK', data: workout });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

const createNewWorkout = (req, res) => {
    const { body } = req;
    if (
        !body.name ||
        !body.mode ||
        !body.equipment ||
        !body.exercises ||
        !body.trainerTips
    ) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "One of the following keys is missing or is empty in request body: 'name', 'mode', 'equipment', 'exercises', 'trainerTips'",
            },
        });
        return;
    }
    const newWorkout = {
        name: body.name,
        mode: body.mode,
        equipment: body.equipment,
        exercises: body.exercises,
        trainerTips: body.trainerTips,
    };
    try {
        const createdWorkout = workoutService.createNewWorkout(
            newWorkout
        );
        res.status(201).send({
            status: 'OK',
            data: createdWorkout,
        });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

const updateOneWorkout = (req, res) => {
    const {
        body,
        params: { workoutId },
    } = req;
    if (!workoutId) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "Parameter ':workoutId' can not be empty",
            },
        });
    }
    try {
        const updatedWorkout = workoutService.updateOneWorkout(
            workoutId,
            body
        );
        res.send({ status: 'OK', data: updatedWorkout });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

const deleteOneWorkout = (req, res) => {
    const {
        params: { workoutId },
    } = req;
    if (!workoutId) {
        res.status(400).send({
            status: 'FAILED',
            data: {
                error:
                    "Parameter ':workoutId' can not be empty",
            },
        });
    }
    try {
        workoutService.deleteOneWorkout(workoutId);
        res.status(204).send({ status: 'OK' });
    } catch (error) {
        res.status(error?.status || 500).send({
            status: 'FAILED',
            data: { error: error?.message || error },
        });
    }
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
    getRecordsForWorkout,
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// In src/services/workoutService.js
const { v4: uuid } = require('uuid');
const Workout = require('../database/Workout');

const getAllWorkouts = () => {
    try {
        const allWorkouts = Workout.getAllWorkouts();
        return allWorkouts;
    } catch (error) {
        throw error;
    }
};

const getOneWorkout = (workoutId) => {
    try {
        const workout = Workout.getOneWorkout(workoutId);
        return workout;
    } catch (error) {
        throw error;
    }
};

const createNewWorkout = (newWorkout) => {
    const workoutToInsert = {
        ...newWorkout,
        id: uuid(),
        createdAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
        updatedAt: new Date().toLocaleString('en-US', {
            timeZone: 'UTC',
        }),
    };
    try {
        const createdWorkout = Workout.createNewWorkout(
            workoutToInsert
        );
        return createdWorkout;
    } catch (error) {
        throw error;
    }
};

const updateOneWorkout = (workoutId, changes) => {
    try {
        const updatedWorkout = Workout.updateOneWorkout(
            workoutId,
            changes
        );
        return updatedWorkout;
    } catch (error) {
        throw error;
    }
};

const deleteOneWorkout = (workoutId) => {
    try {
        Workout.deleteOneWorkout(workoutId);
    } catch (error) {
        throw error;
    }
};

module.exports = {
    getAllWorkouts,
    getOneWorkout,
    createNewWorkout,
    updateOneWorkout,
    deleteOneWorkout,
};