Паспорт нод: Паспорт НОД по художественно – зстетическому развитию “Золотая Осень” в старшей группе.

 9003..."
AUTH0_DOMAIN="..."
AUTH0_CLIENT_SECRET="..."
SESSION_SECRET=
AUTH0_CALLBACK_URL=http://localhost:3000/callback  

🛠️ Выполните следующую команду, чтобы сгенерировать подходящую строку для секрета сеанса:

  node -e "console.log(crypto.randomBytes(32).toString('hex'))"  

🛠️ Скопируйте и вставьте вывод команды выше как значение для SESSION_SECRET в . env .

Вы узнаете, что AUTH0_CALLBACK_URL делает для вашего приложения после того, как вы настроите Passport.js в следующем разделе.

🛠️ Перезапустите сервер, работающий на порту 8000 , чтобы Express мог распознать эти новые переменные. Затем обновите страницу, на которой работает пользовательский интерфейс. .

Кроме того, когда ваше приложение работает как рабочий экземпляр, вы будете отправлять файлы cookie только через HTTPS:

  if (app.get("env") === "production") {
  
  session.cookie.secure = истина;
}  

Если для параметра session.cookie.secure задано значение true , совместимые клиенты не будут отправлять файлы cookie обратно на сервер, если браузер не имеет соединения HTTPS. Таким образом, для использования безопасных файлов cookie требуется веб-сайт с поддержкой HTTPS.

🛠️️ Далее, в разделе Конфигурация приложения , скажите своему приложению Express использовать expressSession с только что созданным объектом session :

 



приложение. set("views", path.join(__dirname, "views"));
app.set("движок просмотра", "мопс");
app.use(express.static(path.join(__dirname, "public")));

app.use (expressSession (сеанс));  

🛠️️ После настройки промежуточного программного обеспечения сеанса вы готовы добавить и настроить Passport.js в своем приложении.

Настройте Passport с помощью параметров приложения

В этом разделе вы сосредоточитесь на подключении Passport.js к вашему приложению Express.

🛠️️ Импортировав Auth0Strategy , перейдите к определению этой стратегии в разделе Passport Configuration в указателе .js :

 



константная стратегия = новая Auth0Strategy(
  {
    домен: процесс.env.AUTH0_DOMAIN,
    идентификатор клиента: process.env.AUTH0_CLIENT_ID,
    clientSecret: процесс.env.AUTH0_CLIENT_SECRET,
    callbackURL: process.env.AUTH0_CALLBACK_URL
  },
  function(accessToken, refreshToken, extraParams, profile, done) {
    
    вернуть готово (ноль, профиль);
  }
);  

Здесь метод Auth0Strategy принимает ваши учетные данные Auth0 и инициализирует стратегию. Важно понимать, что делает для вас Auth0Strategy :

1. Функция обратного вызова, переданная методу Auth0Strategy , известна как обратный вызов Verification , целью которого является поиск пользователя, обладающего набором реквизиты для входа.

2. Когда Passport.js проверяет подлинность запроса, он анализирует учетные данные или любую другую информацию для проверки подлинности, содержащуюся в запросе.

3. Затем он вызывает обратный вызов Verify с данными аутентификации в качестве аргументов, в данном случае accessToken , refreshToken , extraParams и profile .

4. Поскольку Passport.js является промежуточной функцией, обратный вызов Verify также получает done в качестве аргумента для передачи управления следующей промежуточной функции.

5. Поскольку Auth0 выполняет всю проверку учетных данных за вас, обратный вызов Verify вызывает done для предоставления в Passport пользователя, который прошел аутентификацию через объект профиля .

🛠️️ После определения стратегии вам нужно, чтобы Passport.js использовал ее. В приложениях Express вам также необходимо инициализировать Passport и изменить постоянный сеанс входа в систему с помощью Passport и метода app.use() из Express.Для выполнения этих задач обновите раздел App Configuration в index.js следующим образом:

 

app.set("представления", path.join(__dirname, "представления"));
app.set("движок просмотра", "мопс");
app.use(express.static(path.join(__dirname, "public")));

app.use (expressSession (сеанс));

паспорт.использование(стратегия);
app.use(passport.initialize());
app.use(passport.session());  

