Jako vývojář je vaší odpovědností chránit data vašich uživatelů prostřednictvím ověřování. Passport.js můžete použít k ověření uživatelů v aplikaci Node a Postgres.

Začněte vytvořením serveru Node s koncovými body pro registraci, přihlašování a odhlašování uživatelů. Můžete nechat službu Passport zpracovávat ověřování a omezit tak neoprávněný přístup k vaší aplikaci.

Vytvoření tabulky uživatelů

Pro ověření uživatele budete používat e-mail a heslo. To znamená, že tabulka uživatelů musí obsahovat pole pro e-mail a heslo. V příkazovém řádku psql vytvořte novou databázi s názvem nodeapp:

VYTVOŘITDATABÁZE nodeapp;

Dále vytvořte tabulku pro uložení uživatelů:

VYTVOŘITSTŮLuživatelů (
 id INT GENEROVÁNO VŽDY JAKO PRIMÁRNÍ KLÍČ IDENTITY,
 email CHAR(128),
 heslo CHAR(60)
);

Tento kód vytvoří novou tabulku obsahující e-mail, heslo a automaticky vygenerované pole ID.

Vytvoření uzlového serveru

Node.js je běhové prostředí JavaScriptu na straně serveru, které nám umožňuje rychle vytvářet servery HTTP. Chcete-li zjednodušit proces vytváření serveru a různých tras HTTP, můžete použít

Express, webový rámec Node.js.

Spuštěním tohoto příkazu vytvořte novou složku s názvem postgres-auth:

mkdir postgres-auth

Dále inicializujte npm:

npm init -y

Nakonec nainstalujte Express:

npm install express

Teď můžeš vytvořte webový server Node.

V novém souboru s názvem index.js, přidejte následující:

konst vyjádřit = vyžadovat("vyjádřit");
konst app = express();
app.use (express.json());
app.use (express.urlencoded({ prodloužený: skutečný }));
app.listen(3000, () => řídicí panel.log("Poslouchání na portu 3000"));

Spuštěním tohoto kódu se spustí server a do konzoly se přihlásí následující:

Poslech na portu 3000

Připojení k PostgreSQL

Na připojit k PostgreSQL použití node-postgres. node-postgres je ovladač připojení, který poskytuje rozhraní mezi Node a Postgres.

Chcete-li nainstalovat node-postrges přes npm, proveďte následující:

npm instalace str

Jakmile tuto knihovnu nainstalujete, vytvořte nový soubor s názvem db.js a připojte jej k databázi:

konst { Klient } = vyžadovat("pg");
konst { uživatel, hostitel, databáze, heslo, port } = vyžadovat(./dbConfig");
konst klient = Nový Klient({
 uživatel,
 hostitel,
 databáze,
 Heslo,
 přístav,
});
client.connect();
modul.export = klient;

Metoda klienta z node-postgres bere podrobnosti o databázi, ke které se připojujete. Tento program importuje podrobnosti o připojení ze souboru s názvem dbConfig. Vytvořte proto tento soubor a přidejte do něj následující kód:

modul.exports = {
 uživatel: "postgres",
 hostitel: "localhost",
 databáze: "nodeapp",
 heslo: "vaše heslo",
 přístav: 5432,
};

Vytvořit pomocné funkce databáze

Vždy je dobré používat jednotlivé funkce k interakci s databází. Usnadňují psaní jednotkových testů a zlepšují opětovnou použitelnost. Pro koncový bod registrace musíte vytvořit dvě funkce:

  1. Chcete-li zkontrolovat, zda je e-mail již zaregistrován.
  2. Chcete-li vytvořit uživatele.

Cílem je zaregistrovat uživatele pouze v případě, že v databázi neexistuje.

Vytvořte nový soubor s názvem helper.js a importujte databázového klienta z db.js:

konst klient = vyžadovat(./db.js")

Dále přidejte novou funkci s názvem emailExists():

konst emailExistuje = asynchronní (e-mail) => {
konst údaje = čekat client.query("SELECT * FROM users WHERE email=$1", [
 e-mailem,
 ]);
-li (data.rowCount == 0) vrátit seNepravdivé; 
vrátit se data.rows[0];
};

Tato funkce přijme e-mail a zkontroluje, zda se již nepoužívá. Dělá to pomocí klauzule SELECT, která vrací řádek s polem e-mailu, které odpovídá hodnotě poskytnuté registrujícím uživatelem. Pokud e-mail neexistuje, vrátí hodnotu false.

Chcete-li vytvořit funkci, která vytvoří uživatele, přidejte funkci s názvem createUser() do helper.js:

konst createUser = asynchronní (e-mail, heslo) => {
konst sůl = čekat bcrypt.genSalt(10);
konst hash = čekat bcrypt.hash (heslo, sůl);
konst údaje = čekat client.query(
 "INSERT INTO users (e-mail, heslo) VALUES ($1, $2) VRÁCENÍ ID, e-mail, heslo",
 [e-mail, hash]
 );
-li (data.rowCount == 0) vrátit seNepravdivé;
vrátit se data.rows[0];
};

Tato funkce přebírá hodnoty e-mailu a hesla. Pomocí klauzule INSERT vytvoří nový řádek s těmito podrobnostmi a v případě úspěchu vrátí nově vytvořeného uživatele. Pamatujte, že před uložením hesla byste měli hash to pomocí bcrypt. Nikdy není dobrý nápad ukládat hesla jako prostý text. Pokud hackeři získali přístup k vaší uživatelské databázi, mohli by se snadno dostat k citlivým informacím.

Chcete-li jej začít používat, nainstalujte si bcryptjs:

npm nainstalovat bcryptjs

V helper.js importujte bcryptjs:

konst bcrypt = vyžadovat("bcryptjs")

Při použití Bcryptjs databáze ukládá pouze zašifrované heslo. Proto během přihlašování budete muset porovnat heslo ve formátu prostého textu zadané uživatelem a heslo hashované v databázi. K tomu můžete použít metodu porovnání poskytovanou Bcryptjs.

Vytvořte funkci s názvem matchPassword():

konst matchPassword = asynchronní (heslo, hashPassword) => {
konst zápas = čekat bcrypt.compare (heslo, hashPassword);
vrátit se zápas
};

Přijme prosté heslo a hash a poté pomocí Bcrypt.compare() určí, zda je poskytnuté heslo správné. Pokud ano, vrátí hodnotu true, jinak vrátí hodnotu false.

To jsou všechny funkce, které budeme používat k interakci s databází. Nezapomeňte je na konci exportovat všechny:

modul.exports = { emailExists, createUser, matchPassword };

Nakonfigurujte Passport

Passport je middleware pro ověřování uzlů, který poskytuje více než 500 strategií ověřování, jako je sociální přihlášení, JSON Web Tokeny (JWT) a ověřování e-mailů. Budeme používat to druhé, které poskytuje místní strategie pasů.

K instalaci passport a passport-local použijte následující příkaz:

npm instalační pas
npm install passport-local

Dále nakonfigurujte službu Passport pro přihlášení stávajících uživatelů a registraci nových uživatelů.

Začněte vytvořením nového souboru passportConfig.js. Poté importujte místní strategii Passport a pomocné funkce databáze, které jste právě vytvořili:

konst LocalStrategy = vyžadovat("pas-místní");
konst { emailExists, createUser, matchPassword } = vyžadovat("./pomocník");

Ve stejném souboru přidejte následující pro nastavení registrace uživatele:

modul.exports = (pas) => {
 passport.use(
 "místní registrace",
Nový LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "heslo",
 },
asynchronní (e-mail, heslo, hotovo) => {
Snaž se {
konst userExists = čekat emailExists (e-mail)
-li (userExists) {
vrátit se Hotovo(nula, Nepravdivé);
 }
konst uživatel = čekat createUser (e-mail, heslo);
vrátit se Hotovo(nula, uživatel);
 } úlovek (chyba) {
 hotovo (chyba);
 }
 }
 )
 );
}

