כיצד להגדיר אימות דרכון ביישום Node ו-Postgres

כמפתח, באחריותך להגן על נתוני המשתמשים שלך באמצעות אימות. אתה יכול להשתמש ב-Passport.js כדי לאמת משתמשים באפליקציית Node ו-Postgres.

התחל ביצירת שרת Node עם נקודות קצה לרישום, כניסה ויציאה של משתמשים. אתה יכול לתת ל- Passport לטפל באימות כדי להגביל גישה לא מורשית לאפליקציה שלך.

יצירת טבלת משתמשים

לצורך אימות משתמש, תשתמש באימייל ובסיסמה. משמעות הדבר היא שטבלת המשתמשים חייבת להכיל דוא"ל ושדה סיסמה. בשורת הפקודה psql, צור מסד נתונים חדש בשם nodeapp:

לִיצוֹרמאגר מידע nodeapp;

לאחר מכן, צור טבלה לאחסון המשתמשים:

לִיצוֹרשולחןמשתמשים (
 מזהה INT נוצר תמיד כמפתח זהות ראשי,
 דוא"ל CHAR(128),
 סיסמה CHAR(60)
);

קוד זה יצור טבלה חדשה המכילה דואר אלקטרוני, סיסמה ושדה מזהה שנוצר אוטומטית.

יצירת שרת צומת

Node.js היא סביבת זמן ריצה של JavaScript בצד השרת המאפשרת לנו ליצור שרתי HTTP במהירות. כדי לפשט את תהליך יצירת השרת ומסלולי HTTP שונים, אתה יכול להשתמש Express, מסגרת אינטרנט של Node.js.

הפעל את הפקודה הזו כדי ליצור תיקיה חדשה בשם postgres-auth:

mkdir postgres-auth

לאחר מכן, אתחול npm:

npm init -y

לבסוף, התקן את Express:

npm להתקין אקספרס

אתה יכול עכשיו ליצור את שרת האינטרנט של ה-Node.

בקובץ חדש שנקרא index.js, הוסף את הדברים הבאים:

const express = לִדרוֹשׁ("אֶקְסְפּרֶס");
const app = express();
app.use (express.json());
app.use (express.urlencoded({ מורחב: נָכוֹן }));
app.listen(3000, () => לְנַחֵם.log("האזנה ביציאה 3000"));

הפעלת קוד זה תפעיל את השרת ותיכנס את הדברים הבאים במסוף:

האזנה בפורט 3000

מתחבר ל-PostgreSQL

ל התחבר אל PostgreSQL להשתמש node-postgres. node-postgres הוא מנהל התקן חיבור המספק ממשק בין Node ו-Postgres.

בצע את הפעולות הבאות כדי להתקין node-postrges באמצעות npm:

npm התקנה עמוד

לאחר שהתקנת את הספרייה, צור קובץ חדש בשם db.js ותחבר אותו למסד הנתונים:

