Säkra dina applikationer genom att validera data på begärannivån med hjälp av Joi-valideringsbiblioteket.
Att acceptera oprövad och ovaliderad data i en webbapplikation kan orsaka säkerhetsbrister, och oförutsedda problem kan uppstå från ogiltiga data.
Node.js ORM, som Sequelize och TypeORM, låter dig ställa in valideringsregler direkt på applikationsnivå. Under API-utveckling kommer data från HTTP-förfrågningar till specifika slutpunkter. Detta händer på begäran nivå; sålunda gäller inte standardvalideringen som erbjuds av ORM: erna för dem.
Joi är en schemabeskrivning och datavalidator för JavaScript. Här kommer du att lära dig hur du använder Joi-valideringsbiblioteket för att validera data på begäran-nivå.
Konfigurera demoprojekt
För att visa hur Joi validerar data kommer du att bygga en enkel demoapplikation som efterliknar en faktisk applikation.
Skapa först en projektmapp och flytta in i den genom att köra följande kommando:
mkdir demoapp && cd demoapp
Initiera sedan npm i din projektkatalog genom att köra:
npm init -y
Därefter måste du installera vissa beroenden. De beroenden som krävs för denna handledning inkluderar följande:
- uttrycka: Express är ett Node.js-ramverk som ger en robust uppsättning funktioner för webb- och mobilapplikationer. Express gör det enklare att bygga backend-applikationer med Node.js.
- Joi: Joi är ett datavalideringsbibliotek för Node.js.
Installera beroenden med nodpakethanteraren genom att köra kommandot nedan:
npm installera express joi
Skapa sedan en index.js fil i din rotkatalog och lägg till följande kodblock till den:
konst uttrycka = behöva("uttrycka");
konst router = behöva("./rutter");
konst port = 3000;konst app = express();
app.use (express.json());
app.use (express.urlencoded({ förlängt: Sann }));
app.use (router);
app.listen (port, () => {
trösta.logga("app lyssnar på port 3000!");
});
Kodblocket ovan sätter upp en enkel Express-server. Den konfigurerar mellanprogram för att analysera inkommande förfrågningar och hantera inkommande förfrågningar och startar servern att lyssna efter inkommande förfrågningar på port 3000.
Routing och hantering av förfrågningar
För enkelhetens skull skapar du en mellanprogram för förfrågningshanterare som returnerar en statuskod, tillsammans med förfrågningskroppen, som ett svar på varje begäran som försöker skicka data till din applikation.
Skapa en handler.js fil i ditt projekts rotkatalog och lägg till kodblocket nedan:
konst demoHandler = (req, res, nästa) => {
res.send({
koda: 201,
data: req.body,
});
Nästa();
};
modul.exports = demoHandler;
Skapa sedan en router.js fil i ditt projekts rotkatalog och lägg till kodblocket nedan i din fil:
konst uttrycka = behöva("uttrycka");
konst demoHandler = behöva("./hanterare");
konst router = express. Router();router.post("/Bli Medlem", demoHandler);
modul.exports = router;
Skapa ett Joi-schema
Ett Joi-schema representerar ett specifikt dataobjekts förväntade struktur och valideringsregler.
För att skapa ett Joi-schema kan du använda Joi.object() metod och kedja olika valideringsregler exponerade av Joi för att definiera strukturen och valideringskraven för dina data.
Till exempel:
konst exempelSchema = Joi.object({
namn: Joi.string().min(3).nödvändig(),
});
Exemplet ovan beskriver ett enkelt Joi-schema med en namn fast egendom. De namn fastighet har ett värde på Joi.string().min (3).required(). Detta innebär att namn värdet ska vara en sträng med en minsta längd på 3 tecken, och det är obligatoriskt.
Med hjälp av Joi kan du kedja olika metoder för att lägga till fler valideringsbegränsningar till varje fält som definieras i ditt schema.
Här är ett exempel med fler fält och valideringsbegränsningar:
konst userSchema = Joi.object({
e-post: Joi.string().email().required(),lösenord: Joi.string().min(6).nödvändig(),
ålder: Joi.number().min(18).frivillig(),
anställd: Joi.boolean().optional(),
telefon: Joi.string()
.regex(/^\\d{3}-\\d{3}-\\d{4}$/)//"123-456-7890"
.nödvändig(),adress: Joi.object({
gata: Joi.string().min(3).nödvändig(),
stad: Joi.string().min(3).nödvändig(),
state: Joi.string().min(3).nödvändig(),
zip: Joi.number().min(3).nödvändig(),
}).nödvändig(),hobbies: Joi.array().items (Joi.string()).required(),
}).alternativ({ avbryta Tidigt: falsk });
De userSchema definierar följande begränsningar för varje egenskap:
- e-post: Måste vara en giltig e-poststräng.
- Lösenord: Måste vara en sträng med minst 6 tecken.
- ålder: Ett valfritt nummer med ett lägsta värde på 18.
- anställd: En valfri boolean.
- telefon: En obligatorisk sträng som matchar den angivna regex uttryck (/^\d{3}-\d{3}-\d{4}$/).
-
adress: Ett objekt som representerar användarens adress med följande underegenskaper.
- gata: En obligatorisk sträng med en minsta längd på 3 tecken.
- stad: En obligatorisk sträng med en minsta längd på 3 tecken.
- stat: En obligatorisk sträng med en minsta längd på 3 tecken.
- blixtlås: Ett obligatoriskt nummer med ett lägsta värde på 3.
- hobbyer: En obligatorisk uppsättning strängar.
Förutom begränsningarna, userSchema ställer in avbryta Tidigt möjlighet att falsk. Som standard stoppar Joi körningen av programmet så snart det stöter på det första felet och skriver ut felet till konsolen. Ställ dock in detta alternativ till falsk ser till att Joi kontrollerar hela schemat och skriver ut alla påträffade fel till konsolen.
Validerar data med Joi
Skapa en validation.js fil och lägg till userSchema kod till den.
Såhär:
//validation.js
konst Joi = behöva("joi");konst userSchema = Joi.object({
//...
}).alternativ({ avbryta Tidigt: falsk });
modul.exports = userSchema;
Skapa sedan en mellanprogramvara som fångar upp begäranden nyttolaster och verifierar dem mot ett tillhandahållet schema genom att lägga till följande kod under userSchema koda.
konst valideringMiddleware = (schema) => {
lämna tillbaka(req, res, nästa) => {
konst { error } = schema.validate (req.body);om (fel) {
// Hantera valideringsfel
trösta.log (fel.meddelande);
res.status(400).json({ fel: detaljer om felet });
} annan {
// Data är giltig, fortsätt till nästa mellanprogram
Nästa();
}
};
};
När en begäran görs anropar mellanvaran bekräfta metod för schema för att validera förfrågningsorganet. Om några valideringsfel uppstår skickar mellanvaran ett 400 Dålig Förfrågan svar med felmeddelandena extraherade från valideringsfeldetaljerna.
Å andra sidan, om valideringen går igenom utan fel, anropar mellanvaran Nästa() fungera.
Exportera slutligen validering Mellanprogram och userSchema.
modul.exports = {
userSchema,
valideringMiddleware,
};
Testa valideringsbegränsningar
Importera validering Mellanprogram och userSchema in i din router.js fil och ställ in mellanvaran så här:
konst { validationMiddleware, userSchema } = behöva("./godkännande");
router.post("/Bli Medlem", validationMiddleware (userSchema), demoHandler);
Starta din applikation genom att köra kommandot nedan:
nodindex.js
Gör sedan en HTTP POST-begäran till lokalvärd: 3000/registrering med hjälp av testdata nedan. Du kan uppnå detta med hjälp av cURL eller någon annan API-klient.
{
"e-post": "användare@exempel", // Ogiltigt e-postformat
"Lösenord": "passera", // Lösenordslängd mindre än 6 tecken
"ålder": 15, // Ålder under 18
"anställd": Sann,
"hobbyer": ["läsning", "löpning"],
"telefon": "123-456-789", // Ogiltigt telefonnummerformat
"adress": {
"gata": "123",
"stad": "Exempelstad",
"stat": "Exempel tillstånd",
"blixtlås": 12345
}
}
Denna begäran skulle misslyckas och returnera ett felobjekt eftersom nyttolasten innehåller många ogiltiga fält, såsom e-post, lösenord, ålder och telefon. Med det angivna felobjektet kan du hantera felen på lämpligt sätt.
Förenkla datavalidering med Joi
Här täckte du det mesta av grunderna för datavalidering med Joi. Du kan dock täcka mer avancerade tekniker och begränsningar i Joi-dokumentationen.
Joi förenklar datavalideringsuppgiften i JavaScript, vilket ger en intuitiv lösning som avsevärt förbättrar tillförlitligheten och integriteten hos data som lagras i din applikation.