Protože passport-local očekává uživatelské jméno a heslo a vy používáte e-mail, nastavte pole uživatelského jména na e-mail. Uživatel nebo spíše frontendová část této aplikace zašle email a heslo v těle požadavku. Hodnoty však nemusíte extrahovat sami, protože Passport to zvládne na pozadí.

Tento program nejprve zkontroluje, zda je e-mail již přijat pomocí funkce emailExists() z helper.js. Pokud e-mail v databázi neexistuje, vytvoří nového uživatele pomocí funkce createUser(). Nakonec vrátí objekt uživatele.

Chcete-li přihlásit uživatele, přidejte do passportConfig.js následující:

modul.exports = (pas) => {
 passport.use(
 "místní registrace",
Nový LocalStrategy(
// Přihlásit se
 )
 );
 passport.use(
 "místní přihlášení",
Nový LocalStrategy(
 {
 usernameField: "e-mail",
 passwordField: "heslo",
 },
asynchronní (e-mail, heslo, hotovo) => {
Snaž se {
konst uživatel = čekat emailExists (e-mail);
-li (!uživatel) vrátit se Hotovo(nula, Nepravdivé);
konst isMatch = čekat matchPassword (heslo, user.password);
-li (!isMatch) vrátit se Hotovo(nula, Nepravdivé);
vrátit se Hotovo(nula, {id: uživatelské ID, e-mailem: user.email});
 } úlovek (chyba) {
vrátit se hotovo (chyba, Nepravdivé);
 }
 }
 )
 );
};

Zde program nejprve zkontroluje, zda je email zaregistrován. Pokud ne, vrátí false. Pokud e-mail najde, porovná jeho heslo s heslem z požadavku. Pokud se hesla shodují, přihlásí uživatele a vrátí objekt uživatele.

Posledním krokem je vytvoření koncových bodů API:

  • POST /auth/registrace
  • POST /auth/login

Oba tyto koncové body obdrží e-mail a heslo v těle žádosti. Budou také zahrnovat funkce middlewaru pro ověřování pasů, které jsme právě nakonfigurovali.

Importujte a nastavte Passport v novém souboru s názvem server.js:

konst pas = vyžadovat("cestovní pas");
vyžadovat(./passportConfig")(pas);

Poté přidejte následující trasy:

app.post(
 "/auth/Přihlásit se",
 passport.authenticate("local-signup", { zasedání: Nepravdivé }),
 (req, res, next) => {
 res.json({
 uživatel: req.user,
 });
 }
);
app.post(
 "/auth/přihlásit se",
 passport.authenticate("local-login", { zasedání: Nepravdivé }),
 (req, res, next) => {
 res.json({ uživatel: req.user });
 }
);

Obě tyto trasy v případě úspěchu vrátí objekt JSON obsahující uživatele.

Zkontrolujte své API pomocí testů jednotek

Passport můžete použít k ověření aplikace Node pomocí aplikace PostgreSQL. Vytvořili jste koncové body API pro registraci a přihlášení uživatelů.

I když můžete použít klienty REST, jako je Postman, abyste otestovali, jak dobře funguje rozhraní API, psaní jednotkových testů je mnohem jednodušší. Unit testy vám umožní otestovat jednotlivé části vaší aplikace. Tímto způsobem, i když selže koncový bod, můžete určit přesný bod selhání. Jedním z nástrojů, který můžete použít k testování aplikací Node, je Jest.