После привязки промежуточного программного обеспечения express-session expressSession(session(session) к промежуточному программному обеспечению уровня приложения необходимо убедиться, что passport.initialize() и passion. session() добавлены.

Хранение и извлечение пользовательских данных из сеанса

🛠️️ Последний шаг в настройке Passport.js — поддержка сеансов входа в систему путем сериализации и десериализации экземпляров пользователей в сеансе и из него. Чтобы интегрировать эту функцию, еще раз обновите раздел App Configuration следующим образом:

 .



app.set("представления", path.join(__dirname, "представления"));
app.set("движок просмотра", "мопс");
app.use(express.static(path.join(__dirname, "public")));

app.use (expressSession (сеанс));

паспорт.использование (стратегия);
app.use(passport.initialize());
app.use(passport.session());

паспорт.serializeUser((пользователь, готово) => {
  сделано (ноль, пользователь);
});

паспорт.deserializeUser((пользователь, готово) => {
  сделано (ноль, пользователь);
});  

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

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

«Несмотря на сложности, связанные с аутентификацией, код не должен быть сложным. Это философия Passport.js, которая предоставляет простое, ненавязчивое промежуточное ПО для аутентификации для Node.js»

Tweet This

Создание конечных точек экспресс-аутентификации

🛠️️ В этом разделе вы создадите три конечные точки, которые обрабатывают поток аутентификации приложения:

  GET /login.

ПОЛУЧИТЬ /выйти

GET /callback  

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

🛠️️ Для начала создайте файл auth.js в каталоге проекта.

  touch auth.js  

Заполните его этим шаблоном, чтобы определить его структуру:

🛠️️ Затем добавьте следующее в раздел Required External Modules , чтобы импортировать необходимые пакеты и загрузить переменные среды:

 



константный экспресс = требуется ("экспресс");
const router = express.Router();
const паспорт = требовать("паспорт");
const строка_запроса = требуется("строка_запроса");

требуют("дотенв").конфиг();  

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

• маршрутизатор : Объект маршрутизатора — это изолированный экземпляр промежуточного программного обеспечения и маршрутов. Он способен выполнять только промежуточное ПО и функции маршрутизации. Каждое приложение Express имеет встроенный маршрутизатор приложений.

• util : этот модуль предназначен для поддержки внутренних API-интерфейсов Node. js, предоставляя полезные служебные функции для выполнения таких задач, как форматирование и кодирование строк.

• url : Этот модуль предоставляет утилиты для разрешения и анализа URL.

• querystring : Этот модуль предоставляет утилиты для разбора и форматирования строк запросов URL.

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

🛠️️ Первая конечная точка, которую вы создадите, — это GET /login . Обновите раздел Routes Definitions вашего auth.js следующим образом:

 



роутер.получить(
  "/авторизоваться",
  паспорт.аутентификация("auth0", {
    scope: "профиль электронной почты openid"
  }),
  (требование, разрешение) => {
    res.redirect("/");
  }
);  

🛠️️ GET /login выполняет вход пользователя. Эта конечная точка демонстрирует, как экспресс-маршрут может принимать несколько обратных вызовов после определения маршрута и пути (первый аргумент). Здесь вы передаете две функции обратного вызова:

• Метод passport.authenticate() , который получает паспорт.js и объект options , который определяет область применения в качестве аргументов.

• Пользовательский обратный вызов вызывается после завершения pass.authenticate() . Этот обратный вызов обрабатывает успешную или неудачную аутентификацию и выдает ответ клиенту.

🛠️️ После того, как сервер аутентификации идентифицирует и проверяет пользователя, он вызывает конечную точку GET /callback из вашего API для передачи всех необходимых данных аутентификации.Реализуйте эту конечную точку, добавив следующее определение GET /callback в раздел Routes Definitions :

 



router.get("/логин", ...);

router.get("/callback", (req, res, next) => {
  паспорт.аутентификация("auth0", (ошибка, пользователь, информация) => {
    если (ошибка) {
      вернуть следующий (ошибка);
    }
    если (!пользователь) {
      вернуть res. redirect("/логин");
    }
    req.logIn(пользователь, (ошибка) => {
      если (ошибка) {
        вернуть следующий (ошибка);
      }
      константа returnTo = требуется.сеанс.returnTo;
      удалить req.session.returnTo;
      res.redirect (возврат в || "/");
    });
  })(запрос, разрешение, следующий);
});  

GET /callback выполняет последний этап аутентификации и перенаправляет на ранее запрошенный URL-адрес или /, если этот URL-адрес не существует. В пользовательской функции обратного вызова вы проверяете наличие ошибки err и определен ли объект пользователя . В случае ошибки вы передаете управление следующей промежуточной функции вместе с объектом ошибки.Если аутентификация не удалась, user является ложным, и вы перенаправляете пользователя обратно на страницу /login .

Поскольку вы вызываете метод паспорта.authenticate() в контроллере маршрута, он имеет доступ к объектам запроса req и ответа res через замыкание. Если аутентификация прошла успешно, вы вызываете req.LogIn() , чтобы установить сеанс входа в систему. req.logIn() — это функция, предоставляемая Passport.js для объекта req .По завершении операции входа в объект req добавляется свойство user , содержащее всю информацию о пользователе.

После установления сеанса входа в систему вы можете улучшить взаимодействие с пользователем, перенаправляя пользователей на страницу, которую они посещали до выполнения запроса аутентификации. Маршрут такой страницы — это значение req.session.returnTo , которое вы присваиваете переменной returnTo перед ее удалением. Если определено returnTo , вы перенаправляете пользователя на этот маршрут; в противном случае вы ведете их на страницу /user , которая в идеале должна предоставить пользователю их информацию.

Вы можете перенаправить на любые другие маршруты.

Как видите, GET /callback действует как мост между вашим приложением и сервером аутентификации Auth0. Используя Passport.js, вы можете упростить процесс создания сеанса входа и активного пользователя в своем приложении.

🛠️️ Почти готово. Последней конечной точкой аутентификации, которую необходимо реализовать, является GET /logout , и она самая сложная. Добавьте следующее определение GET /logout в раздел Routes Definitions :

 



маршрутизатор.получить("/логин", ...);

router.get("/обратный вызов", ...);

router.get("/logout", (req, res) => {
  req.logOut();

  пусть returnTo = req.protocol + "://" + req.hostname;
  постоянный порт = req.connection.localPort;

  if (порт !== не определено && порт !== 80 && порт !== 443) {
    вернуться к =
      process.env.NODE_ENV === "производство"
        ? `${возврат}/`
        : `${returnTo}:${порт}/`;
  }

  const logoutURL = новый URL(
    `https://${process. env.AUTH0_DOMAIN}/v2/выход из системы`
  );

  константная строка поиска = строка запроса.подстроить строку ({
    client_id: process.env.AUTH0_CLIENT_ID,
    вернуться к: вернуться к
  });
  logoutURL.search = строка поиска;

  res.redirect (URL-адрес выхода);
});  

Этот маршрут выполняет выход из сеанса и перенаправляет пользователя на домашнюю страницу.

Passport.js также предоставляет функцию logOut() для объекта запроса, req , которую вы можете вызвать из любого контроллера маршрута, которому необходимо завершить сеанс входа в систему. Вызов req.logOut() удаляет req.user и очищает существующий сеанс входа в систему. После этого вы создаете URL-адрес, на который перенаправляются пользователи после завершения выхода, следующим образом:

• Начните строку URL-адреса с протокола и имени хоста:

  let returnTo = req.protocol + "://" + req.hostname;  

• Определите, используете ли вы локальный порт. Если порт не является ни undefined , ни номером порта по умолчанию для веб-серверов, использующих HTTP ( 80 ), ни портом по умолчанию для веб-серверов, использующих HTTPS ( 443 ), вы добавляете этот порт к строке URL returnTo если текущая среда Node development :

  const port = req.соединение.локальныйПорт;

if (порт !== не определено && порт !== 80 && порт !== 443) {
  вернуться к =
    process.env.NODE_ENV === "производство"
      ? `${возврат}/`
      : `${returnTo}:${порт}/`;
}  

• Используйте конструктор Node.js URL() вместе с util.format() , чтобы вернуть отформатированную строку, заменив спецификаторы формата (символы, которым предшествует знак процента, % ) на соответствующий аргумент. В этом случае спецификатор строки %s заменяется значением процесса .env.AUTH0_DOMAIN . Вы установите переменные Auth0 в следующем разделе.

  const logoutURL = новый URL(
  `https://${process.env.AUTH0_DOMAIN}/v2/выход из системы`
);  

• Используя querystring.stringify , создайте строку запроса URL из объекта, который содержит идентификатор клиента Auth0 и URL-адрес returnTo :

  const searchString = querystring.stringify({
  client_id: process.env.AUTH0_CLIENT_ID,
  вернуться к: вернуться к
});  

• Использование URL-адреса .search , получить и установить сериализованные части запроса logoutURL :

  logoutURL.search = searchString;  

• Наконец, перенаправьте пользователя на logoutURL :

  res.redirect(logoutURL);  

Конечная точка GET /logout не слишком длинная, но довольно сложная. Он использует различные API-интерфейсы Node для динамического построения пути выхода в зависимости от активной среды Node, порта, который использует сервер, и переменных конфигурации.

🛠️️ Все конечные точки API аутентификации завершены. Теперь вам нужно экспортировать маршрутизатор и использовать его с приложением Express. Сначала добавьте эту строку в раздел Module Exports файла auth.js :

 .



модуль.экспорт = маршрутизатор;  

🛠️️ Затем откройте index.js и импортируйте маршрутизатор аутентификации в раздел Required External Modules :

 



константный экспресс = требуется ("экспресс");
постоянный путь = требуется ("путь");

const expressSession = require("Экспресс-сеанс");
const паспорт = требовать("паспорт");
const Auth0Strategy = require("passport-auth0");

требуют("дотенв").конфиг();

const authRouter = require("./auth");  

🛠️️ Теперь смонтируйте authRouter по корневому пути / вашего приложения Express, обновив раздел App Configuration следующим образом:

 



app.set("представления", path.join(__dirname, "представления"));
app.set("движок просмотра", "мопс");
app.use(express.static(path.join(__dirname, "public")));

app.use (expressSession (сеанс));

паспорт.использование(стратегия);
app.use(passport.initialize());
app.use(паспорт.сеанс());

паспорт.serializeUser( ... );

паспорт.deserializeUser( ... );


app.use("/", authRouter);  

🛠️️ У вас есть конечная точка GET /login , но у вас нет кнопки входа. Обновите views/index.pug , чтобы включить его:

  расширяет макет

блочный макет-контент
  div.View.WelcomeView
    h2.Баннер WHATABYTE
    div.Сообщение
      div.Название
        h4 Делая все возможное
        h2 Пища для разработчиков
      span.Details Доступ к командному порталу WHATABYTE
    разд.навигационные кнопки
      если авторизован
        а(href="/пользователь")
          div.NavButton Просто погрузитесь!
      еще
        а(href="/логин")
          div.NavButton Войдите в систему  

Теперь, когда вы нажимаете кнопку входа в систему на странице индекса, вызывается конечная точка GET /login . Как упоминалось ранее, конечная точка /login предоставляет пользователю страницу входа, но где эта страница? При использовании Auth0 в качестве платформы для идентификации вам не нужно создавать страницу входа в систему, Auth0 предоставляет ее с надлежащей формой и безопасными сообщениями и подсказками об ошибках аутентификации.

🛠️️ Последнее, что вам нужно сделать, это смонтировать промежуточную функцию на уровне приложения, чтобы определить значение переменной isAuthenticated , используемой в шаблоне index.pug .

Создайте пользовательское промежуточное ПО с помощью Express

🛠️️ В index.js обновите раздел App Configuration , чтобы дополнить объект ответа res данными с сервера аутентификации. Сделайте это прямо над креплением маршрутизатора аутентификации:

 



приложение.set("views", path.join(__dirname, "views"));
app.set("движок просмотра", "мопс");
app.use(express.static(path.join(__dirname, "public")));

app.use (expressSession (сеанс));

паспорт.использование(стратегия);
app.use(passport.initialize());
app.use(passport.session());

паспорт.serializeUser( ... );

паспорт.deserializeUser( ... );


app.use((req, res, next) => {
  res.locals.isAuthenticated = req.isAuthenticated();
  следующий();
});

app.use("/", authRouter);  

res.locals — это свойство, используемое для предоставления информации на уровне запроса, такой как аутентифицированный пользователь и настройки пользователя.Затем эта информация становится доступной для представлений, отображаемых во время этого цикла запроса-ответа, таких как шаблоны, использующие переменную isAuthenticated .

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

Войдите в приложение Node.js Express

🛠️️ Перейдите на вкладку браузера, где запущено ваше приложение, и нажмите кнопку входа, чтобы проверить, правильно ли оно взаимодействует с Auth0 и что вы можете пройти аутентификацию.

🛠️️ Если вы все настроили правильно, приложение перенаправит вас на страницу универсального входа.

Как объяснялось ранее, эта страница входа предоставляется Auth0 с включенными батареями. Он обеспечивает не только вход в систему, но и регистрацию новых пользователей в вашем приложении. Если у вас уже есть существующая учетная запись пользователя, войдите в систему; в противном случае зарегистрируйтесь как новый пользователь.

🛠️️ Кроме того, вы можете зарегистрироваться и войти в систему с помощью Google, так как он включен по умолчанию в качестве социального провайдера.

🛠️️ Если вы входите в приложение с использованием Auth0 в первый раз, вы увидите диалоговое окно с просьбой разрешить вашему приложению доступ к данным профиля пользователя. Идите вперед и нажмите кнопку с зеленой стрелкой, чтобы авторизовать доступ.

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

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

🛠️️ После того, как вы зарегистрируетесь или войдете в систему, Auth0 вернет вас на домашнюю страницу вашего приложения Express.

Обратите внимание, что метка кнопки на домашней странице изменилась с Войти на Просто погрузитесь! , что означает, что приложение успешно аутентифицировало вас.

Доступ к защищенным маршрутам

В своем приложении вы защищаете конечную точку GET /user с помощью промежуточного программного обеспечения Passport.js, чтобы предотвратить переход к ней, если приложение не аутентифицировало пользователя. Поскольку вы вошли в систему, при нажатии кнопки Just Dive In! , которая указывает на /user , вы успешно перешли к этому представлению. В случае, если вы вышли из системы, при попытке доступа к маршруту /user вы попадете на экран входа в систему Auth0.

🛠️️ Для начала создайте промежуточную функцию с именем secure для защиты вашего маршрута /user и убедитесь, что он доступен только в том случае, если пользователь вошел в систему. В разделе Routes Definitions файла index.js , добавьте следующую функцию промежуточного программного обеспечения :

 



const secure = (req, res, next) => {
  если (треб. пользователь) {
    вернуть следующий();
  }
  req.session.returnTo = req.originalUrl;
  res.redirect("/логин");
};


приложение.получить("/", ... );

app.get("/пользователь", ...);  

🛠️️ Затем, все еще в разделе Routes Definitions , рефакторинг контроллера GET /user , чтобы он использовал эту промежуточную функцию следующим образом:

 



const secure = (req, res, next) => { ... };

app.get("/", ...);

app.get("/user", защищенный, (req, res, следующий) => {
  const { _raw, _json, ...userProfile } = req.user;
  res.render ("пользователь", {
    заголовок: "Профиль",
    профиль пользователя: профиль пользователя
  });
});  

Вы используете деструктуризацию объекта Javascript для распаковки значений из req.объект пользователя в отдельные переменные. Используя необязательный объектный аргумент метода res.render() , вы передаете переменную userProfile в шаблон представления пользователя вместе с заголовком страницы.

🛠️️ Посетите http://localhost:3000/user в браузере, если вы вошли в систему, теперь вы видите свой псевдоним в приветственном баннере и объект userProfile , отображаемый в формате JSON в контейнере содержимого.

🛠️️ Если вы нажмете на кнопку Выйти , приложение перенесет вас на главную страницу.Посетите http://localhost:3000/user еще раз, и вы попадете на страницу входа, предоставленную Auth0. Войдите снова, и вы вернетесь на страницу пользователя.

«Узнайте, как настроить Node.js и экспресс-аутентификацию с помощью Passport.js и Auth0».

Твитнуть это

Интеграция аутентификации завершена

Готово! Из этого руководства вы узнали, как работает Passport.js, как его настроить и как интегрировать с Node.js и Auth0, чтобы добавить аутентификацию в веб-приложения.Вы также узнали о передовых методах обеспечения безопасности и идентификации и о том, как платформа идентификации, такая как Auth0, позволяет делегировать команде экспертов гигантскую ответственность за обеспечение безопасности входа в систему.

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

Спасибо за ваше время!

Я столкнулся с проблемой

Аутентификация в React с использованием Express, Node, Passport и MongoDB

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

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

Мы будем использовать:

• Passport как промежуточное ПО для Node.js.
• MongoDB для хранения сведений о пользователе.
• JWT для идентификации запроса пользователя.
• Жетоны обновления для обновления JWT.

Архитектура приложения

Вот как будет выглядеть наш процесс входа в систему:

Вот как будет выглядеть аутентифицированный запрос:

Зачем нужны токены JWT и Refresh и что такое тихое обновление?

Возможно, вы уже знаете, что когда мы используем JWT для аутентификации, мы не храним JWT в серверной части. Мы идентифицируем пользователя, извлекая информацию из JWT с помощью секрета, используемого для создания JWT.Таким образом, сервер не может аннулировать JWT (если только мы не изменим секрет JWT, что приведет к выходу из системы всех пользователей!) или определить, исходит ли запрос от законного клиента или нет. В связи с этим создаются JWT с коротким сроком действия (например, 15 минут, который может варьироваться в зависимости от критичности приложения), так что даже если JWT будет украден, злоумышленник не сможет использовать его в течение более длительного времени.

Проблема с коротким сроком действия JWT заключается в том, что пользователь будет часто выходить из системы, что определенно не очень удобно для пользователя.Чтобы решить эту проблему, мы вводим токены обновления с очень длительным сроком действия (скажем, 30 дней). В отличие от JWT, токен обновления хранится в файле cookie, который создается на сервере (только HTTP, безопасный). таким образом предотвращается чтение любым уязвимым javascript файла cookie refreshToken (XSS-атака).

Токены обновления создаются и сохраняются в базе данных во время входа/регистрации и записываются в файл cookie. После каждого короткого интервала (скажем, 5 минут, что меньше времени истечения JWT), Конечная точка /refreshToken будет вызываться в фоновом режиме ( Silent Refresh ) для обновления как JWT, так и refreshToken , как показано ниже:

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

Почему JWT хранится в памяти? Почему не локальное хранилище?

Вы могли заметить во многих блогах и видеороликах, что не следует хранить JWT или какие-либо данные аутентификации в локальном хранилище или в файлах cookie на стороне клиента. Причина, по которой они могли указать, заключается в том, что локальное хранилище и файлы cookie на стороне клиента подвержены XSS-атакам. Тем не менее, хранение JWT в памяти не препятствует его чтению при наличии XSS-уязвимости, а лишь затрудняет его чтение злоумышленником. Таким образом, цель должна состоять в том, чтобы разработать приложение без уязвимости XSS (или любой другой, если на то пошло) и не беспокоиться о том, где хранить JWT!

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

Почему не используются файлы cookie SameSite?

Вам может быть интересно, почему бы не использовать один файл cookie SameSite с HTTPOnly и Secure для хранения сеанса пользователя? Проблема с этим подходом:

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

Другие преимущества использования JWT:

• Поскольку JWT не нужно проверять по базе данных, он повышает производительность, избегая обращения к базе данных в каждом запросе.
• Поскольку JWT хранится на стороне клиента, он помогает предотвратить атаки XSRF/CSRF.

Реализация на стороне сервера

Создать новый узел.js с помощью следующей команды:

Откройте каталог, в котором вы запустили указанную выше команду, в своем любимом редакторе кода, обновите файл package.json с помощью сценария запуска:

package.json

 
 1{ 
 
 2 "имя": "mern-auth-server", 
 
 3 "версия": "1.0.0", 
 
 4 "описание": "", 
 
 5 "main": "index.js", 
 
 6 "scripts": { 
 
 7 "start": "node index.js", 
 
 8 "test": "echo \"Ошибка: тест не указан\" && выход 1" 
 
 9 }, 
 
 10 "ключевые слова": [], 
 
 11 "автор": "", 
 
 12 "лицензия": "ISC" 
 
 13} 
 

Теперь выполните следующую команду для установки пакетов:

 
 1yarn добавить экспресс-парсер dotenv mongoose body-parser cors cookie-parser 
 

• экспресс — используется для создания веб-фреймворка с помощью Node.js.
• dotenv — загружает переменные среды из файла .env .
• мангуст — ODM для mongoDB.
• body-parser — анализирует тело запроса из таких запросов, как POST-запрос.
• cors — включение политик CORS для URL-адреса клиента.
• cookie-parser — для создания и чтения файла cookie refreshToken .

Теперь давайте создадим файл с именем .env в корневом каталоге проекта. В этом файле будут все конфигурации и секреты, используемые сервером.Вы встретите эти переменные в этом посте.

 .env 
 1JWT_SECRET = jdhdhd-kjfjdhrhrerj-uurhr-jjge 
 
 2REFRESH_TOKEN_SECRET = fgkjddshfdjh773bdjsj84-jdjd774 
 
 3SESSION_EXPIRY = 60 * 15 
 
 4REFRESH_TOKEN_EXPIRY = 60 * 60 * 24 * 30 
 
 5MONGO_DB_CONNECTION_STRING = MongoDB: //127.0. 0.1:27017/mern_auth 
 
 6COOKIE_SECRET = jhdshhds884hfhhs-ew6dhjd 
 
 7WHITELISTED_DOMAINS = http://localhost:3000 
 

.env файлы с производственными секретами не должны помещаться в кодовую базу. В развернутой среде задайте переменные среды в конфигурации сервера.

Создайте каталог с именем utils и создайте в нем файл с именем connectdb.js :

Connectdb.js

 
 1Const Mongoose = Требуется («Монтон») 
 
 2CONST URL = Process.env.mongo_db_connection_string 
 
 3Const Connect = Mongoose.Connect (URL, {
 
 4 UREWURLPARSER: TRUE, 
 
 5 USERALPARSERTTOPOLY: true, 
 
 6 useCreateIndex: true, 
 
 7}) 
 
 8connect 
 
 9 .then(db => { 
 
 10 console.log("подключен к db") 
 
 11 }) 
 
 12 .catch(err => {
 
 13 console.log(err) 
 
 14 })  
3 
 
2
 
 Как следует из названия, это помогает подключиться к экземпляру MongoDB, указанному в файле  .env .
Вы можете использовать либо локальный экземпляр, либо
подключиться к облачному провайдеру, такому как MongoDB Atlas. 

 
 Теперь создайте файл с именем  index.js  со следующим кодом: 
 индекс 
.js 
 
 
 1const express = require("express") 
 
 2const cors = require("cors") 
 
 3const bodyParser = require("body-parser") 
 
 4const cookieParser = require("cookie-parser") 
 
 5
 
 
 6if (process.env.NODE_ENV !== "production") { 
 
 7 
 
 8 require("dotenv").config() 
 
 9} 
 
 10require("./utils/connectdb") 
 
 11
 
 
 12const приложение = экспресс() 
 
 13
 
 
 14прил.use(bodyParser.json()) 
 
 15app.use(cookieParser(process.env.COOKIE_SECRET)) 
 
 16
 
 
 17 
 
 18
 
 
 19const белый список = process.env.WHITELISTED_DOMAINS 
 
 20 ? process.env.WHITELISTED_DOMAINS.split(",") 
 
 21 : [] 
 
 22
 
 
 23const corsOptions = { 
 
 24 origin: function (origin, callback) { 
 
 25 if (!origin || whitelist.indexOf(origin) !== -1) { 
 
 26 callback(null, true) 
 
 27 } else { 
 
 28 обратный вызов (новая ошибка («Не разрешено CORS»)) 
 
 29 } 
 
 30 }, 
 
 31
 
 
 32 учетные данные: правда, 
 
 33} 
 
 34
 
 
 35прил.использовать (cors (corsOptions)) 
 
 36
 
 
 37app.get("/", function (req, res) { 
 
 38 res.send({статус: "успешно"}) 
 
 39}) 
 
 40
 
 
 41 
 
 42
 
 
 43const server = app.listen(process.env.PORT || 8081, function () { 
 
 44 const port = server.address().port 
 
 45
 
 
 46 console.log("Приложение запущено на порту:", порт) 
 
 47}) 
 
 Здесь мы запускаем сервер на порту 8081 и подключаем маршрут / с успешным ответом.
 Запустите сервер с помощью следующей команды (вы можете использовать npm start или nodemon):
 Теперь в консоли вы должны увидеть следующий вывод:
 Если вы откроете URL-адрес http://localhost:8081 в браузере или почтальоне, вы увидите ответ об успешном завершении, как показано ниже:
 Теперь, когда у нас есть готовая базовая настройка, давайте углубимся в часть аутентификации.
 Паспорт js
 Passport — это промежуточное ПО Node.js, используемое для аутентификации.В нем написаны разные стратегии, основанные на типе аутентификации, который мы хотели бы использовать.
Он имеет стратегии для локальной аутентификации с использованием имени пользователя и пароля, а также для входа в социальные сети, такие как Google и Facebook.
 Установка пакетов, связанных с паспортом
 Давайте установим следующие пакеты:
 
 1пряжа добавить паспорт паспорт-jwt паспорт-местный паспорт-местный-мангуст jsonwebtoken 
 
 паспорт-jwt — стратегия паспорта для аутентификации с использованием JWT для дальнейших запросов после входа/регистрации.
 паспорт-местный — стратегия паспорта для аутентификации с использованием имени пользователя и пароля при входе в систему и регистрации.
 паспорт-локальный-мангуст — плагин Mongoose, который помогает в создании имени пользователя и пароля для входа с использованием паспорта.
 jsonwebtoken — помогает в создании и проверке JWT.
 Создание пользовательской модели
 Теперь давайте создадим модель пользователя. Создайте папку с именем  models  и файл с именем  user.js  внутри нее со следующим кодом:
 пользователя.js
 
 1const mongoose = require("mongoose") 
 
 2const Schema = mongoose.Schema 
 
 3
 
 
 4const паспортЛокальныйМангуст = требуется("паспорт-местный-мангуст") 
 
 5
 
 
 6const Session = new Schema({ 
 
 7 refreshToken: { 
 
 8 тип: строка, 
 
 9 по умолчанию: "", 
 
 10 }, 
 
 11}) 
 
2
 
 
 13Const User = Новая схема ({
 
 14 Именные данные: {
 
 15 Тип: строка, 
 
 16 по умолчанию: "", 
 
 17}, 
 
 18 lastname: {
 
 19 Тип: {
 
 19 Тип: Строка, 
 
 20 по умолчанию: "", 
 
 21 }, 
 
 22 authStrategy: { 
 
 23 тип: строка, 
 
 24 по умолчанию: "local", 
 
 25 }, 
 72 
 9000 тип: { 
 72 
 
 , 
 
 28 по умолчанию: 50, 
 
 29 }, 
 
 30 refreshToken: { 
 
 31 тип: [Сеанс], 
 
 32 }, 
 
 33}) 
3 90
 
 
 35 
 
 36Пользователь.set("toJSON", { 
 
 37 transform: function (doc, ret, options) { 
 
 38 delete ret.refreshToken 
 
 39 return ret 
 
 40 }, 
 
 41}) 
 
 42
 
 
 43User.plugin(passportLocalMongoose) 
 
 44
 
 
 45module.exports = mongoose.model («Пользователь», Пользователь) 
 
 Здесь мы объявляем 2 схемы,
один для хранения токенов обновления, а другой для хранения сведений о пользователе, таких как
имя, фамилия, стратегия аутентификации, баллы (которые будут отображаться пользователю после входа в систему),
и массив токенов обновления (для поддержки одновременного входа с нескольких устройств).
 Кроме того, мы удалили токен обновления из функции  toJSON ,
чтобы мы не раскрывали токены обновления пользователя всякий раз, когда мы сериализуем модель и отправляем данные в ответе API.
 Плагин
  паспорт-локальный-мангуст  предоставляет такие функции, как  аутентификация  и  serializeUser  , которые мы увидим в следующих разделах.
 Создание локальной стратегии
 Теперь создадим локальную стратегию, которая будет использоваться при входе и регистрации:
 Создайте папку с именем  стратегий  и файл с именем  LocalStrategy.js  внутри него.
Локальная стратегия использует методы, предоставляемые  паспортом-локальным-мангустом , для аутентификации и сериализации пользователя.
 LocalStrategy.js
 
 1const паспорт = требовать("паспорт") 
 
 2const LocalStrategy = требовать("локальный паспорт").Стратегия 
 
 3const Пользователь = требовать("../модели/пользователь") 
 
 4
 
 
 5 
 
 6passport.use(new LocalStrategy(User.authenticate())) 
 
 7
 
 
 8 
 
 9паспорт.сериализовать пользователя (пользователь. сериализовать пользователя ()) 
 
 Создание стратегии JWT
 Аналогично локальной стратегии, создайте файл с именем  JwtStrategy.js  внутри папки  стратегий  со следующим кодом:
 JwtStrategy.js
 
 1const паспорт = требовать("паспорт") 
 
 2const JwtStrategy = требовать("паспорт-jwt").Стратегия, 
 
 3 ExtractJwt = требовать("паспорт-jwt").ExtractJwt 
3 40const Пользователь = требуется("../модели/пользователь") 
 
 5
 
 
 6const opts = {} 
 
 7opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken() 
 
 8opts.secretOrKey = process.env.JWT_SECRET 
 
 9
 
 
 10 
 
 11 
 
 12 
 
 12Passort.use (
 
 13 Новая JWTSTSTRATEGY (OPTS, Функция (JWT_PAYLOAD, сделано) {
 
 14 
 
 15 
 
 16 User.Findone ({_id: jwt_payload._id}, функция ( err, user) { 
 
 17 if (err) { 
 
 18 return done(err, false) 
 
 19 } 
 
 20 if (user) { 
 
 21 return done(null, user) 
 
 else 22 { 
 
 23 return done(null, false) 
 
 24 
 
 25 } 
 
 26 }) 
 
 27 }) 
 
 28) 
 
 Как вы могли видеть, мы используем функцию  fromAuthHeaderAsBearerToken , указав  JwtStrategy  для извлечения JWT из заголовка носителя аутентификации.Мы увидим, как передать JWT в заголовке аутентификации в следующих разделах.
Другие экстракторы, поддерживаемые паспортом, вы найдете здесь.
 Создание функций, связанных с аутентификацией
 Теперь давайте создадим несколько функций, используемых для аутентификации. Создайте файл с именем  authentication.js  внутри корневого каталога со следующим кодом:
.
 authentication.js
 
 1const паспорт = требовать ("паспорт") 
 
 2const jwt = требовать ("jsonwebtoken") 
 
 3const dev = процесс.env.NODE_ENV !== "производство" 
 
 4
 
 
 5Exports.Cookie_Options = {
 
 6 Httpnly: True, 
 
 7 
 
 8 
 
 
 8 
 
 9 Безопасное :! dev, 
 
 10 Подписано: true, 
 
 11 maxage: eval (process.env.refresh_token_expiry) * 1000 , 
 
 12 тот же сайт: "нет", 
 
 13} 
 
 14
 
 
 15exports.getToken = user => { 
 
 16 return jwt.sign(user, process.env.JWT_SECRET, { 
 
 17 expiresIn: eval(process.env.SESSION_EXPIRY), 
 
 18 }) 
 
 19} 
 
 20
 
 
 21Exports.getrefreshtoken = User => {
 
 22 const Refreshtoken = jwt.sign (пользователь, process.env.refresh_token_secret, {
 
 23 Expiresin: Eval (process.env.refresh_token_expiry), 
 
 24}) 
 
 25 вернуть refreshToken 
 
 26} 
 
 27
 
 
 28exports.verifyUser = паспорт.аутентификация("jwt", {сеанс: ложь}) 
 
  COOKIE_OPTIONS  используется для создания файла cookie токена обновления,
который должен быть httpOnly и безопасным, чтобы он не мог быть прочитан клиентским javascript.Для SameSite установлено значение «Нет», поскольку клиент и сервер будут находиться в разных доменах.
  getToken  используется для создания JWT.
  getRefreshToken  используется для создания токена обновления, который сам по себе является JWT.
  verifyUser  — это промежуточное ПО, которое необходимо вызывать для каждого аутентифицированного запроса.
 Создание пользовательского маршрутизатора
 Создайте папку с именем  route  и файл с именем  userRoutes.js  внутри нее со следующим кодом:
 пользовательских маршрута.js
 
 1const express = require("express") 
 
 2const router = express.Router() 
 
 3const User = require("../models/user") 
 
 4
 
 
 5const { getToken, COOKIE_OPTIONS, getRefreshToken } = require("../authenticate") 
 
 6
 
 
 7router.post("/signup", (req, res, next) => { 
 
 8 
 
 9 if (!req.body.firstName) { 
 
 10 res.statusCode = 500 
 
 11 рез. send({ 
 
 12 name: "FirstNameError", 
 
 13 message: "Требуется имя", 
 
 14 }) 
 
 15 } else { 
 
 16 Пользователь.register( 
 
 17 новый пользователь ({ имя пользователя: req.body.username }), 
 
 18 req.body.password, 
 
 19 (ошибка, пользователь) => { 
 
 20 если (ошибка) { 
 
 21 res.statusCode = 500 
 
 22 res.send(err) 
 
 23 } else { 
 
 24 user.firstName = req.body.firstName 
 
 25 user.lastName = req.body.lastName || "" 
 
 26 const token = getToken({ _id: user._id }) 
 
 27 const refreshToken = getRefreshToken({ _id: user._id }) 
 
 28 user.refreshToken.push({ refreshToken }) 
 
 29 user.save((ошибка, пользователь) => { 
 
 30 if (ошибка) { 
 
 31 res.statusCode = 500 
 3  
 res.send(err) 
 
 
 33 } else { 
 
 34 res.cookie("refreshToken", refreshToken, COOKIE_OPTIONS) 
 
 35 res.send({ успех: true, token }) 
 
 36 } 
3 90 } ) 
 
 38 } 
 
 39 } 
 
 40 ) 
 
 41 } 
 
 42}) 
 
 43
 
 
 44модуль.экспорт = маршрутизатор 
 
 Здесь мы определяем маршрут  /signup  для регистрации.
Он вызывает функцию  register  из плагина  паспорта-локального-мангуста  с
имя пользователя и пароль и обратный вызов, который будет вызван после регистрации пользователя.
 Когда пользователь успешно зарегистрирован, мы генерируем токен аутентификации (JWT) и токен обновления.
Мы сохраняем имя и фамилию в базе данных вместе с токеном обновления.При успешном сохранении сведений в базе данных создается файл cookie  refreshToken  и
маркер аутентификации (JWT) отправляется в теле ответа.
 Теперь давайте включим все эти файлы в  index.js  :
 index.js
 
 1const express = require("express") 
 
 2const cors = require("cors") 
 
 3const bodyParser = require("body-parser") 
 
 4const cookieParser = require("cookie- парсер") 
 
 5const паспорт = требовать("паспорт") 
 
 6
 
 
 7if (процесс.env.NODE_ENV !== "production") { 
 
 8 
 
 9 require("dotenv").config() 
 
 10} 
 
 11require("./utils/connectdb") 
 
 12
 
 
 13require("./strategies/JwtStrategy") 
 
 14require("./strategies/LocalStrategy") 
 
 15require("./authenticate") 
 
 16
 
 
 17const userRouter = require("./routes/userRoutes") 
 
 18
 
 
 19const приложение = экспресс() 
 
 20
 
 
 21app.use(bodyParser.json()) 
 
 22app.use(cookieParser(process.env.COOKIE_SECRET)) 
 
 23
 
 
 24 
 
 25
 
 
 26const белый список = process.env.WHITELISTED_DOMAINS 
 
 27 ? process.env.WHITELISTED_DOMAINS.split(",") 
 
 28 : [] 
 
 29
 
 
 30const corsOptions = { 
 
 31 origin: function (origin, callback) { 
 
 32 if (!origin || whitelist.indexOf(origin) !== -1) { 
 
 33 callback(null, true) 
 
 34 } else { 
 
 35 обратный вызов (новая ошибка («Не разрешено CORS»)) 
 
 36 } 
 
 37 }, 
 
 38
 
 
 39 учетные данные: правда, 
 
 40} 
 
 41
 
 
 42прил.использовать (cors (corsOptions)) 
 
 43
 
 
 44app.use(passport.initialize()) 
 
 45
 
 
 46app.use("/пользователи", userRouter) 
 
 47
 
 
 48app.get("/", function (req, res) { 
 
 49 res.send({статус: "успешно"}) 
 
 50}) 
 
 51
 
 
 52 
 
 53
 
 
 54const server = app.listen(process.env.PORT || 8081, function () { 
 
 55 const port = server.address().port 
 
 56
 
 
 57 консоль.log("Приложение запущено на порту:", порт) 
 
 58}) 
 
 Тестирование с помощью почтальона 
 Теперь, если вы сделаете почтовый запрос на URL-адрес: http://localhost:8081/users/signup,
с  username  ,  password  ,  firstName  и  lastName  , вы сможете увидеть токен, сгенерированный в ответе.
 Если вы нажмете на Cookies, вы сможете увидеть файл cookie  refreshToken :
 Если вы проверите базу данных, вы сможете увидеть созданную там запись пользователя:
 Создание маршрута входа 
 Теперь, когда у нас есть способ зарегистрировать пользователя, давайте добавим маршрут входа в  userRoutes.js :
 userRouter.js
 
 1const express = require("express") 
 
 2const router = express.Router() 
 
 3const User = require("../models/user") 
 
 4const паспорт = require(" паспорт") 
 
 5
 
 
 6const { getToken, COOKIE_OPTIONS, getRefreshToken } = require("../authenticate") 
 
 7
 
 
 8 
 
 9
 
 
 10router.post("/login",passport.authenticate("local"), (req, res, next) => { 
 
 11 const token = getToken({ _id: req.user._id }) 
 
 12 const refreshToken = getRefreshToken({ _id: req.user._id }) 
 
 13 User.findById(req.user._id).then( 
 
 14 user => { 
 
 15 user .refreshToken.push({ refreshToken}) 
 
 16 user.save((ошибка, пользователь) => { 
 
 17 если (ошибка) { 
 
 18 res.statusCode = 500 
 
 19 res.send(ошибка) 
 
 20 } else { 
 
 21 res.cookie("refreshToken", refreshToken, COOKIE_OPTIONS) 
 
 22 рез.send({ успех: истина, токен }) 
 
 23 } 
 
 24 }) 
 
 25 }, 
 
 26 err => следующий(ошибка) 
 
 27 ) 
 
 28}) 90 90
 
 
 30module.exports = маршрутизатор 
 
 Здесь мы подключаем локальную стратегию аутентификации, вызывая  pass.authenticate("local")  .
Только если учетные данные действительны, тогда управление будет передано в тело маршрута входа.
Если пользователь успешно вошел в систему, мы генерируем токен аутентификации и токен обновления.Мы сохраняем токен обновления в базе данных и устанавливаем его в файле cookie ответа.
Маркер аутентификации (JWT) будет отправлен в теле ответа, чтобы клиент мог прикрепить его к последующему запросу.
 Если мы проверим его с помощью почтальона, вы сможете увидеть ответ, как показано ниже:
 Если вы предоставили неверные учетные данные, вы получите ответ «Неавторизованный» с кодом ответа 401.
 Создание маршрута refreshToken 
 Ранее мы видели, что будем выполнять автоматическое обновление, вызывая конечную точку  /refreshToken , чтобы получить новый токен аутентификации (JWT).Теперь давайте обновим  userRoutes.js  с помощью  /refreshToken  route:
 userRoutes.js
 
 1 
 
 2const jwt = требуется ("jsonwebtoken") 
 
 3
 
 
 4 
 
 5
 
 
 6router.post("/refreshToken", (req, res, next) => { 
 
 7 const { signedCookies = {} } = req 
 
 8 const { refreshToken } = signedCookies 
 
 9
 
 
 10 if (refreshToken) { 
 
 11 try { 
 
 12 const payload = jwt.Verify(refreshToken, process.env.REFRESH_TOKEN_SECRET) 
 
 13 const userId = payload._id 
 
 14 User.findOne({ _id: userId }).then( 
 
 15 user => { 
 
 16 if (user) { 
 
 17 
 
 18 const tokenIndex = user.refreshToken.findIndex( 
 
 19 item => item.refreshToken === refreshToken 
 
 20 ) 
 
 21
 
 
 22 если (tokenIndex === -1) { 
 
 23 рез.statusCode = 401 
 
 24 res.send ("Unauthorized") 
 
 25 } else { 
 
 26 const token = getToken ({ _id: userId }) 
 
 27 
 
 28 const newRefreshToken = ) 
 
 29 user.refreshToken[tokenIndex] = { refreshToken: newRefreshToken } 
 
 30 user.save((ошибка, пользователь) => { 
 
 31 если (ошибка) { 
 
 32 рез.statusCode = 500 
 
 33 res.send(err) 
 
 34 } else { 
 
 35 res.cookie("refreshToken", newRefreshToken, COOKIE_OPTIONS) 
 
 36 res.send({ успех: true, token 0) 37} 
 
 38}) 
 
 39} 
 
 39} 
 
 40} else {
 
 41 res.statuscode = 401 
 
 42 res.send ("несанкционировано") 
 
 43} 
 
 44}, 
 
 45 Err = > следующий(ошибка) 
 
 46 ) 
 
 47 } ловить (ошибка) { 
 
 48 рез.statuscode = 401 
 
 49 res.send ("несанкционирован") 
 
 50} 
 
 51} else {
 
 52 RES.StatusCode = 401 
 
 53 RES.Send («Несанкционированный») 
 
 54} 
 
 55 }) 
 
 56
 
 
 57 
 
 Здесь,
 Мы извлекаем токен обновления из подписанных файлов cookie.
 Мы сверяем токен обновления с секретом, использованным для создания токена обновления, и извлекаем из него полезную нагрузку (содержащую идентификатор пользователя).
 Затем мы определяем, существует ли еще токен обновления в базе данных.
(в случае выхода из системы со всех устройств все токены обновления, принадлежащие пользователю, будут удалены, и пользователь будет вынужден снова войти в систему).
 Если он существует в базе данных, мы заменяем его вновь созданным токеном обновления.
 Аналогично шагам входа и регистрации,
здесь также мы будем устанавливать токен обновления в файле cookie ответа и токен аутентификации (JWT) в теле ответа.
 Если мы проверим это в почтальоне, вы увидите, что каждый раз создается новый токен обновления:
 Конечная точка для получения сведений о пользователе 
 Теперь у нас есть конечная точка для получения сведений о вошедшем в систему пользователе:
 USERTER.JS
 
 1 
 
 
 1 
 
 2CONST {
 
 3 Gettoken, 
 
 4 Cookie_Options, 
 
 5 Getrefreshtoken, 
 
 6 VerifyUser, 
 
 7} = Требовать ("../uctife") 
 
 8
 
 
 9 
 
 10маршрутизатор.get("/me", verifyUser, (req, res, next) => { 
 
 11 res.send(req.user) 
 
 12}) 
 
 13
 
 
 14 
 
 Здесь мы вызываем промежуточное ПО  verifyUser , которое, в свою очередь, вызывает стратегию JWT для проверки JWT и получения сведений о пользователе.
Если вы не получаете данные о пользователе внутри стратегии JWT,
то вы можете явно получить его в теле маршрута,
перед отправкой сведений о пользователе в ответе.
 Чтобы получить данные пользователя, вам необходимо передать токен аутентификации (JWT), полученный в ответе на вход/регистрацию в почтальоне, как показано ниже:
 Создание маршрута выхода 
 Прежде чем перейти к внешнему интерфейсу, давайте создадим последний маршрут, который будет использоваться для выхода пользователя из системы.
 userRouter.js
 
 1 
 
 2router.get("/logout", verifyUser, (req, res, next) => { 
 
 3 const { signedCookies = {} } = req 
 
 4 const { refreshToken } = signedCookies 
 
 5 User.findById(req.user._id).then( 
 
 6 user => { 
 
 7 const tokenIndex = user.refreshToken.findIndex( 
 
 8 item => item.refreshToken === refreshToken 
 
 9 ) 
 
 10
 
 
 11 если (tokenIndex !== -1) { 
 
 12 пользователь.refreshToken.id(user.refreshToken[tokenIndex]._id).remove() 
 
 13 } 
 
 14
 
 
 15 user.save((ошибка, пользователь) => { 
 
 16 if (ошибка) { 
 
 17 res.statusCode = 500 
 
 18 res.send(ошибка) 
 
 19 0 res } else {  
3 .clearCookie("refreshToken", COOKIE_OPTIONS) 
 
 
 21 res.send({ успех: true }) 
 
 22 } 
 
 23 }) 
 
 24 }, 
 
 25 err) => 0 0 0 r 3 2 9 след. 
 
 27}) 
 
 28 
 
 Здесь мы извлекаем файл cookie маркера обновления и удаляем его из базы данных, а также из файла cookie.Удаление токена аутентификации (JWT), который хранится в памяти браузера, произойдет во внешнем интерфейсе.
 Реализация внешнего интерфейса 
 Создайте новый проект реакции, используя следующую команду
 
 1npx создать-реагировать-приложение mern-auth-client 
 
 Добавление BlueprintJS для стилизации 
 Мы будем использовать BlueprintJS для оформления приложения. Итак, давайте установим его:
 
 1 пряжа добавить @blueprintjs/core 
 
 В индексе .css , давайте включим файлы css, связанные с BlueprintJS:
 index.css
 
 1@import "~normalize.css"; 
 
 4body { 
 
 5 поле: 0 авто; 
 
 6 максимальная ширина: 400 пикселей; 
 
 7} 
 
 Также обратите внимание, что мы добавили стили для выравнивания содержимого страницы по центру.
 Создание компонентов входа и регистрации 
 Теперь давайте создадим компоненты Login и Registration с помощью BlueprintJS:
 Login.js
 
 1импортировать {Button, FormGroup, InputGroup} из "@blueprintjs/core" 
 
 2импортировать React, {useState} из "реагировать" 
 
 3
 
 
 4const Login = () => { 
 
 5 const [email, setEmail] = useState("") 
 
 6 const [пароль, setPassword] = useState("") 
 
 7
 
 
 8 return ( 
 
 9 <> 
 
 10 
 
 
 11  
 
 12  
 13 placeholder="Email" 
 
 15 type="email" 
 
 16 value={email} 
 
 17 onChange={e => setEmail(e.target.value)} 
 
 18 /> 
 
 19  
 
 20  
 
 21  
 22 
 
2 
 24 type="password" 
 
 25 value={пароль} 
 
 26 onChange={e => setPassword(e.target.value)} 
 
 27 /> 
 
 28  
 
 29 < намерение = «основной» тип заполнения = «отправить» текст = «Войти» /> 
 
 30 
 
 
 31  
 
 32 ) 
 
 33} 
 
 34
 
 
 35экспорт по умолчанию Логин 
 
 Здесь у нас есть поля имени пользователя и пароля и кнопка отправки.Мы используем локальные состояния для хранения значения электронной почты и пароля и
мы подключили их к обработчикам изменений.
 Добавим поля для формы:
 index.css
 
 1@import "~normalize.css"; 
 
 4body { 
 
 5 поле: 0 авто; 
 
 6 максимальная ширина: 400 пикселей; 
 
 7} 
 
 8
 
 
 9.auth-form { 
 
 10 margin-top: 10px; 
 
 11} 
 
 Аналогично создадим страницу регистрации:
 Регистр.js
 
 1импортировать {Button, FormGroup, InputGroup} из "@blueprintjs/core" 
 
 2импортировать React, {useState} из "реагировать" 
 
 3
 
 
 4const Register = () => { 
 
 5 const [firstName, setFirstName] = useState("") 
 
 6 const [lastName, setLastName] = useState("") 
 
 7 const [email, setEmail] = useState("") 
 
 8 const [пароль, setPassword] = useState("") 
 
 9
 
 
 10 return ( 
 
 11 <> 
 
 12 
 
 
 13  
 
 14  
 17 onChange={e => setFirstName(e.target.value)} 
 
 18 value={firstName} 
 
 19 /> 
 
 20  
 
 21  
 
 22 3 2 
 
 24 placeholder="Фамилия" 
 
 25 onChange={e => setLastName(e.target.value)} 
 
 26 value={lastName} 
 
 27 /> 
 
 28   
3 
 
3  
 
 30  
 31 
 
 32 type="email" 
 
 33 placeholder="Email" 
 
 34 onChange={e => setEmail(e.target.value)} 
 
 35 value={email} 
 
 36 /> 
 
 37  
 
 38  
 
 39 30 3 
 
3 
2 38 
 41 placeholder="Password" 
 
 42 type="password" 
 
 43 onChange={e => setPassword(e.target.value)} 
 
 44 value={password} 
 
 45 /> 
 
 46 < /FormGroup> 
 
 47  
 
 48  
 
 49  
 
 50 ) 
 
 51} 
 

 
 
 53экспорт по умолчанию Регистр 
 

Теперь в приложении .js , давайте включим компоненты входа и регистрации:

App.js

 
 1import { Card, Tab, Tabs } from "@blueprintjs/core" 
 
 2import { useState } from "react" 
 
 3import Login from "./Login" 
 
 4import Register from "./ Регистрация" 
 
 5
 
 
 6function App() { 
 
 7 const [currentTab, setCurrentTab] = useState («логин») 
 
 8
 
 
 9 return ( 
 
 10  
 
 11 <Вкладки onChange={setCurrentTab} selectedTabId={currentTab}> 
 
 12 } /> 
 
 13 } /> 
 
 14  
 
 15  
 
 16  
 
 17 ) 
 
 18} 
 
 19
 
 
 20экспорт приложения по умолчанию 
 

