Som utvikler er det ditt ansvar å beskytte brukernes data gjennom autentisering. Du kan bruke Passport.js til å autentisere brukere i en Node- og Postgres-applikasjon.
Start med å opprette en nodeserver med endepunkter for å registrere, logge på og logge ut brukere. Du kan la Passport håndtere autentisering for å begrense uautorisert tilgang til applikasjonen din.
Opprette en brukertabell
For brukerautentisering vil du bruke en e-post og et passord. Dette betyr at brukertabellen må inneholde en e-post og et passordfelt. I psql-ledeteksten oppretter du en ny database kalt nodeapp:
SKAPEDATABASE nodeapp;
Deretter oppretter du en tabell for å lagre brukerne:
SKAPEBORDbrukere (
ID INT GENERERT ALLTID SOM IDENTITETSPRIMÆR NØKKEL,
e-post CHAR(128),
passord CHAR(60)
);
Denne koden vil opprette en ny tabell som inneholder e-post, passord og et autogenerert ID-felt.
Opprette en nodeserver
Node.js er et JavaScript-runtime-miljø på serversiden som lar oss lage HTTP-servere raskt. For å forenkle prosessen med å lage serveren og forskjellige HTTP-ruter, kan du bruke Express, et Node.js-nettrammeverk.
Kjør denne kommandoen for å opprette en ny mappe kalt postgres-auth:
mkdir postgres-auth
Deretter initialiser npm:
npm init -y
Til slutt, installer Express:
npm install express
Du kan nå opprette Node-webserveren.
I en ny fil som heter index.js, legg til følgende:
konst uttrykke = krever("uttrykke");
konst app = express();
app.use (express.json());
app.use (express.urlencoded({ forlenget: ekte }));
app.listen(3000, () => konsoll.log("Lytter på port 3000"));
Å kjøre denne koden vil starte serveren og logge følgende i konsollen:
Lytter på port 3000Kobler til PostgreSQL
Til koble til PostgreSQL bruk node-postgres. node-postgres er en tilkoblingsdriver som gir et grensesnitt mellom Node og Postgres.
Utfør følgende for å installere node-postrges via npm:
npm installer s
Når du har installert det biblioteket, oppretter du en ny fil som heter db.js og koble den til databasen:
konst { Klient } = krever("pg");
konst { bruker, vert, database, passord, port } = krever("./dbConfig");konst klient = ny Klient({
bruker,
vert,
database,
passord,
havn,
});
client.connect();
modul.exports = klient;
Klientmetoden fra node-postgres tar detaljene i databasen du kobler til. Dette programmet importerer tilkoblingsdetaljer fra en fil kalt dbConfig. Opprett derfor filen og legg til følgende kode til den:
modul.exports = {
bruker: "postgres",
vert: "localhost",
database: "nodeapp",
passord: "dittPassord",
havn: 5432,
};
Opprett databasehjelpefunksjoner
Det er alltid god praksis å bruke individuelle funksjoner for å samhandle med databasen. De gjør det enkelt å skrive enhetstester og forbedrer gjenbrukbarheten. For registreringsendepunktet må du opprette to funksjoner:
- For å sjekke om e-posten allerede er registrert.
- For å opprette brukeren.
Målet er kun å registrere en bruker hvis de ikke finnes i databasen.
Opprett en ny fil kalt helper.js og importer databaseklienten fra db.js:
konst klient = krever("./db.js")
Deretter legger du til en ny funksjon kalt emailExists():
konst emailExists = asynkron (e-post) => {
konst data = avvente client.query("VELG * FRA brukere WHERE email=$1", [
e-post,
]);
hvis (data.rowCount == 0) komme tilbakefalsk;
komme tilbake data.rows[0];
};
Denne funksjonen tar en e-post og sjekker om den allerede er i bruk. Den gjør dette ved å bruke SELECT-klausulen som returnerer en rad som har et e-postfelt som samsvarer med verdien oppgitt av den registrerende brukeren. Hvis e-posten ikke eksisterer, returnerer den falsk.
For å lage en funksjon som oppretter brukeren, legg til en funksjon kalt createUser() til helper.js:
konst createUser = asynkron (e-post, passord) => {
konst salt = avvente bcrypt.genSalt(10);
konst hasj = avvente bcrypt.hash (passord, salt);konst data = avvente client.query(
"SETT INN I brukere (e-post, passord) VERDIER ($1, $2) RETURNERING ID, e-post, passord",
[e-post, hash]
);
hvis (data.rowCount == 0) komme tilbakefalsk;
komme tilbake data.rows[0];
};
Denne funksjonen tar e-post- og passordverdiene. Den bruker INSERT-klausulen for å lage en ny rad med disse detaljene, og hvis vellykket returnerer den nyopprettede brukeren. Merk at før du lagrer passordet, bør du hash det ved hjelp av bcrypt. Det er aldri en god idé å lagre passord som ren tekst. Hvis hackere fikk tilgang til brukerdatabasen din, kunne de enkelt få tilgang til sensitiv informasjon.
Installer bcryptjs for å begynne å bruke det:
npm installer bcryptjs
I helper.js, importer bcryptjs:
konst bcrypt = krever("bcryptjs")
Ved å bruke Bcryptjs lagrer databasen kun det krypterte passordet. Derfor, under pålogging, må du sammenligne ren tekstpassordet som er gitt av brukeren, og det hash-kodede passordet i databasen. For dette kan du bruke sammenligningsmetoden levert av Bcryptjs.
Lag en funksjon kalt matchPassword():
konst matchPassword = asynkron (passord, hashPassword) => {
konst match = avvente bcrypt.compare (passord, hashPassword);
komme tilbake kamp
};
Den mottar det vanlige passordet og hashen og bruker deretter Bcrypt.compare() for å finne ut om passordet som er oppgitt er riktig. Hvis det er det, returnerer det sant ellers returnerer det usant.
Dette er alle funksjonene vi skal bruke for å samhandle med databasen. Sørg for å eksportere alle på slutten:
modul.exports = { emailExists, createUser, matchPassword };
Konfigurer Passport
Passport er en mellomvare for nodeautentisering som gir over 500 autentiseringsstrategier som sosial pålogging, JSON Web Tokens (JWT) og e-postautentisering. Vi vil bruke sistnevnte som den pass-lokale strategien gir.
Bruk følgende kommando for å installere passport og passport-local:
npm installere pass
npm installere pass-lokalt
Deretter konfigurerer du Passport for å logge på eksisterende brukere og registrere nye brukere.
Start med å lage en ny fil passportConfig.js. Importer deretter den lokale Passport-strategien og databasehjelpefunksjonene du nettopp opprettet:
konst Lokal Strategi = krever("pass-lokal");
konst { emailExists, createUser, matchPassword } = krever("./hjelper");
I samme fil legger du til følgende for å konfigurere brukerregistrering:
modul.exports = (pass) => {
passport.use(
"lokal registrering",
ny lokal strategi(
{
brukernavnfelt: "e-post",
passordfelt: "passord",
},
asynkron (e-post, passord, ferdig) => {
prøve {
konst brukereksisterer = avvente e-posteksisterer (e-post)hvis (brukereksisterer) {
komme tilbake ferdig(null, falsk);
}
konst bruker = avvente createUser (e-post, passord);
komme tilbake ferdig(null, bruker);
} å fange (feil) {
gjort (feil);
}
}
)
);
}
Siden passport-local forventer et brukernavn og et passord, og du bruker en e-post, sett brukernavnfeltet til en e-post. Brukeren eller rettere sagt frontend-delen av denne applikasjonen vil sende e-post og passord i forespørselsteksten. Du trenger imidlertid ikke å trekke ut verdiene selv, da Passport vil håndtere det i bakgrunnen.
Dette programmet sjekker først om e-posten allerede er tatt med funksjonen emailExists() fra helper.js. Hvis e-posten ikke finnes i databasen, oppretter den en ny bruker med createUser()-funksjonen. Til slutt returnerer den brukerobjektet.
For å logge på brukere, legg til følgende i passportConfig.js:
modul.exports = (pass) => {
passport.use(
"lokal registrering",
ny lokal strategi(
// melde deg på
)
);
passport.use(
"lokal-pålogging",
ny lokal strategi(
{
brukernavnfelt: "e-post",
passordfelt: "passord",
},
asynkron (e-post, passord, ferdig) => {
prøve {
konst bruker = avvente emailExists (e-post);
hvis (!bruker) komme tilbake ferdig(null, falsk);
konst isMatch = avvente matchPassword (passord, bruker.passord);
hvis (!isMatch) komme tilbake ferdig(null, falsk);
komme tilbake ferdig(null, {id: bruker-ID, e-post: bruker.e-post});
} å fange (feil) {
komme tilbake gjort (feil, falsk);
}
}
)
);
};
Her sjekker programmet først om e-posten er registrert. Hvis ikke, returnerer den falsk. Hvis den finner e-posten, sammenligner den passordet med det fra forespørselen. Hvis passordene samsvarer, logger den på brukeren og returnerer brukerobjektet.
Det siste trinnet er å lage API-endepunktene:
- POST /auth/registrering
- POST /auth/login
Begge disse endepunktene vil motta en e-post og et passord i forespørselsteksten. De vil også inkludere mellomvarefunksjonene for passautentisering vi nettopp konfigurerte.
Importer og sett opp Passport i en ny fil med navnet server.js:
konst pass = krever("pass");
krever("./passportConfig")(pass);
Deretter legger du til følgende ruter:
app.post(
"/auth/melde deg på",
passport.authenticate("local-signup", { økt: falsk }),
(req, res, neste) => {
res.json({
bruker: req.user,
});
}
);
app.post(
"/auth/Logg Inn",
passport.authenticate("local-login", { økt: falsk }),
(req, res, neste) => {
res.json({ bruker: req.user });
}
);
Begge disse rutene returnerer et JSON-objekt som inneholder brukeren hvis vellykket.
Sjekk API-en din ved å bruke enhetstester
Du kan bruke Passport til å autentisere en Node-applikasjon ved hjelp av en PostgreSQL-applikasjon. Du opprettet API-endepunkter for å registrere deg og logge på brukere.
Mens du kan bruke REST-klienter som Postman for å teste hvor godt et API fungerer, er det mye enklere å skrive enhetstester. Enhetstester lar deg teste de enkelte delene av applikasjonen din. På denne måten, selv om et endepunkt mislykkes, kan du finne det nøyaktige punktet for feilen. Et av verktøyene du kan bruke for å teste Node-applikasjoner er Jest.