const { לקוח } = לִדרוֹשׁ("עמוד");
const { user, host, database, password, port } = לִדרוֹשׁ(./dbConfig");
const לקוח = חָדָשׁ לָקוּחַ({
 מִשׁתַמֵשׁ,
 מנחה,
 מאגר מידע,
 סיסמה,
 נמל,
});
client.connect();
מודול.exports = לקוח;

שיטת הלקוח מ-node-postgres לוקחת את הפרטים של מסד הנתונים שאליו אתה מתחבר. תוכנית זו מייבאת את פרטי החיבור שלה מקובץ שנקרא dbConfig. לכן, צור את הקובץ הזה והוסף לו את הקוד הבא:

מודול‎.exports = {
 משתמש: "postgres",
 מארח: "מארח מקומי",
 מסד נתונים: "nodeapp",
 סיסמה: "yourPassword",
 נמל: 5432,
};

יצירת פונקציות מסייעות למסד נתונים

זה תמיד נוהג טוב להשתמש בפונקציות בודדות כדי ליצור אינטראקציה עם מסד הנתונים. הם מקלים על כתיבת בדיקות יחידות ומשפרים שימוש חוזר. עבור נקודת הקצה של ההרשמה, עליך ליצור שתי פונקציות:

1. כדי לבדוק אם המייל כבר רשום.
2. כדי ליצור את המשתמש.

המטרה היא לרשום משתמש רק אם הוא לא קיים במסד הנתונים.

צור קובץ חדש בשם helper.js וייבא את לקוח מסד הנתונים מ-db.js:

const לקוח = לִדרוֹשׁ("./db.js")

לאחר מכן, הוסף פונקציה חדשה בשם emailExists():

const emailExists = אסינכרון (אימייל) => {
const נתונים = לְהַמתִין client.query("SELECT * FROM users WHERE email=$1", [
 אימייל,
 ]);
אם (data.rowCount == 0) לַחֲזוֹרשֶׁקֶר; 
לַחֲזוֹר data.rows[0];
};

פונקציה זו לוקחת אימייל ובודקת אם היא כבר בשימוש. הוא עושה זאת על ידי שימוש בסעיף SELECT שמחזיר שורה שיש לה שדה דוא"ל התואם לערך שסופק על ידי המשתמש שנרשם. אם האימייל לא קיים, הוא מחזיר false.

כדי ליצור פונקציה שיוצרת את המשתמש, הוסף פונקציה בשם createUser() ל-helper.js:

const createUser = אסינכרון (אימייל, סיסמה) => {
const מלח = לְהַמתִין bcrypt.genSalt(10);
const hash = לְהַמתִין bcrypt.hash (סיסמה, מלח);
const נתונים = לְהַמתִין client.query(
 "הכנס לתוך משתמשים (אימייל, סיסמה) VALUES ($1, $2) זיהוי חוזר, דוא"ל, סיסמה",
 [אימייל, hash]
 );
אם (data.rowCount == 0) לַחֲזוֹרשֶׁקֶר;
לַחֲזוֹר data.rows[0];
};

פונקציה זו לוקחת את ערכי הדוא"ל והסיסמה. הוא משתמש בסעיף INSERT כדי ליצור שורה חדשה עם הפרטים הללו, ואם הוא מצליח מחזיר את המשתמש החדש שנוצר. שים לב שלפני שמירת הסיסמה, עליך hash אותו באמצעות bcrypt. זה אף פעם לא רעיון טוב לאחסן סיסמאות כטקסט רגיל. אם האקרים קיבלו גישה למסד הנתונים של המשתמשים שלך, הם יכלו לגשת בקלות למידע רגיש.

התקן את bcryptjs כדי להתחיל להשתמש בו:

npm התקן את bcryptjs

ב-helper.js, ייבא bcryptjs:

const bcrypt = לִדרוֹשׁ("bcryptjs")

באמצעות Bcryptjs, מסד הנתונים מאחסן רק את הסיסמה המוצפנת. לכן, במהלך הכניסה, תצטרכו להשוות בין סיסמת הטקסט הפשוט שניתן על ידי המשתמש לבין הסיסמה ה-hash במסד הנתונים. לשם כך, אתה יכול להשתמש בשיטת ההשוואה שסופקה על ידי Bcryptjs.

צור פונקציה בשם matchPassword():

const matchPassword = אסינכרון (סיסמה, hashPassword) => {
const התאמה = לְהַמתִין bcrypt.compare (סיסמה, hashPassword);
לַחֲזוֹר התאמה
};

הוא מקבל את הסיסמה הפשוטה ואת ה-hash ולאחר מכן משתמש ב-Bcrypt.compare() כדי לקבוע אם הסיסמה שסופקה נכונה. אם כן, הוא מחזיר אמת אחרת, הוא מחזיר שקר.

אלו הן כל הפונקציות שבהן נשתמש כדי ליצור אינטראקציה עם מסד הנתונים. הקפד לייצא את כולם בסוף:

מודול.exports = { emailExists, createUser, matchPassword };

הגדר דרכון

Passport היא תוכנת אמצעים לאימות צומת המספקת למעלה מ-500 אסטרטגיות אימות כמו התחברות חברתית, JSON Web Tokens (JWT) ואימות דואר אלקטרוני. אנו נשתמש באחרון שאסטרטגיית הדרכון-מקומי מספקת.

השתמש בפקודה הבאה כדי להתקין דרכון ודרכון מקומי:

npm להתקין דרכון
npm להתקין דרכון-מקומי

לאחר מכן, הגדר את Passport לכניסה למשתמשים קיימים ולרשום משתמשים חדשים.

התחל ביצירת קובץ חדש passportConfig.js. לאחר מכן, ייבא את האסטרטגיה המקומית של Passport ואת פונקציות העזר של מסד הנתונים שיצרת זה עתה:

const אסטרטגיה מקומית = לִדרוֹשׁ("דרכון-מקומי");
const { emailExists, createUser, matchPassword } = לִדרוֹשׁ("./עוֹזֵר");

באותו קובץ הוסף את הדברים הבאים כדי להגדיר הרשמה למשתמש:

מודול.exports = (דרכון) => {
 passport.use(
 "הרשמה מקומית",
חָדָשׁ אסטרטגיה מקומית(
 {
 usernameField: "אימייל",
 passwordField: "סיסמה",
 },
אסינכרון (אימייל, סיסמה, בוצע) => {
לְנַסוֹת {
const userExists = לְהַמתִין emailExists (email)
אם (UserExists) {
לַחֲזוֹר בוצע(ריק, שֶׁקֶר);
 }
const משתמש = לְהַמתִין createUser (דוא"ל, סיסמה);
לַחֲזוֹר בוצע(ריק, משתמש);
 } לתפוס (שגיאה) {
 נעשה (שגיאה);
 }
 }
 )
 );
}

מכיוון ש-passport-local מצפה לשם משתמש וסיסמה, ואתה משתמש באימייל, הגדר את שדה שם המשתמש לאימייל. המשתמש או ליתר דיוק החלק הקדמי של אפליקציה זו ישלח את האימייל והסיסמה בגוף הבקשה. עם זאת, אינך צריך לחלץ את הערכים בעצמך מכיוון ש- Passport יטפל בזה ברקע.

תוכנית זו בודקת תחילה אם האימייל כבר נלקח באמצעות הפונקציה emailExists() מ-helper.js. אם האימייל לא קיים במסד הנתונים, הוא יוצר משתמש חדש עם הפונקציה createUser(). לבסוף, הוא מחזיר את אובייקט המשתמש.

כדי להתחבר למשתמשים, הוסף את הדברים הבאים ל-passportConfig.js:

מודול.exports = (דרכון) => {
 passport.use(
 "הרשמה מקומית",
חָדָשׁ אסטרטגיה מקומית(
// הירשם
 )
 );
 passport.use(
 "מקומי-כניסה",
חָדָשׁ אסטרטגיה מקומית(
 {
 usernameField: "אימייל",
 passwordField: "סיסמה",
 },
אסינכרון (אימייל, סיסמה, בוצע) => {
לְנַסוֹת {
const משתמש = לְהַמתִין emailExists (אימייל);
אם (!מִשׁתַמֵשׁ) לַחֲזוֹר בוצע(ריק, שֶׁקֶר);
const isMatch = לְהַמתִין matchPassword (סיסמה, user.password);
אם (!isMatch) לַחֲזוֹר בוצע(ריק, שֶׁקֶר);
לַחֲזוֹר בוצע(ריק, {תְעוּדַת זֶהוּת: תעודת זהות של המשתמש, אימייל: user.email});
 } לתפוס (שגיאה) {
לַחֲזוֹר נעשה (שגיאה, שֶׁקֶר);
 }
 }
 )
 );
};

כאן, התוכנית בודקת תחילה אם האימייל רשום. אם לא, הוא מחזיר false. אם הוא מוצא את האימייל, הוא משווה את הסיסמה שלו לזו מהבקשה. אם הסיסמאות תואמות, הוא מתחבר למשתמש ומחזיר את אובייקט המשתמש.

השלב האחרון הוא יצירת נקודות הקצה של ה-API:

• POST /auth/signup
• POST /auth/login

שתי נקודות הקצה הללו יקבלו אימייל וסיסמה בגוף הבקשה. הם יכללו גם את פונקציות התווך של אימות דרכון שהגדרנו זה עתה.

יבא והגדר את Passport בקובץ חדש בשם server.js:

const דרכון = לִדרוֹשׁ("דַרכּוֹן");
לִדרוֹשׁ("./passportConfig")(דרכון);

לאחר מכן, הוסף את המסלולים הבאים:

app.post(
 "/auth/הירשם",
 passport.authenticate("local-signup", { מוֹשָׁב: שֶׁקֶר }),
 (req, res, next) => {
 res.json({
 משתמש: req.user,
 });
 }
);
app.post(
 "/auth/התחברות",
 passport.authenticate("local-login", { מוֹשָׁב: שֶׁקֶר }),
 (req, res, next) => {
 res.json({ מִשׁתַמֵשׁ: req.user });
 }
);

שני המסלולים הללו מחזירים אובייקט JSON המכיל את המשתמש אם זה מצליח.

בדוק את ה-API שלך באמצעות בדיקות יחידה

אתה יכול להשתמש ב- Passport כדי לאמת יישום Node באמצעות יישום PostgreSQL. יצרת נקודות קצה של API כדי להירשם ולהתחבר למשתמשים.

בעוד שאתה יכול להשתמש בלקוחות REST כמו Postman כדי לבדוק עד כמה API עובד, כתיבת בדיקות יחידות היא הרבה יותר פשוטה. בדיקות יחידה מאפשרות לך לבדוק את החלקים הבודדים של היישום שלך. בדרך זו, גם אם נקודת קצה נכשלת, תוכל לאתר את נקודת הכשל המדויקת. אחד הכלים שבהם אתה יכול להשתמש כדי לבדוק יישומי Node הוא Jest.