In qualità di sviluppatore, è tua responsabilità salvaguardare i dati dei tuoi utenti tramite l'autenticazione. Puoi utilizzare Passport.js per autenticare gli utenti in un'applicazione Node e Postgres.
Inizia creando un server Node con endpoint per registrare, accedere e disconnettere gli utenti. Puoi lasciare che Passport gestisca l'autenticazione per limitare l'accesso non autorizzato alla tua applicazione.
Creazione di una tabella utenti
Per l'autenticazione dell'utente, utilizzerai un'e-mail e una password. Ciò significa che la tabella degli utenti deve contenere un campo e-mail e una password. Nel prompt dei comandi di psql, crea un nuovo database chiamato nodeapp:
CREAREBANCA DATI nodoapp;
Quindi, crea una tabella per memorizzare gli utenti:
CREARETAVOLOutenti (
id INT GENERATO SEMPRE COME CHIAVE PRIMARIA DI IDENTITÀ,
e-mail CHAR(128),
password CAR(60)
);
Questo codice creerà una nuova tabella contenente email, password e un campo ID generato automaticamente.
Creazione di un server nodo
Node.js è un ambiente di runtime JavaScript lato server che ci consente di creare rapidamente server HTTP. Per semplificare il processo di creazione del server e dei diversi percorsi HTTP, puoi utilizzare Express, un framework Web Node.js.
Esegui questo comando per creare una nuova cartella chiamata postgres-auth:
mkdir postgres-auth
Quindi, inizializza npm:
npm init -y
Infine, installa Express:
npm install express
Tu puoi ora creare il server Web Node.
In un nuovo file chiamato index.js, aggiungi quanto segue:
cost espresso = richiedere("esprimere");
cost app = espresso();
app.use (express.json());
app.use (express.urlencoded({ esteso: VERO }));
app.ascolta(3000, () => consolle.log("Ascolto sulla porta 3000"));
L'esecuzione di questo codice avvierà il server e registrerà quanto segue nella console:
Ascolto sulla porta 3000Connessione a PostgreSQL
Per connettersi a PostgreSQL uso nodo-postgres. node-postgres è un driver di connessione che fornisce un'interfaccia tra Node e Postgres.
Eseguire quanto segue per installare node-postrges tramite npm:
npm install pag
Dopo aver installato quella libreria, crea un nuovo file chiamato db.js e collegarlo al database:
cost {Cliente} = richiedere("pag");
cost { utente, host, database, password, porta } = richiedere("./dbConfig");cost cliente = nuovo Cliente({
utente,
ospite,
Banca dati,
parola d'ordine,
porta,
});
client.connect();
modulo.esportazioni = cliente;
Il metodo client di node-postgres prende i dettagli del database a cui ti stai connettendo. Questo programma importa i dettagli della connessione da un file chiamato dbConfig. Pertanto, crea quel file e aggiungi il seguente codice:
modulo.esportazioni = {
utente: "postgres",
host: "localhost",
database: "nodeapp",
password: "la tua password",
porta: 5432,
};
Crea funzioni di supporto del database
È sempre buona norma utilizzare singole funzioni per interagire con il database. Semplificano la scrittura di unit test e migliorano la riutilizzabilità. Per l'endpoint di registrazione, devi creare due funzioni:
- Per verificare se l'e-mail è già registrata.
- Per creare l'utente.
L'obiettivo è registrare un utente solo se non esiste nel database.
Crea un nuovo file chiamato helper.js e importa il client del database da db.js:
cost cliente = richiedere("./db.js")
Quindi, aggiungi una nuova funzione chiamata emailExists():
cost email esiste = asincrono (e-mail) => {
cost dati = aspettare client.query("SELECT * FROM users WHERE email=$1", [
e-mail,
]);
Se (data.rowCount == 0) Restituzionefalso;
Restituzione righe.dati[0];
};
Questa funzione accetta un'e-mail e controlla se è già in uso. Lo fa utilizzando la clausola SELECT che restituisce una riga con un campo e-mail che corrisponde al valore fornito dall'utente che si registra. Se l'e-mail non esiste, restituisce false.
Per creare una funzione che crei l'utente, aggiungi una funzione chiamata createUser() a helper.js:
cost creaUtente = asincrono (e-mail, password) => {
cost sale = aspettare bcrypt.genSalt(10);
cost hash = aspettare bcrypt.hash (password, salt);cost dati = aspettare client.query(
"INSERT INTO users (email, password) VALUES ($1, $2) RESTITUZIONE id, email, password",
[e-mail, hash]
);
Se (data.rowCount == 0) Restituzionefalso;
Restituzione righe.dati[0];
};
Questa funzione accetta i valori dell'e-mail e della password. Utilizza la clausola INSERT per creare una nuova riga con questi dettagli e, in caso di esito positivo, restituisce l'utente appena creato. Nota che prima di memorizzare la password, dovresti hash usando bcrypt. Non è mai una buona idea memorizzare le password come testo normale. Se gli hacker hanno accesso al tuo database utente, potrebbero facilmente accedere a informazioni sensibili.
Installa bcryptjs per iniziare a usarlo:
npm installa bcryptjs
In helper.js, importa bcryptjs:
cost bcrypt = richiedere("bcryptjs")
Utilizzando Bcryptjs, il database memorizza solo la password crittografata. Pertanto, durante l'accesso, sarà necessario confrontare la password in testo normale fornita dall'utente e la password con hash nel database. Per questo, puoi utilizzare il metodo di confronto fornito da Bcryptjs.
Crea una funzione chiamata matchPassword():
cost corrispondenzaPassword = asincrono (password, hashPassword) => {
cost corrispondenza = aspettare bcrypt.compare (password, hashPassword);
Restituzione incontro
};
Riceve la password semplice e l'hash e quindi utilizza Bcrypt.compare() per determinare se la password fornita è corretta. Se lo è, restituisce true, altrimenti restituisce false.
Queste sono tutte le funzioni che utilizzeremo per interagire con il database. Assicurati di esportarli tutti alla fine:
modulo.exports = { emailExists, createUser, matchPassword };
Configura passaporto
Passport è un middleware di autenticazione del nodo che fornisce oltre 500 strategie di autenticazione come l'accesso social, i token Web JSON (JWT) e l'autenticazione e-mail. Utilizzeremo quest'ultimo, fornito dalla strategia del passaporto locale.
Utilizzare il comando seguente per installare passport e passport-local:
npm installa il passaporto
npm installa passaporto-locale
Quindi, configura Passport per accedere agli utenti esistenti e registrarne di nuovi.
Inizia creando un nuovo file passaportoConfig.js. Quindi, importa la strategia locale Passport e le funzioni di supporto del database che hai appena creato:
cost Strategia Locale = richiedere("passaporto locale");
cost { emailExists, createUser, matchPassword } = richiedere(./helper");
Nello stesso file aggiungi quanto segue per configurare la registrazione utente:
modulo.exports = (passaporto) => {
passaporto.usa(
"registrazione locale",
nuovo Strategia Locale(
{
usernameCampo: "email",
passwordCampo: "password",
},
asincrono (e-mail, password, fatto) => {
Tentativo {
cost utente esiste = aspettare emailExists (email)Se (utente esiste) {
Restituzione fatto(nullo, falso);
}
cost utente = aspettare createUser (e-mail, password);
Restituzione fatto(nullo, utente);
} presa (errore) {
fatto (errore);
}
}
)
);
}
Poiché passport-local si aspetta un nome utente e una password e stai utilizzando un'e-mail, imposta il campo nome utente su un'e-mail. L'utente o meglio la parte frontend di questa applicazione invierà l'e-mail e la password nel corpo della richiesta. Tuttavia, non è necessario estrarre i valori da soli poiché Passport lo gestirà in background.
Questo programma verifica innanzitutto se l'e-mail è già stata presa utilizzando la funzione emailExists() di helper.js. Se l'e-mail non esiste nel database, crea un nuovo utente con la funzione createUser(). Infine, restituisce l'oggetto utente.
Per accedere agli utenti, aggiungi quanto segue a passportConfig.js:
modulo.exports = (passaporto) => {
passaporto.usa(
"registrazione locale",
nuovo Strategia Locale(
// iscrizione
)
);
passaporto.usa(
"login locale",
nuovo Strategia Locale(
{
usernameCampo: "email",
passwordCampo: "password",
},
asincrono (e-mail, password, fatto) => {
Tentativo {
cost utente = aspettare emailExists (email);
Se (!utente) Restituzione fatto(nullo, falso);
cost isMatch = aspettare matchPassword (password, user.password);
Se (!è Match) Restituzione fatto(nullo, falso);
Restituzione fatto(nullo, {id: ID utente, e-mail: utente.email});
} presa (errore) {
Restituzione fatto (errore, falso);
}
}
)
);
};
Qui, il programma controlla prima se l'e-mail è registrata. In caso contrario, restituisce false. Se trova l'e-mail, confronta la sua password con quella della richiesta. Se le password corrispondono, accede all'utente e restituisce l'oggetto utente.
Il passaggio finale consiste nel creare gli endpoint API:
- POST /autorizzazione/registrazione
- POST /auth/login
Entrambi questi endpoint riceveranno un'e-mail e una password nel corpo della richiesta. Includeranno anche le funzioni del middleware di autenticazione del passaporto che abbiamo appena configurato.
Importa e configura Passport in un nuovo file denominato server.js:
cost passaporto = richiedere("passaporto");
richiedere("./passportConfig")(passaporto);
Quindi, aggiungi i seguenti percorsi:
app.post(
"/auth/iscrizione",
passport.authenticate("registrazione locale", { sessione: falso }),
(req, res, successivo) => {
res.json({
utente: utente richiesto,
});
}
);
app.post(
"/auth/Accedere",
passport.authenticate("local-login", { sessione: falso }),
(req, res, successivo) => {
res.json({ utente: utente richiesto });
}
);
Entrambe queste route restituiscono un oggetto JSON contenente l'utente in caso di esito positivo.
Controlla la tua API usando gli Unit Test
È possibile utilizzare Passport per autenticare un'applicazione Node utilizzando un'applicazione PostgreSQL. Hai creato gli endpoint API per la registrazione e l'accesso degli utenti.
Sebbene tu possa utilizzare client REST come Postman per testare il funzionamento di un'API, scrivere unit test è molto più semplice. Gli unit test ti consentono di testare le singole parti della tua applicazione. In questo modo, anche se un endpoint si guasta, puoi individuare il punto esatto dell'errore. Uno degli strumenti che puoi utilizzare per testare le applicazioni Node è Jest.