Здесь мы используем компонент Tabs из BlueprintJS вместе с локальное состояние реакции, чтобы определить текущую активную вкладку.

Если вы откроете http://localhost:3000/ в своем браузере, вы сможете переключаться между формами входа и регистрации:

Создание пользовательского контекста

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

Создайте папку с именем context и файл с именем UserContext.js внутри нее:

UserContext.js

 
 1импортировать React, {useState} из "реагировать" 
 
 2
 
 
 3const UserContext = React.createContext([{}, () => {}]) 
 
 4
 
 
 5let InitialState = {} 
 
 6
 
 
 7const UserProvider = props => { 
 
 8 const [состояние, setState] = useState (initialState) 
 
 9
 
 
 10 возврат ( 
 
 11  
 
 12 {props.children} 
 
 13  
 
 14 ) 
 
 15} 
 
 16
 
 
 17экспорт {UserContext, UserProvider} 
 

Добавьте поставщика в index.js :

index.js

 
 1импортировать React из "реагировать" 
 
 2импортировать ReactDOM из "реагировать-дом" 
 
 3импортировать "./index.css" 
 
 4импортировать приложение из "./App" 
 50002Userimport} "./контекст/Контекст пользователя" 
 
 6
 
 
 70003 
 7REACTDOD.RUNDER (
 
 8  
 
 9  
 
 10  
 
 11  
 11  
 
 12 , 
 
 13 document.getelementbyId ("корень") 
 
 14) 
 

