Som udvikler er det dit ansvar at beskytte dine brugeres data gennem autentificering. Du kan bruge Passport.js til at godkende brugere i en Node- og Postgres-applikation.
Start med at oprette en nodeserver med slutpunkter til at registrere, logge på og logge ud brugere. Du kan lade Passport håndtere godkendelse for at begrænse uautoriseret adgang til din applikation.
Oprettelse af en brugertabel
Til brugergodkendelse skal du bruge en e-mail og en adgangskode. Det betyder, at brugertabellen skal indeholde en e-mail- og et kodeordsfelt. I psql-kommandoprompten skal du oprette en ny database kaldet nodeapp:
SKABDATABASE nodeapp;
Opret derefter en tabel til at gemme brugerne:
SKABBORDbrugere (
ID INT GENERERET ALTID SOM IDENTITETSPRIMÆR NØGLE,
e-mail CHAR(128),
adgangskode CHAR(60)
);
Denne kode vil oprette en ny tabel, der indeholder e-mail, adgangskode og et automatisk genereret ID-felt.
Oprettelse af en nodeserver
Node.js er et JavaScript-runtime-miljø på serversiden, der giver os mulighed for hurtigt at oprette HTTP-servere. For at forenkle processen med at oprette serveren og forskellige HTTP-ruter, kan du bruge
Express, en Node.js-webramme.Kør denne kommando for at oprette en ny mappe kaldet postgres-auth:
mkdir postgres-auth
Dernæst initialiser npm:
npm init -y
Til sidst skal du installere Express:
npm install Express
Det kan du nu oprette Node-webserveren.
I en ny fil kaldet index.js, tilføj følgende:
konst udtrykke = kræve("udtryk");
konst app = express();
app.use (express.json());
app.use (express.urlencoded({ udvidet: rigtigt }));
app.lyt(3000, () => konsol.log("Lytter på port 3000"));
Ved at køre denne kode starter serveren og logger følgende i konsollen:
Lytter på port 3000Opretter forbindelse til PostgreSQL
Til opret forbindelse til PostgreSQL brug node-postgres. node-postgres er en forbindelsesdriver, der giver en grænseflade mellem Node og Postgres.
Udfør følgende for at installere node-postrges via npm:
npm installer s
Når du har installeret det bibliotek, skal du oprette en ny fil kaldet db.js og tilslut den til databasen:
konst { Klient } = kræve("pg");
konst { bruger, vært, database, adgangskode, port } = kræve("./dbConfig");konst klient = ny Klient({
bruger,
vært,
database,
adgangskode,
Havn,
});
client.connect();
modul.exports = klient;
Klientmetoden fra node-postgres tager detaljerne i den database, du opretter forbindelse til. Dette program importerer dets forbindelsesdetaljer fra en fil kaldet dbConfig. Derfor skal du oprette denne fil og tilføje følgende kode til den:
modul.exports = {
bruger: "postgres",
vært: "localhost",
database: "nodeapp",
adgangskode: "dit kodeord",
Havn: 5432,
};
Opret databasehjælpefunktioner
Det er altid god praksis at bruge individuelle funktioner til at interagere med databasen. De gør det nemt at skrive enhedstests og forbedrer genanvendeligheden. For tilmeldingsslutpunktet skal du oprette to funktioner:
- For at kontrollere, om e-mailen allerede er registreret.
- At oprette brugeren.
Målet er kun at registrere en bruger, hvis de ikke findes i databasen.
Opret en ny fil kaldet helper.js og importer databaseklienten fra db.js:
konst klient = kræve("./db.js")
Tilføj derefter en ny funktion kaldet emailExists():
konst emailEksisterer = asynkron (e-mail) => {
konst data = vente client.query("VÆLG * FRA brugere WHERE email=$1", [
e-mail,
]);
hvis (data.rowCount == 0) Vend tilbagefalsk;
Vend tilbage data.rows[0];
};
Denne funktion tager en e-mail og tjekker, om den allerede er i brug. Det gør det ved at bruge SELECT-sætningen, der returnerer en række, der har et e-mail-felt, der matcher den værdi, der er angivet af den registrerende bruger. Hvis e-mailen ikke findes, returnerer den falsk.
For at oprette en funktion, der opretter brugeren, skal du tilføje en funktion kaldet createUser() til helper.js:
konst opretteBruger = asynkron (e-mail, adgangskode) => {
konst salt = vente bcrypt.genSalt(10);
konst hash = vente bcrypt.hash (adgangskode, salt);konst data = vente klient.forespørgsel(
"INDSÆT I brugere (e-mail, adgangskode) VÆRDIER ($1, $2) RETURNERENDE id, e-mail, adgangskode",
[e-mail, hash]
);
hvis (data.rowCount == 0) Vend tilbagefalsk;
Vend tilbage data.rows[0];
};
Denne funktion tager værdierne for e-mail og adgangskode. Den bruger INSERT-klausulen til at oprette en ny række med disse detaljer og returnerer den nyoprettede bruger, hvis den lykkes. Bemærk, at før du gemmer adgangskoden, bør du hash det ved hjælp af bcrypt. Det er aldrig en god idé at gemme adgangskoder som almindelig tekst. Hvis hackere fik adgang til din brugerdatabase, kunne de nemt få adgang til følsomme oplysninger.
Installer bcryptjs for at begynde at bruge det:
npm installer bcryptjs
I helper.js skal du importere bcryptjs:
konst bcrypt = kræve("bcryptjs")
Ved at bruge Bcryptjs gemmer databasen kun den krypterede adgangskode. Derfor skal du under login sammenligne den almindelige tekstadgangskode givet af brugeren og den hash-kodede adgangskode i databasen. Til dette kan du bruge sammenligningsmetoden leveret af Bcryptjs.
Opret en funktion kaldet matchPassword():
konst matchPassword = asynkron (adgangskode, hashPassword) => {
konst match = vente bcrypt.compare (adgangskode, hashPassword);
Vend tilbage match
};
Den modtager den almindelige adgangskode og hashen og bruger derefter Bcrypt.compare() til at afgøre, om den angivne adgangskode er korrekt. Hvis det er, returnerer det sandt, ellers returnerer det falsk.
Det er alle de funktioner, vi vil bruge til at interagere med databasen. Sørg for at eksportere dem alle til sidst:
modul.exports = { emailExists, createUser, matchPassword };
Konfigurer pas
Passport er en Node-godkendelses-middleware, der giver over 500 autentificeringsstrategier som socialt login, JSON Web Tokens (JWT) og e-mail-godkendelse. Vi vil bruge sidstnævnte, som den pas-lokale strategi giver.
Brug følgende kommando til at installere pas og pas-lokal:
npm installere pas
npm installere pas-lokalt
Konfigurer derefter Passport til at logge på eksisterende brugere og registrere nye brugere.
Start med at oprette en ny fil passportConfig.js. Importer derefter den lokale Passport-strategi og de databasehjælpefunktioner, du lige har oprettet:
konst Lokal Strategi = kræve("pas-lokal");
konst { emailExists, createUser, matchPassword } = kræve("./hjælper");
Tilføj følgende i samme fil for at konfigurere brugertilmelding:
modul.exports = (pas) => {
pas.brug(
"lokal tilmelding",
ny Lokal Strategi(
{
brugernavnFelt: "e-mail",
passwordField: "adgangskode",
},
asynkron (e-mail, adgangskode, færdig) => {
prøve {
konst brugereksisterer = vente emailEksisterer (e-mail)hvis (brugereksisterer) {
Vend tilbage Færdig(nul, falsk);
}
konst bruger = vente createUser (e-mail, adgangskode);
Vend tilbage Færdig(nul, bruger);
} fangst (fejl) {
udført (fejl);
}
}
)
);
}
Da passport-local forventer et brugernavn og en adgangskode, og du bruger en e-mail, skal du indstille brugernavnfeltet til en e-mail. Brugeren eller snarere frontend-delen af denne applikation vil sende e-mailen og adgangskoden i anmodningens brødtekst. Du behøver dog ikke selv at udtrække værdierne, da Passport håndterer det i baggrunden.
Dette program kontrollerer først, om e-mailen allerede er taget ved hjælp af funktionen emailExists() fra helper.js. Hvis e-mailen ikke findes i databasen, opretter den en ny bruger med funktionen createUser(). Til sidst returnerer den brugerobjektet.
For at logge på brugere skal du tilføje følgende til passportConfig.js:
modul.exports = (pas) => {
pas.brug(
"lokal tilmelding",
ny Lokal Strategi(
// Tilmelde
)
);
pas.brug(
"lokal-login",
ny Lokal Strategi(
{
brugernavnFelt: "e-mail",
passwordField: "adgangskode",
},
asynkron (e-mail, adgangskode, færdig) => {
prøve {
konst bruger = vente emailEksisterer (e-mail);
hvis (!bruger) Vend tilbage Færdig(nul, falsk);
konst isMatch = vente matchPassword (adgangskode, bruger.password);
hvis (!isMatch) Vend tilbage Færdig(nul, falsk);
Vend tilbage Færdig(nul, {id: bruger ID, e-mail: bruger.e-mail});
} fangst (fejl) {
Vend tilbage udført (fejl, falsk);
}
}
)
);
};
Her tjekker programmet først, om mailen er registreret. Hvis ikke, returnerer den falsk. Hvis den finder e-mailen, sammenligner den sin adgangskode med den fra anmodningen. Hvis adgangskoden matcher, logger den på brugeren og returnerer brugerobjektet.
Det sidste trin er at oprette API-endepunkterne:
- POST /auth/signup
- POST /auth/login
Begge disse endepunkter modtager en e-mail og adgangskode i anmodningens brødtekst. De vil også inkludere de pasgodkendelses-middleware-funktioner, vi lige har konfigureret.
Importer og opsæt Passport i en ny fil med navnet server.js:
konst pas = kræve("pas");
kræve("./passportConfig")(pas);
Tilføj derefter følgende ruter:
app.post(
"/auth/Tilmelde",
passport.authenticate("local-signup", { session: falsk }),
(req, res, næste) => {
res.json({
bruger: req.bruger,
});
}
);
app.post(
"/auth/Log på",
passport.authenticate("local-login", { session: falsk }),
(req, res, næste) => {
res.json({ bruger: req.user });
}
);
Begge disse ruter returnerer et JSON-objekt, der indeholder brugeren, hvis det lykkes.
Tjek din API ved hjælp af enhedstests
Du kan bruge Passport til at godkende en Node-applikation ved hjælp af en PostgreSQL-applikation. Du har oprettet API-endepunkter for at tilmelde dig og logge på brugere.
Mens du kan bruge REST-klienter som Postman til at teste, hvor godt en API fungerer, er det meget nemmere at skrive enhedstests. Enhedstest giver dig mulighed for at teste de enkelte dele af din applikation. På denne måde, selvom et slutpunkt fejler, kan du lokalisere det nøjagtige punkt for fejl. Et af de værktøjer, du kan bruge til at teste Node-applikationer, er Jest.
