Som utvecklare är det ditt ansvar att skydda dina användares data genom autentisering. Du kan använda Passport.js för att autentisera användare i en Node- och Postgres-applikation.
Börja med att skapa en nodserver med slutpunkter för att registrera, logga in och logga ut användare. Du kan låta Passport hantera autentisering för att begränsa obehörig åtkomst till din applikation.
Skapa en användartabell
För användarautentisering kommer du att använda en e-post och ett lösenord. Detta innebär att användartabellen måste innehålla ett e-post- och ett lösenordsfält. Skapa en ny databas som heter nodeapp i psql-kommandotolken:
SKAPADATABAS nodeapp;
Skapa sedan en tabell för att lagra användarna:
SKAPATABELLanvändare (
ID INT GENERERAS ALLTID SOM IDENTITETSPRIMÄRNYCKEL,
e-post CHAR(128),
lösenord CHAR(60)
);
Denna kod skapar en ny tabell som innehåller e-post, lösenord och ett autogenererat ID-fält.
Skapa en nodserver
Node.js är en JavaScript-runtimemiljö på serversidan som gör att vi snabbt kan skapa HTTP-servrar. För att förenkla processen att skapa servern och olika HTTP-rutter kan du använda
Express, ett webbramverk för Node.js.Kör det här kommandot för att skapa en ny mapp som heter postgres-auth:
mkdir postgres-auth
Initiera sedan npm:
npm init -y
Slutligen, installera Express:
npm installera express
Du kan nu skapa nodens webbserver.
I en ny fil som heter index.js, lägg till följande:
konst uttrycka = behöva("uttrycka");
konst app = express();
app.use (express.json());
app.use (express.urlencoded({ förlängt: Sann }));
app.lyssna(3000, () => trösta.log("Lyssnar på port 3000"));
Om du kör den här koden startar servern och loggar följande i konsolen:
Lyssnar på port 3000Ansluter till PostgreSQL
Till anslut till PostgreSQL använda sig av nod-postgres. node-postgres är en anslutningsdrivrutin som tillhandahåller ett gränssnitt mellan Node och Postgres.
Utför följande för att installera nodpostrges via npm:
npm installera sid
När du har installerat det biblioteket skapar du en ny fil som heter db.js och anslut den till databasen:
konst { Client } = behöva("pg");
konst { användare, värd, databas, lösenord, port } = behöva("./dbConfig");konst klient = ny Klient({
användare,
värd,
databas,
Lösenord,
hamn,
});
client.connect();
modul.exports = klient;
Klientmetoden från node-postgres tar informationen om databasen du ansluter till. Detta program importerar sina anslutningsdetaljer från en fil som heter dbConfig. Skapa därför den filen och lägg till följande kod till den:
modul.exports = {
användare: "postgres",
värd: "localhost",
databas: "nodeapp",
lösenord: "dittLösenord",
hamn: 5432,
};
Skapa databashjälpfunktioner
Det är alltid bra att använda enskilda funktioner för att interagera med databasen. De gör det enkelt att skriva enhetstester och förbättrar återanvändbarheten. För registreringsslutpunkten måste du skapa två funktioner:
- För att kontrollera om mejlet redan är registrerat.
- För att skapa användaren.
Målet är att bara registrera en användare om de inte finns i databasen.
Skapa en ny fil som heter helper.js och importera databasklienten från db.js:
konst klient = behöva("./db.js")
Lägg sedan till en ny funktion som heter emailExists():
konst emailExists = asynkron (e-post) => {
konst data = vänta client.query("SELECT * FROM users WHERE email=$1", [
e-post,
]);
om (data.rowCount == 0) lämna tillbakafalsk;
lämna tillbaka data.rows[0];
};
Den här funktionen tar ett e-postmeddelande och kontrollerar om den redan används. Den gör detta genom att använda SELECT-satsen som returnerar en rad som har ett e-postfält som matchar värdet som tillhandahålls av den registrerande användaren. Om e-postmeddelandet inte finns returnerar det falskt.
För att skapa en funktion som skapar användaren, lägg till en funktion som heter createUser() till helper.js:
konst createUser = asynkron (e-post, lösenord) => {
konst salt = vänta bcrypt.genSalt(10);
konst hash = vänta bcrypt.hash (lösenord, salt);konst data = vänta client.query(
"INSERT I användare (e-post, lösenord) VÄRDEN ($1, $2) RETURNERING ID, e-post, lösenord",
[e-post, hash]
);
om (data.rowCount == 0) lämna tillbakafalsk;
lämna tillbaka data.rows[0];
};
Denna funktion tar e-post- och lösenordsvärdena. Den använder INSERT-satsen för att skapa en ny rad med dessa detaljer och om den lyckas returneras den nyskapade användaren. Observera att innan du lagrar lösenordet bör du hasha det med bcrypt. Det är aldrig en bra idé att lagra lösenord som vanlig text. Om hackare fick tillgång till din användardatabas kunde de enkelt komma åt känslig information.
Installera bcryptjs för att börja använda det:
npm installera bcryptjs
I helper.js, importera bcryptjs:
konst bcrypt = behöva("bcryptjs")
Genom att använda Bcryptjs lagrar databasen endast det krypterade lösenordet. Därför måste du under inloggningen jämföra det vanliga textlösenordet som ges av användaren och det hashade lösenordet i databasen. För detta kan du använda jämförelsemetoden från Bcryptjs.
Skapa en funktion som heter matchPassword():
konst matchPassword = asynkron (lösenord, hashPassword) => {
konst matcha = vänta bcrypt.compare (lösenord, hashPassword);
lämna tillbaka match
};
Den tar emot det vanliga lösenordet och hashen och använder sedan Bcrypt.compare() för att avgöra om det angivna lösenordet är korrekt. Om det är det returnerar det sant annars returnerar det falskt.
Det här är alla funktioner vi kommer att använda för att interagera med databasen. Se till att exportera alla i slutet:
modul.exports = { emailExists, createUser, matchPassword };
Konfigurera Passport
Passport är ett mellanprogram för nodautentisering som tillhandahåller över 500 autentiseringsstrategier som social inloggning, JSON Web Tokens (JWT) och e-postautentisering. Vi kommer att använda det senare som den pass-lokala strategin ger.
Använd följande kommando för att installera passport och passport-local:
npm installera pass
npm installera pass-lokalt
Konfigurera sedan Passport för att logga in på befintliga användare och registrera nya användare.
Börja med att skapa en ny fil passportConfig.js. Importera sedan den lokala Passport-strategin och databashjälpfunktionerna du just skapade:
konst LocalStrategy = behöva("pass-lokal");
konst { emailExists, createUser, matchPassword } = behöva("./hjälpare");
Lägg till följande i samma fil för att konfigurera användarregistrering:
modul.exports = (pass) => {
passport.use(
"lokal registrering",
ny LocalStrategy(
{
användarnamnFält: "e-post",
lösenordsfält: "lösenord",
},
asynkron (e-post, lösenord, klar) => {
Prova {
konst userExists = vänta emailExists (e-post)om (användare finns) {
lämna tillbaka Gjort(null, falsk);
}
konst användare = vänta createUser (e-post, lösenord);
lämna tillbaka Gjort(null, användare);
} fånga (fel) {
gjort (fel);
}
}
)
);
}
Eftersom passport-local förväntar sig ett användarnamn och ett lösenord, och du använder en e-post, ställ in användarnamnsfältet till ett e-postmeddelande. Användaren eller snarare frontend-delen av denna applikation kommer att skicka e-post och lösenord i förfrågan. Du behöver dock inte extrahera värdena själv eftersom Passport kommer att hantera det i bakgrunden.
Detta program kontrollerar först om e-postmeddelandet redan tagits med hjälp av funktionen emailExists() från helper.js. Om e-postmeddelandet inte finns i databasen skapar det en ny användare med funktionen createUser(). Slutligen returnerar den användarobjektet.
För att logga in användare, lägg till följande i passportConfig.js:
modul.exports = (pass) => {
passport.use(
"lokal registrering",
ny LocalStrategy(
// Bli Medlem
)
);
passport.use(
"lokal-inloggning",
ny LocalStrategy(
{
användarnamnFält: "e-post",
lösenordsfält: "lösenord",
},
asynkron (e-post, lösenord, klar) => {
Prova {
konst användare = vänta emailExists (e-post);
om (!användare) lämna tillbaka Gjort(null, falsk);
konst isMatch = vänta matchPassword (lösenord, användare.lösenord);
om (!isMatch) lämna tillbaka Gjort(null, falsk);
lämna tillbaka Gjort(null, {id: användar ID, e-post: user.email});
} fånga (fel) {
lämna tillbaka gjort (fel, falsk);
}
}
)
);
};
Här kontrollerar programmet först om mejlet är registrerat. Om inte, returnerar det falskt. Om den hittar e-postmeddelandet jämför den sitt lösenord med det från förfrågan. Om lösenorden matchar loggar den in på användaren och returnerar användarobjektet.
Det sista steget är att skapa API-slutpunkterna:
- POST /auth/signup
- POST /auth/login
Båda dessa slutpunkter kommer att få ett e-postmeddelande och ett lösenord i förfrågan. De kommer också att inkludera de passautentiseringsfunktioner som vi just har konfigurerat.
Importera och ställ in Passport i en ny fil med namnet server.js:
konst pass = behöva("pass");
behöva("./passportConfig")(pass);
Lägg sedan till följande rutter:
app.post(
"/auth/Bli Medlem",
passport.authenticate("local-signup", { session: falsk }),
(req, res, nästa) => {
res.json({
användare: req.user,
});
}
);
app.post(
"/auth/logga in",
passport.authenticate("local-login", { session: falsk }),
(req, res, nästa) => {
res.json({ användare: req.user });
}
);
Båda dessa rutter returnerar ett JSON-objekt som innehåller användaren om det lyckas.
Kontrollera ditt API med hjälp av enhetstester
Du kan använda Passport för att autentisera en Node-applikation med en PostgreSQL-applikation. Du skapade API-slutpunkter för att registrera dig och logga in användare.
Även om du kan använda REST-klienter som Postman för att testa hur väl ett API fungerar, är det mycket enklare att skriva enhetstester. Med enhetstester kan du testa de enskilda delarna av din applikation. På detta sätt, även om en slutpunkt misslyckas, kan du fastställa den exakta punkten för felet. Ett av verktygen du kan använda för att testa Node-applikationer är Jest.