Отправка форм входа и регистрации:

Теперь давайте привяжем обработчик отправки к нашей форме входа:

Login.js

 
 1импортировать {Button, Callout, FormGroup, InputGroup} из "@blueprintjs/core" 
 
 2импортировать React, {useContext, useState} из "реагировать" 
 
 3импортировать {UserContext} из "./контекст/Контекст пользователя" 
 
 4
 
 
 5const Login = () => { 
 
 6 const [isSubmitting, setIsSubmitting] = useState(false) 
 
 7 const [ошибка, setError] = useState("") 
 
 8 const [email, setEmail] = useState ("") 
 
 9 const [пароль, setPassword] = useState ("") 
 
 10 const [userContext, setUserContext] = useContext(UserContext) 
 
 11
 
 
 12 const formSubmitHandler = e => { 
 
 13 e.preventDefault() 
 
 14 setIsSubmitting(true) 
 
 15 setError("") 
 
 16
 
 
 17 const genericErrorMessage = "Что-то пошло не так! Повторите попытку позже." 
 
 18
 
 
 19 fetch(process.env.REACT_APP_API_ENDPOINT + "users/login", { 
 
 20 метод: "POST", 
 
 21 учетные данные: "include", 
 
 22 заголовки: { "Content-Type": "application /json" }, 
 
 23 тело: JSON.stringify({имя пользователя: электронная почта, пароль}), 
 
 24 }) 
 
 25 .then(асинхронный ответ => { 
 
 26 setIsSubmitting(false) 
 
 27 if (!response.ok) { 
 
 28 если (ответ.status === 400) { 
 
 29 setError("Пожалуйста, заполните все поля правильно!") 
 
 30 } else if (response.status === 401) { 
 
 31 setError("Неверная комбинация адреса электронной почты и пароля. ") 
 
 32 } else { 
 
 33 setError(genericErrorMessage) 
 
 34 } 
 
 35 } else { 
 
 36 const data = await response.json() 
 
 37 setUserContext(old { ...oldvalues, токен: data.token} 
 
 39}) 
 
 40} 
 
 40} 
 
 41}) 
 
 41}) 
 
 42 .Catch (ошибка => {
 
 43 setissubmittion (false) 
 
 44 seteleror (genericerrormessage) 
 
 45 }) 
 
 46 } 
 
 47 return ( 
 
 48 <> 
 
 49 {ошибка && {ошибка}} 
 
 50 
 
 
 51  
 
 52  
 53 
 
 54 placeholder="Email" 
 
 55 type="email" 
3 90 value={email} 
 
 57 onChange={e => setEmail(e.target.value)} 
 
 58 /> 
 
 59  
 
 60  
 
 61  
 62 
 63placeholder="03assword"0P 
 64 type="password" 
 
 65 value={пароль} 
 
 66 onChange={e => setPassword(e.target.value)} 
 
 67 /> 
 
 68  
 
 69 < 
 
 70 намерение = "основной" 
 
 71 disabled={isSubmitting} 
 
 72 text={`${isSubmitting ? «Вход» : «Войти»}`} 
 
 73 заполнить 
 
 74 type="submit" 
 
 75 /> 
 
 76 
 
 
 77  
 
 70 3 ) 900} 
 
 80
 
 
 81экспорт по умолчанию Логин 
 

В приведенном выше коде

• Мы добавили два дополнительных локальных состояния.
• Во-первых, isSubmitting используется для отключения кнопки входа, когда пользователь уже нажал ее. Он также используется для отображения текста «Вход в систему», чтобы информировать пользователя о том, что происходит.
• У нас есть состояние ошибки, которое используется для отображения пользователю соответствующего сообщения об ошибке в случае сбоя входа в систему.
• В formSubmitHandler мы отключаем отправку формы по умолчанию, используя e.preventDefault() .
• Мы делаем POST-вызов конечной точке /users/login , созданной ранее в серверном проекте с параметры имени пользователя и пароля в теле запроса.
• В случае каких-либо ошибок мы устанавливаем соответствующее сообщение об ошибке, используя функцию setError .
• При успешном входе в систему значение токена будет сохранено в контексте пользователя.

Мы не выполняем проверку имени пользователя и пароля на стороне клиента, учитывая объем сообщения. Я написал статью о том, как выполнить проверку формы в реакции.

Не забудьте добавить переменную среды REACT_APP_API_ENDPOINT в .env и перезапустите клиентский проект. Он будет иметь URL-адрес сервера в качестве значения:

.env

 
 1REACT_APP_API_ENDPOINT = http://localhost:8081/ 
 

Если у вас несколько сред, таких как dev, qa, stage, prod и т. д., и хотите увидеть, как вы можете установить несколько переменных среды, вы можете прочитать эту статью.

Теперь, если вы нажмете на вход с действительными учетными данными и зарегистрируете userContext в Login.js на консоли, вы сможете увидеть токен:

Аналогичным образом добавьте обработчик отправки в регистрационную форму:

Регистр.js

 
 1import {Button, Callout, FormGroup, InputGroup} из "@blueprintjs/core" 
 
 2import React, {useContext, useState} из "react" 
 
 3import {UserContext} из "./context/UserContext" 
 
 4
 
 
 5const Register = () => { 
 
 6 const [isSubmitting, setIsSubmitting] = useState(false) 
 
 7 const [ошибка, setError] = useState("") 
 
 8 const [firstName, setFirstName] = useState ("") 
 
 9 const [lastName, setLastName] = useState ("") 
 
 10 const [email, setEmail] = useState ("") 
 
 11 const [пароль, setPassword] = useState ("") 
 
 12 const [userContext, setUserContext] = useContext(UserContext) 
 
 13
 
 
 14 const formSubmitHandler = e => { 
 
 15 e.preventDefault() 
 
 16 setIsSubmitting(true) 
 
 17 setError("") 
 
 18
 
 
 19 const genericErrorMessage = "Что-то пошло не так! Повторите попытку позже." 
 
 20
 
 
 21 fetch(process.env.REACT_APP_API_ENDPOINT + "users/signup", { 
 
 22 метод: "POST", 
 
 23 учетные данные: "include", 
 
 24 заголовки: { "Content-Type": "application /json" }, 
 
 25 body: JSON.stringify({ firstName, lastName, username: email, password }), 
 
 26 }) 
 
 27 .then(async response => { 
 
 28 setIsSubmitting(false) 
 
 29 if (!response.ok) { 
 
 30 if (response.status === 400) { 
 
 31 setError("Пожалуйста, заполните все поля правильно!") 
 
 32 } else if (response.status === 401) { 
 
 33 setError("Неверная комбинация адреса электронной почты и пароля.") 
 
 34 } else if (response.status === 500) { 
 
 35 console.log(ответ) 
 
 36 константные данные = ожидание ответа.json() 
 
 37 if (data.message) setError(data.message || genericErrorMessage) 
 
 38 } else { 
 
 39 setError(genericErrorMessage) 
 
 40 } 
 
 41 } data = {
3 90 const await response.json() 
 
 43 setUserContext(oldValues ​​=> { 
 
 44 return { ...oldValues, token: data.token } 
 
 45 }) 
 
 46 } 
 
 47 }) 
 4 900.0.catch (ошибка => { 
 
 49 setIsSubmitting (false) 
 
 50 setError (genericErrorMessage) 
 
 51 }) 
 
 52 } 
 
 53
 
 
 54 возврат ( 
 
 55 <> 
 
 56 {ошибка && <Выноска намерение="опасность">{ошибка}} 
 
 57
 
 
 58 
 
 
 59  
 
 60  
 61 
 
 62 placeholder="First Имя" 
 
 63 onChange={e => setFirstName(e.target.value)} 
 
 64 value={firstName} 
 
 65 /> 
 
 66  
 
 67  
 
 68  
 
 70 placeholder="Фамилия" 
 
 71 onChange={e => setLastName(e.target.value)} 
 
 72 value={lastName} 
 
 73 /> 
 
 74   
3 
 
3  
 
 76  
 77 
 
 78 type="email" 
 
 79 placeholder="Email" 
 
 80 onChange={e => setEmail(e.target.value)} 
 
 81 value={email} 
 
 82 /> 
 
 83  
 
 84  
 
 80 60 3InputGroup 
2 
3 
0 
 87 placeholder="Password" 
 
 88 type="password" 
 
 89 onChange={e => setPassword(e.target.value)} 
 
 90 value={password} 
 
 91 /> 
 
 92 /FormGroup> 
 
 93 <Кнопка 
 
 94 намерение = "основной" 
 
 95 disabled={isSubmitting} 
 
 96 text={`${isSubmitting ? "Регистрация": "Зарегистрироваться"} `} 
 
 97 Fill 
 
 97 Тип =" Отправить "
 9000 99 /> 
 
 100  
 
 101  
 
 102) 
 
 103} 
 
 104
 
 
 105экспорт по умолчанию Регистр 
 

Отображение экрана приветствия

Теперь, когда токен хранится в контексте, мы можем определить, показывать ли форму входа/регистрации или экран приветствия.

Сначала создадим компонент приветствия:

Welcome.js

 
 1импорт React из «реакции» 
 
 2
 
 
 3const Добро пожаловать = () => { 
 
 4 return 
Добро пожаловать!
 
 
 5} 
 
 6
 
 
 7экспорт по умолчанию Добро пожаловать 
 

В App.js давайте проверим, имеет ли userContext.token какое-либо значение, если да, то мы покажем экран приветствия, иначе мы покажем экран входа/регистрации:

Приложение.js

 
 1импорт {карты, вкладки, вкладки} из "@blueprintjs/core" 
 
 2импорт {useContext, useState} из "реагировать" 
 
 3импортировать {UserContext} из "./context/UserContext" 
 
 4импорт Войти из "./Login" 
 
 5import Register from "./Register" 
 
 6import Welcome from "./Welcome" 
 
 7
 
 
 8function App() { 
 
 9 const [currentTab, setCurrentTab] = useState("логин") 
 
 10 const [userContext, setUserContext] = useContext(UserContext) 
 
 11
 
 
 12 вернуть !userContext.жетон? ( 
 
 13  
 
 14 <Вкладки onChange={setCurrentTab} selectedTabId={currentTab}> 
 
 15 } /> 
 
 16 } /> 
 
 17  
 
 18  
 
 19  
 
 20 ) : ( 
 
 21 <Добро пожаловать /> 
 
 22 ) 
 
 23} 
 
 24
 
 
 25экспорт приложения по умолчанию 
 

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

App.js

 
 1import { Card, Tab, Tabs } from "@blueprintjs/core" 
 
 2import { useCallback, useContext, useEffect, useState } from "react" 
 
 3import { UserContext } from "./context/ UserContext" 
 
 4import Loader from "./Loader" 
 
 5import Login from "./Login" 
 
 6import Register from "./Register" 
 
 7import Welcome from "./Добро пожаловать" 
 
 8
 
 
 9function App() { 
 
 10 const [currentTab, setCurrentTab] = useState("логин") 
 
 11 const [userContext, setUserContext] = useContext(UserContext) 
 
 12
 
 
 13 const verifyUser = useCallback(() => { 
 
 14 fetch(process.env.REACT_APP_API_ENDPOINT + "users/refreshToken", { 
 
 15 метод: "POST", 
 
 16 учетные данные: "include", 
 
 17 заголовков: { "Content-Type": "application/json" }, 
 
 18 }).then(async response => { 
 
 19 if (response.ok) { 
 
 20 const data = await response.json() 
 
 21 setUserContext(oldValues ​​=> { 
 
 22 return { ...oldValues, token: data.token } 
 
 23 }) 
 
 24 } else { 
 
 25 setUserContext(oldValues ​​=> { 
 
 26 return { ...oldValues, token: null } 
 
 27 }) 2 9 0 9 0 9 0 0 0 3 2 8 0 0 0 2 
 
 30 setTimeout(verifyUser, 5 * 60 * 1000) 
 
 31 }) 
 
 32 }, [setUserContext]) 
 
 33
 
 
 34 useEffect(() => { 
 
 35 verifyUser() 
 
 36 }, [verifyUser]) 
 
 37
 
 
 38 вернуть пользовательский контекст.токен === ноль? ( 
 
 39  
 
 40 <Вкладки onChange={setCurrentTab} selectedTabId={currentTab}> 
 
 41 } /> 
 
 42 } /> 
 
 43  
 
 44  
 
 45  
 
 46 ) : userContext.token ? ( 
 
 47 <Добро пожаловать /> 
 
 48 ) : ( 
 
 49 <Загрузчик /> 
 
 50 ) 
 
 51} 
 
 52
 
 
 53экспорт приложения по умолчанию 
 

Здесь мы объявили функцию с именем verifyUser (заключена в useCallback , чтобы избежать повторного объявления при повторном рендеринге компонента), который будет вызываться при загрузке страницы (с помощью useEffect ) и будет вызывать конечную точку /refreshToken .Если он получает успешный ответ, он сохраняет токен из тела ответа в контекст. Если мы получаем какую-либо ошибку при вызове токена обновления, мы устанавливаем токен на null в контексте. Это означает, что всякий раз, когда пользователь не аутентифицирован, для токена будет установлено значение null , и мы покажем экран входа в систему.

При вызове токена обновления мы отобразим счетчик, включив компонент Loader . Вот код загрузчика .js :

Loader.js

 
 1импортировать { Spinner } из "@blueprintjs/core" 
 
 2импортировать React из "реагировать" 
 
 3
 
 
 4const Loader = () => { 
 
 5 return ( 
 
 6 
 
 
 7  
 
 8 
 
 
 90 ) ) 
 10} 
 
 11
 
 12экспорт загрузчика по умолчанию 
 

Давайте также убедимся, что счетчик находится в центре, добавив несколько стилей:

.css

 
 1 
 
 2.loader { 
 
 3 поле: 100 пикселей авто; 
 
 4} 
 

Вы увидите, что в App.js мы вызываем функцию verifyUser каждые 5 минут. Это автоматическое обновление в действии, используемое для обновления токена аутентификации, срок действия которого составляет 15 минут.

Получение сведений о пользователе

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

Добро пожаловать.js

 
 1import {Button, Card} из "@blueprintjs/core" 
 
 2import React, {useCallback, useContext, useEffect} из "react" 
 
 3import {UserContext} из "./context/UserContext" 
 
 4import Загрузчик из "./Loader" 
 
 5
 
 
 6const Добро пожаловать = () => { 
 
 7 const [userContext, setUserContext] = useContext(UserContext) 
 
 8
 
 
 9 const fetchUserDetails = useCallback(() => { 
 
 10 fetch(process.env.REACT_APP_API_ENDPOINT + "users/me", { 
 
 11 метод: "GET", 
 
 12 учетные данные: "include", 
 
 13 
 
 14 заголовки: { 
 
 15 "Content-Type": "application/ json", 
 
 16 Авторизация: `Bearer ${userContext.token}`, 
 
 17 }, 
 
 18 }).then(async response => { 
 
 19 if (response.ok) { 
 
 20 const data = await response.json() 
 
 21 setUserContext(oldValues ​​=> { 
 
 22 return { ...oldValues, детали: данные } 
 
 23 }) 
 
 24 } else { 
 
 25 if (response.status === 401) { 
 
 26 
 
 27  
 9.reload window 2 9.9000 28 () 
 
 
 30} else {
 
 31 SetuSercontext (OldValues ​​=> {
 
 32 Return {... OldValues, детали: NULL} 
 
 33}) 
 
 34} 
 
 35} 
 
 36}) 
 
 37 }, [setUserContext, userContext.жетон]) 
 
 38
 
 
 39 Use Expectect (() => {
 
 40 
 
 41 if (! Usercontext.details) {
 
 42 fetchuserdetails () 
 
 43} 
 
 44}, [USERCONTEXT.Details, FetchuserDetails]) 
 
 45
 
 
 46 Const RefitchHandler = () => {
 
 47 
 
 48 
 
 
 48 
 
 49 SetuSercontext (OldValues ​​=> {
 
 50 Repeate {... OldValues, детали: undefined} 
 
 51}) 
 
 52} 
 
 53
 
 54 вернуть пользовательский контекст.подробности === ноль? ( 
 
 55 «Ошибка при загрузке сведений о пользователе» 
 
 56 ) : !userContext.details ? ( 
 
 57 <Загрузчик /> 
 
 58 ) : ( 
 
 59 <Подъем карты="1"> 
 
 60 
 
 
 61 
 
 
 62002 62 
 
 63 Добро пожаловать 
 
 64  
 
 65 {userContext.details.firstName} 
 
 66 {userContext.details.lastName && 
 
 67 " " + userContext.details.lastName} 
 
 68 ! 
 
 69 
 
 
 70 
 
 
 71 Ваши призовые баллы: {userContext.details.points} 
 
 72 
 
 
 73 
 
 
 74 
 
 
 75  
 
 76 
 
 
 77 
 
 
 78  
 
 79 ) 
 
 80} 
 
 81
 
 82экспорт по умолчанию Добро пожаловать 
 

Здесь у нас есть fetchUserDetails , который будет вызываться из хука useEffect всякий раз, когда userContext.детали не имеют никакого значения. В функции fetchUserDetails мы вызываем конечную точку /users/me , передавая токен аутентификации в заголовке. Ответ на вызов будет сохранен в userContext.details . Если при получении ответа возникает какая-либо ошибка, мы устанавливаем userContext.details на null , чтобы мы могли показать пользователю сообщение об ошибке.

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

Функция выхода из системы

Теперь, когда мы отображаем информацию о пользователе, давайте добавим возможность выхода из системы:

Welcome.js

 
 1импортировать {Button, Card} из "@blueprintjs/core" 
 
 2импортировать React, {useCallback, useContext, useEffect} из "реагировать" 
 
 3импортировать {UserContext} из "./context/UserContext" 
 
 4импорт загрузчика из "./Loader" 
 
 5
 
 
 6const Добро пожаловать = () => { 
 
 7 const [userContext, setUserContext] = useContext(UserContext) 
 
 8
 
 
 9 const fetchUserDetails = useCallback(() => { 
 
 10 fetch(process.env.REACT_APP_API_ENDPOINT + "users/me", { 
 
 11 метод: "GET", 
 
 12 учетные данные: "include", 
 
 13 
 
 14 заголовков: { 
 
 15 "Content-Type": "application/json", 
 
 16 Авторизация: `Bearer ${userContext.token}`, 
 
 17 }, 
 
 18 }).then(async response => { 
 
 19 if (response.ok) { 
 
 20 const data = await response.json() 
 
 21 setUserContext(oldValues => { 
 
 22 return { ...oldValues, детали: данные } 
 
 23 }) 
 
 24 } else { 
 
 25 if (response.status === 401) { 
 
 2 2 
 
0 2 7 28 
 
 29 окно.location.reload() 
 
 30 } else { 
 
 31 setUserContext(oldValues ​​=> { 
 
 32 return { ...oldValues, детали: null } 
 
 33 }) 
 
 34 } 2 3003 
 305 }) 
 
 37 }, [setUserContext, userContext.token]) 
 
 38
 
 
 39 useEffect(() => { 
 
 40 
 
 41 if (!userContext.details) { 
 
 42 fetchUserDetails() 
 
 43 } 
 
 44.}, [userContext.}подробности, fetchUserDetails]) 
 
 45
 
 
 46 const logoutHandler = () => { 
 
 47 fetch(process.env.REACT_APP_API_ENDPOINT + "users/logout", { 
 
 48 учетные данные: "include", 
 
 49 заголовки: { 
 
 5 Тип": "application/json", 
 
 51 Авторизация: `Bearer ${userContext.token}`, 
 
 52 }, 
 
 53 }).then(async response => { 
 
 54 setUserContext(oldValues ​​=> { 
 
 55 возврат { ...oldValues, детали: не определено, токен: null } 
 
 56 }) 
 
 57
 
 
 61 const Refitchhandler = () => {
 
 62 
 
 63 
 
 64 SetuSercontext (OldValues ​​=> {
 
 65 Return {... OldValues, детали: undefined} 
 
 66}) 
 
 67} 
 
 68
 
 
 69 вернуть пользовательский контекст.подробности === ноль? (
 
 70 "Ошибка при загрузке сведений о пользователе" 
 
 71) : !userContext.details ? ( 
 
 72 <Загрузчик /> 
 
 73 ) : ( 
 
 74 <Подъем карты="1"> 
 
 75 
 
 
 76 
 
 
 77 
 
 78 Добро пожаловать 
 
 79  
 
 80 {userContext.details.firstName} 
 
 81 {userContext.details.lastName && 
 
 82 " " + userContext.details.lastName} 
 
 83 ! 
 
 84 
 
 
 85 
 
 
 86 Ваши призовые баллы: {userContext.details.points} 
 
 87 
 
 
 88 
 
 
 89 
 
 
 90  
 91 text="Выход" 
 
 92 onClick={logoutHandler} 
 
 93 минимальное 
 
 94 намерение="основной" 
 95002 
 
 
 96  
 
 97 
 
 
 98 
 
 
 99  
 
 100 ) 
 101002} 
 
 102
 
 
 103экспорт по умолчанию Добро пожаловать 
 

При нажатии кнопки выхода из системы мы вызываем функцию logoutHandler .В logoutHandler мы вызываем конечную точку /users/logout , чтобы токен обновления был удален из базы данных и файла cookie. Наконец, мы устанавливаем данные пользователя и токен в контексте на null , чтобы отображалась страница входа.

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

Давайте также добавим стиль к экрану приветствия:

 
 1 
 
 2.user-details { 
 
 3 display: flex; 
 
 4 выравнивание-содержание: пробел-между; 
 
 5} 
 
 6.user-actions { 
 
 7 display: flex; 
 
 8 flex-direction: столбец; 
 
 9} 
 

 
 1import { Card, Tab, Tabs } из "@blueprintjs/core" 
 
 2import { useCallback, useContext, useEffect, useState } из "react" 
 
 3import {UserContext} из "./context/UserContext" 
 
 4import Загрузчик из "./Loader" 
 
 5import Вход из "./Login" 
 
 6import Регистрация из "./Register" 
 
 7import Welcome из "./Welcome" 
 
 8
 
 
 9function App() { 
 
 10 const [currentTab, setCurrentTab] = useState("логин") 
 
 11 const [userContext, setUserContext] = useContext(UserContext) 
 
 12
 
 
 13 const verifyUser = useCallback(() => { 
 
 14 fetch(process.env.REACT_APP_API_ENDPOINT + "users/refreshToken", { 
 
 15 метод: "POST", 
 
 16 учетные данные: "include", 
 
 17 заголовков: { "Content-Type": "application/json" }, 
 
 18 }).then(async response => { 
 
 19 if (response.ok) { 
 
 20 const data = await response.json() 
 
 21 setUserContext(oldValues ​​=> { 
 
 22 return { ... oldValues, token: data.token } 
 
 23 }) 
 
 24 } else { 
 
 25 setUserContext(oldValues ​​=> { 
 
 26 return { ...oldvalues, токен: NULL} 
 
 27}) 
 
 27}) 
 
 28} 
 
 29 
 
 30 Settimeate (VerifyUser, 5 * 60 * 1000) 
 
 31}) 
 
 31}, [SetuSercontext]) 
 
 33
 
 
 34 useEffect(() => { 
 
 35 verifyUser() 
 
 36 }, [verifyUser]) 
 
 37
 
 
 38 
 
 39 
 
 40 
 
 41 const syncLogout = useCallback(event => { 
 
 42 if (event.key === "logout") { 
 
 43 
 window.location.reload() 
 
 45 } 
 
 46 }, []) 
 
 47
 
 
 48 useEffect(() => { 
 
 49 window.addEventListener("storage", syncLogout) 
 
 50 return () => { 
 
 51 window.removeEventListener("storage", syncLogout) 
 503 9000} 
 53 }, [syncLogout]) 
 
 54
 
 
 55 вернуть userContext.token === null ? ( 
 
 56  
 
 57 <Вкладки onChange={setCurrentTab} selectedTabId={currentTab}> 
 
 58 } /> 
 
 59 } /> 
 
 60 <Вкладки.Expander /> 
 
 61  
 
 62  
 
 63 ) : userContext.token ? ( 
 
 64 <Добро пожаловать /> 
 
 65 ) : ( 
 
 66 <Загрузчик /> 
 
 67 ) 
 
 68} 
 
 69
 
 
 70экспорт приложения по умолчанию 
 

 ├──SRC 
 ├──SRC 
 ├───DB 
 ├───Controllers 
 ├───HELPERS 
 ├───middleware 
 ├────ODELS 
 └───ROUTES 
 ├───mODELS 
 └ ───services 
 index.js 
 app.js 
 Вы, наверное, согласитесь со мной, что  import  и  export  выглядят лучше, чем  требуют модулей  и .exports , поэтому давайте настроим Babel, чтобы наше приложение могло использовать синтаксис импорта ES6.
 В терминале (убедитесь, что на этот раз вы находитесь в корневой папке, а не в папке src) выполните следующие команды:
 npm i @babel/register @babel/runtimenpm i -D @babel/cli @ babel/core @babel/node @babel/preset-env 
 Еще в корневой папке создайте файл  .babelrc  и вставьте в него следующий код
 { 
 "presets": [ 
 [ 
 "@babel /preset-env", 
 { 
 "useBuiltIns": "usage", 
 "corejs": 3 
 } 
 ] 
 ] 
 } 
 После правильной настройки babel пришло время поработать в папке  src  .
   Во-первых, нам нужно установить еще несколько зависимостей:  
 npm i express cookie-parser cross-env debug dotenv morgan nodemon 
   И затем немного обработки ошибок  
3 Мы напишем функцию для перехвата асинхронных ошибок, другой для обработки ошибок и сообщений об ошибках в зависимости от нашей среды, а затем мы напишем несколько классов, расширяющих класс JavaScript Error, чтобы сделать наши сообщения об ошибках более конкретными. 
 Catch Async Errors
 Создайте новый файл в папке промежуточного ПО с именем  catchAsync.js  и скопируйте в него следующий код.
 В той же папке промежуточного ПО создайте файл  errorHandler.js  и добавьте следующий код:
 И, наконец, для наших классов ошибок создайте файл  errors.js  в папке помощников. Это должно выглядеть так:
 На данный момент у нас есть только два класса ошибок, но при необходимости мы можем увеличить их.
 Затем скопируйте следующий код в файл app.js.
 Наконец, в наш файл index.js мы импортируем наше приложение.js и создайте HTTP-сервер.
 Теперь создайте файл  .env  в корневой папке и настройте переменные среды.
 PORT=5000 
 NODE_ENV=development 
 Дальше идут сценарии! Нет, не несколько версий группы, а ваши сценарии package.json для запуска вашего приложения. Мы создадим сценарии  dev  ,  start  ,  build  ,  clean  и  build-babel  , чтобы мы могли запускать наше приложение в среде разработки или в рабочей среде.
 В файле package.json добавьте в свойство scripts следующие команды:
 "build": "npm run clean && npm run build-babel", 
 "build-babel": "babel -d ./build ./src -s", 
 "clean": "rm -rf .nyc_output покрытие сборки && mkdir build", 
 "dev": "cross-env DEBUG=dev nodemon --exec babel-node src/index.js" , 
 "start": "node ./build/index.js", 
 Сценарий  dev  запускает ваше приложение в режиме разработки, который мы и будем использовать.
 Сценарий сборки компилирует ваше приложение в папку сборки, преобразуя код ES6+ в обратно совместимую версию JavaScript в текущей и более старых средах.
 Стартовый сценарий запускает скомпилированное приложение NodeJS.
 Во второй статье мы интегрируем базу данных MongoDB и настроим PassportJS в нашем приложении.
  Этот проект доступен на   GitHub  , вы также можете подписаться на меня в Twitter  . 
 Создайте систему входа в Node.js. Как использовать Passport.js для пользователя… | by Hussain Arif 
 Пользовательская схема и модель 
 Как обычно, перед созданием документов и их сохранением в базе данных необходимо определить схему. Сначала создайте каталог  models  и создайте там файл с именем  user.js  таким образом, чтобы он был  models/user.js  . Во-первых, давайте создадим схему в  user.js . Далее мы создадим модель из этой схемы.
 В  models/user.js  :
 Это означает, что ваша модель будет иметь имя, адрес электронной почты, связанный с ней пароль и дату создания.
 В строке  20  мы используем эту схему в вашей модели  User . Все ваши пользователи будут иметь данные в этом формате.
 Обработка POST-запроса к каталогу реестра: проверки 
 На этом шаге вы создадите документ в базе данных MongoDB с данными, предоставленными клиентом.
 В начале файла  route/users.js  импортируйте библиотеку Mongoose и импортируйте только что созданную модель  User .
 const User = require("../models/user.js") 
 Теперь в файле  route/users.js  найдите следующий фрагмент кода:
 Обработка POST-запроса реестра
 Внутри этого дескриптора , напишите следующий код:
  Строка 1  : извлечение значений из элементов формы. Вы вынимаете почту, имя пользователя, его пароль. Последнее поле (  password2  ) является проверкой, чтобы убедиться, что пользователь подтвердил правильность вводимого им пароля.
  Строки 4-6  : Если какое-либо из полей не заполнено, добавьте соответствующее сообщение в массив  error .
  Строки 8–10  : Если пароли не совпадают, добавьте соответствующее сообщение в массив  error .
  Строки 13–15  : Проверьте, содержит ли пароль не менее шести символов.
  Строки 16–23  : Если присутствует какое-либо содержимое в массиве  error , повторно визуализируйте регистр .ejs , а затем отправьте соответствующие данные вместе с массивом ошибок  . Все содержимое этого массива будет отображаться на странице.
  Строки 24–36  : Вы успешно прошли проверку! Теперь вы сначала узнаете, есть ли уже пользователь в базе данных по электронной почте. Если есть, то вы повторно отобразите страницу  register.ejs  и отобразите соответствующую ошибку. В противном случае создайте нового пользователя с указанным адресом электронной почты, именем и соответствующим паролем.Имейте в виду, что вы еще не сохранили его. Вы сохраните его после шифрования пароля.
 В качестве примера запустим код и введем односимвольный пароль, чтобы он перерендерил страницу:
 Вывод кода после намеренного ввода неправильных параметров
 Теперь вам нужно отобразить ошибки, т.е. , отобразите содержимое массива  ошибок .
 Отображение ошибок 
 Теперь перейдите к  views/register.ejs  и найдите следующий фрагмент кода (это будет примерно в начале файла):
 Код для поиска в views/register.ejs
 Когда вы его найдете, напишите следующую строку прямо под этим тегом  h2 :
 <%- include ('./partials/messages') %> 
 Эта строка означает импорт нового файла, который поможет отображать сообщения.
 Перейдите в каталог  views , создайте новый каталог с именем  partials  и внутри  partials  создайте файл с именем  messages.ejs  . Там напишите следующий код.
  просмотров/частей/сообщений.ejs 
 <% if(typeof errors!= 'undefined') { %> 
 <% errors.forEach(function(error){ %> 
 
 <%= error.msg %>
 
 <% }) %> 
 <% } %> 
 Этот код говорит, что если есть какие-либо ошибки, то отображать содержимое массива с его собственным элементом абзаца (  p  ).
 Повторно запустите код и напишите односимвольный пароль. Это будет вывод:
 Обратите внимание, что вы теперь отобразили сообщение об ошибке
 Если вы оставите какое-либо из полей пустым, вы получите следующее сообщение об ошибке:
 В этой форме отображаются два сообщения об ошибке
 Заставьте оба поля пароля содержать разные значения :
 В этой форме отображаются три сообщения об ошибках
 Обработка POST-запросов к реестру: сохранение пользователей в базе данных 
 На этом шаге вы сохраните зарегистрированных пользователей в базе данных MongoDB.Сначала вы зашифруете их пароли, а затем сохраните их в базе данных.
 В  route/users.js  найдите следующий фрагмент кода:
 Код в route/users.js
 В этом блоке  else  напишите следующий фрагмент кода:
 И на этой ноте завершите  еще  утверждение здесь.
  Строки 2–7 : Генерация соли, хэш пароля пользователя. Назначьте это зашифрованное значение паролю пользователя, а затем сохраните клиента в базе данных.
  Строка 10  : Когда документ будет сохранен без ошибок, перенаправьте пользователя в каталог  login , где пользователь теперь войдет в систему со своими учетными данными.
 Это будет вывод кода, когда вы зарегистрируетесь в качестве пользователя:
 Вывод кода
 Поскольку вы вышли из системы из содержимого документа в своей консоли, вот вывод в консоли:
 Содержание документа newUser
 Введите зарегистрированный адрес электронной почты. Как и ожидалось, вы получаете сообщение об ошибке, говорящее о том, что электронное письмо уже сохранено:
 Вывод кода, показывающий, что у вас есть ошибка
 На этом шаге вы, наконец, сохранили пользователей в базе данных.