छोटों के लिए हापी

Hapi.js वेब अनुप्रयोगों के निर्माण के लिए एक रूपरेखा है। इस पोस्ट में एक गर्म शुरुआत के लिए सभी आवश्यक हैं। दुर्भाग्य से, लेखक बिल्कुल भी लेखक नहीं है, इसलिए बहुत सारे कोड और कुछ शब्द होंगे।

• एमवीपी
• जंगली में
  
  • ORM अगली कड़ी
  • अनुरोध में अतिरिक्त मॉड्यूल इंजेक्ट करें
  • प्राधिकरण
  • हैंडलिंग में त्रुटि
  
  
• डेटा स्कीमा
• स्वैगर / ओपनएपीआई
• ऑटो टेस्ट जनरेशन

एमवीपी

निर्भरता का एक गुच्छा रखो:

npm i @hapi/hapi @hapi/boom filepaths hapi-boom-decorators 

• hapi / hapi - वास्तव में, हमारा सर्वर
• hapi / बूम - मानक उत्तर उत्पन्न करने के लिए मॉड्यूल
• हैप्पी-बूम-डेकोरेटर्स - हेल्पी / बूम के लिए सहायक
• filepaths - एक उपयोगिता जो पुनरावर्ती फ़ोल्डर पढ़ती है

एक फ़ोल्डर संरचना और प्रारंभ फ़ाइलों का एक गुच्छा बनाएँ:

//Src/routes/ में, हम एपीआई एंडपॉइंट्स, 1 फाइल - 1 एंडपॉइंट का विवरण जोड़ते हैं:

 // ./src/routes/home.js async function response() { // content-type            return { result: 'ok', message: 'Hello World!' }; } module.exports = { method: 'GET', //  path: '/', //  options: { handler: response // ,  ,  hapi > 17    } }; 

./src/server.js - वह मॉड्यूल जो सर्वर को स्वयं निर्यात करता है।

 // ./src/server.js 'use strict'; const Hapi = require('@hapi/hapi'); const filepaths = require('filepaths'); const hapiBoomDecorators = require('hapi-boom-decorators'); const config = require('../config'); async function createServer() { //   const server = await new Hapi.Server(config.server); //   await server.register([ hapiBoomDecorators ]); //      ./src/routes/ let routes = filepaths.getSync(__dirname + '/routes/'); for(let route of routes) server.route( require(route) ); //   try { await server.start(); console.log(`Server running at: ${server.info.uri}`); } catch(err) { //    ,   console.log(JSON.stringify(err)); } //      return server; } module.exports = createServer; 

In//verver.js हम सभी करते हैं कॉल क्रिएटवर ()

 #!/usr/bin/env node const createServer = require('./src/server'); createServer(); 

हम लॉन्च करते हैं

 node server.js 

और जांचें:

 curl http://127.0.0.1:3030/ {"result":"ok","message":"Hello World!"} curl http://127.0.0.1:3030/test {"statusCode":404,"error":"Not Found","message":"Not Found"} 

जंगली में

एक वास्तविक परियोजना में, कम से कम, हमें एक डेटाबेस, एक लकड़हारा, प्राधिकरण, त्रुटि से निपटने और बहुत कुछ चाहिए।

सीक्वल जोड़ें

ORM अगली कड़ी को एक मॉड्यूल के रूप में जोड़ा जाता है:

 ... const Sequelize = require('sequelize'); ... await server.register([ ... { plugin: require('hapi-sequelizejs'), options: [ { name: config.db.database, // identifier models: [__dirname + '/models/*.js'], //    //ignoredModels: [__dirname + '/server/models/**/*.js'], //  -     sequelize: new Sequelize(config.db), //  sync: true, // default false forceSync: false, // force sync (drops tables) - default false }, ] } ... ]); 

कॉल के माध्यम से मार्ग के अंदर डेटाबेस उपलब्ध हो जाता है:

 async function response(request) { const model = request.getModel('_', '_'); } 

अनुरोध में अतिरिक्त मॉड्यूल इंजेक्ट करें

"OnRequest" ईवेंट को रोकना आवश्यक है, जिसके अंदर हम अनुरोध ऑब्जेक्ट में कॉन्फिगर और लॉगर इंजेक्ट करेंगे:

 ... const Logger = require('./libs/Logger'); ... async function createServer(logLVL=config.logLVL) { ... const logger = new Logger(logLVL, 'my-hapi-app'); ... server.ext({ type: 'onRequest', method: async function (request, h) { request.server.config = Object.assign({}, config); request.server.logger = logger; return h.continue; } }); ... } 

उसके बाद, अनुरोध हैंडलर के अंदर, हमारे पास कॉन्फ़िगर, लॉगर और डेटाबेस तक पहुंच होगी, इसके अलावा मॉड्यूल बॉडी में कुछ भी शामिल करने की आवश्यकता के बिना:

 // ./src/routes/home.js async function response(request) { //  request.server.logger.error('request error', 'something went wrong'); //  console.log(request.server.config); //   const messages = request.getModel(request.server.config.db.database, '_'); return { result: 'ok', message: 'Hello World!' }; } module.exports = { method: 'GET', //  path: '/', //  options: { handler: response // ,  ,  hapi > 17    } }; 

इस प्रकार, इनपुट पर अनुरोध हैंडलर को इसके प्रसंस्करण के लिए आवश्यक सब कुछ प्राप्त होगा, और समय-समय पर एक ही मॉड्यूल को शामिल करना आवश्यक नहीं होगा।

प्राधिकरण

हापी में प्राधिकरण मॉड्यूल के रूप में बनाया गया है।

 ... const AuthBearer = require('hapi-auth-bearer-token'); ... async function createServer(logLVL=config.logLVL) { ... await server.register([ AuthBearer, ... ]); server.auth.strategy('token', 'bearer-access-token', {// 'token' -   ,  allowQueryToken: false, unauthorized: function() { //  ,  validate  isValid=false throw Boom.unauthorized(); }, validate: function(request, token) { if( token == 'asd' ) { return { //    isValid: true, credentials: {} }; } else { return { //   isValid: false, credentials: {} }; } } }); server.auth.default('token'); //    ... } 

और मार्ग के अंदर आपको यह भी निर्दिष्ट करना होगा कि किस प्रकार के प्राधिकरण का उपयोग करना है:

 module.exports = { method: 'GET', path: '/', auth: 'token', //  false,     options: { handler: response } }; 

यदि कई प्रकार के प्राधिकरण उपयोग किए जाते हैं:

 auth: { strategies: ['token1', 'token2', 'something_else'] }, 

हैंडलिंग में त्रुटि

डिफ़ॉल्ट रूप से, बूम एक मानक तरीके से त्रुटियों को उत्पन्न करता है, अक्सर इन उत्तरों को अपने स्वयं के प्रारूप में लपेटने की आवश्यकता होती है।

 server.ext('onPreResponse', function (request, h) { //      Boom,     if ( !request.response.isBoom ) { return h.continue; } //  -     let responseObj = { message: request.response.output.statusCode === 401 ? 'AuthError' : 'ServerError', status: request.response.message } //     logger.error('code: ' + request.response.output.statusCode, request.response.message); return h.response(responseObj).code(request.response.output.statusCode); }); 

डेटा स्कीमा

यह एक छोटा लेकिन बहुत महत्वपूर्ण विषय है। डेटा योजनाएं आपको अनुरोध की वैधता और प्रतिक्रिया की शुद्धता की जांच करने की अनुमति देती हैं। आप इन योजनाओं का कितना अच्छा वर्णन करते हैं, इसलिए स्वैगर और ऑटोटेस्ट ऐसी गुणवत्ता के होंगे।

सभी डेटा योजनाओं को जोई के माध्यम से वर्णित किया गया है। आइए उपयोगकर्ता प्राधिकरण के लिए एक उदाहरण बनाते हैं:

 const Joi = require('@hapi/joi'); const Boom = require('boom'); async function response(request) { //   const accessTokens = request.getModel(request.server.config.db.database, 'access_tokens'); const users = request.getModel(request.server.config.db.database, 'users'); //     let userRecord = await users.findOne({ where: { email: request.query.login } }); //   ,     if ( !userRecord ) { throw Boom.unauthorized(); } // ,    if ( !userRecord.verifyPassword(request.query.password) ) { throw Boom.unauthorized();//  ,    ,    } // ,    let token = await accessTokens.createAccessToken(userRecord); //    return { meta: { total: 1 }, data: [ token.dataValues ] }; } //   ,      const tokenScheme = Joi.object({ id: Joi.number().integer().example(1), user_id: Joi.number().integer().example(2), expires_at: Joi.date().example('2019-02-16T15:38:48.243Z'), token: Joi.string().example('4443655c28b42a4349809accb3f5bc71'), updatedAt: Joi.date().example('2019-02-16T15:38:48.243Z'), createdAt: Joi.date().example('2019-02-16T15:38:48.243Z') }); //   const responseScheme = Joi.object({ meta: Joi.object({ total: Joi.number().integer().example(3) }), data: Joi.array().items(tokenScheme) }); //   const requestScheme =Joi.object({ login: Joi.string().email().required().example('pupkin@gmail.com'), password: Joi.string().required().example('12345') }); module.exports = { method: 'GET', path: '/auth', options: { handler: response, validate: { query: requestScheme }, response: { schema: responseScheme } } }; 

परीक्षण:

 curl -X GET "http://localhost:3030/auth?login=pupkin@gmail.com&password=12345" 

अब मेल के बजाय भेजें, केवल लॉगिन करें:

 curl -X GET "http://localhost:3030/auth?login=pupkin&password=12345" 

यदि उत्तर प्रतिक्रिया योजना से मेल नहीं खाता है, तो सर्वर 500 त्रुटि में भी गिर जाएगा।

यदि परियोजना प्रति घंटे 1 से अधिक अनुरोध संसाधित करना शुरू कर देती है, तो प्रतिक्रियाओं के सत्यापन को सीमित करना आवश्यक हो सकता है, जैसा कि सत्यापन एक संसाधन-गहन संचालन है। इसके लिए एक पैरामीटर है: "नमूना"

 module.exports = { method: 'GET', path: '/auth', options: { handler: response, validate: { query: requestScheme }, response: { sample: 50, schema: responseScheme } } }; 

जैसे, केवल 50% अनुरोधों को मान्य प्रतिक्रियाएं मिलेंगी।

डिफ़ॉल्ट मानों और उदाहरणों का वर्णन करना बहुत महत्वपूर्ण है, भविष्य में उनका उपयोग प्रलेखन और ऑटोटेस्ट बनाने के लिए किया जाएगा।

स्वैगर / ओपनएपीआई

हमें अतिरिक्त मॉड्यूल का एक गुच्छा चाहिए:

 npm i hapi-swagger @hapi/inert @hapi/vision 

हम उन्हें server.js से कनेक्ट करते हैं

 ... const Inert = require('@hapi/inert'); const Vision = require('@hapi/vision'); const HapiSwagger = require('hapi-swagger'); const Package = require('../package'); ... const swaggerOptions = { info: { title: Package.name + ' API Documentation', description: Package.description }, jsonPath: '/documentation.json', documentationPath: '/documentation', schemes: ['https', 'http'], host: config.swaggerHost, debug: true }; ... async function createServer(logLVL=config.logLVL) { ... await server.register([ ... Inert, Vision, { plugin: HapiSwagger, options: swaggerOptions }, ... ]); ... }); 

और प्रत्येक मार्ग में आपको "एपीआई" टैग लगाने की आवश्यकता है:

 module.exports = { method: 'GET', path: '/auth', options: { handler: response, tags: [ 'api' ], //    swagger'     validate: { query: requestScheme }, response: { sample: 50, schema: responseScheme } } }; 

अब http: // लोकलहोस्ट: 3030 / डॉक्यूमेंटेशन में वेब-फेस के साथ डॉक्यूमेंटेशन उपलब्ध होगा, और http: // लोकलहोस्ट: 3030 / डॉक्यूमेंटेशन। Json। विवरण के लिए।

ऑटो टेस्ट जनरेशन

यदि हमने गुणात्मक रूप से अनुरोध और प्रतिक्रिया योजनाओं का वर्णन किया है, तो अनुरोध के उदाहरणों में वर्णित उदाहरणों के अनुरूप एक बीज डेटाबेस तैयार किया है, फिर, प्रसिद्ध योजनाओं का उपयोग करके, आप स्वचालित रूप से अनुरोध उत्पन्न कर सकते हैं और सर्वर प्रतिक्रिया कोड की जांच कर सकते हैं।

उदाहरण के लिए, GET में: / सामान्य लॉगिन और पासवर्ड पैरामीटर अपेक्षित हैं, हम उन्हें उन उदाहरणों से लेंगे जिन्हें हमने आरेख में निर्दिष्ट किया है:

 const requestScheme =Joi.object({ login: Joi.string().email().required().example('pupkin@gmail.com'), password: Joi.string().required().example('12345') }); 

और यदि सर्वर HTTP-200-OK के साथ प्रतिक्रिया करता है, तो हम मान लेंगे कि परीक्षण पास हो गया है।

दुर्भाग्य से, कोई तैयार-उपयुक्त उपयुक्त मॉड्यूल नहीं था, आपको थोड़ी सी बात करनी होगी:

 // ./test/autogenerate.js const assert = require('assert'); const rp = require('request-promise'); const filepaths = require('filepaths'); const rsync = require('sync-request'); const config = require('./../config'); const createServer = require('../src/server'); const API_URL = 'http://0.0.0.0:3030'; const AUTH_USER = { login: 'pupkin@gmail.com', pass: '12345' }; const customExamples = { 'string': 'abc', 'number': 2, 'boolean': true, 'any': null, 'date': new Date() }; const allowedStatusCodes = { 200: true, 404: true }; function getExampleValue(joiObj) { if( joiObj == null ) // if joi is null return joiObj; if( typeof(joiObj) != 'object' ) //If it's not joi object return joiObj; if( typeof(joiObj._examples) == 'undefined' ) return customExamples[ joiObj._type ]; if( joiObj._examples.length <= 0 ) return customExamples[ joiObj._type ]; return joiObj._examples[ 0 ].value; } function generateJOIObject(schema) { if( schema._type == 'object' ) return generateJOIObject(schema._inner.children); if( schema._type == 'string' ) return getExampleValue(schema); let result = {}; let _schema; if( Array.isArray(schema) ) { _schema = {}; for(let item of schema) { _schema[ item.key ] = item.schema; } } else { _schema = schema; } for(let fieldName in _schema) { if( _schema[ fieldName ]._type == 'array' ) { result[ fieldName ] = [ generateJOIObject(_schema[ fieldName ]._inner.items[ 0 ]) ]; } else { if( Array.isArray(_schema[ fieldName ]) ) { result[ fieldName ] = getExampleValue(_schema[ fieldName ][ 0 ]); } else if( _schema[ fieldName ]._type == 'object' ) { result[ fieldName ] = generateJOIObject(_schema[ fieldName ]._inner); } else { result[ fieldName ] = getExampleValue(_schema[ fieldName ]); } } } return result } function generateQuiryParams(queryObject) { let queryArray = []; for(let name in queryObject) queryArray.push(`${name}=${queryObject[name]}`); return queryArray.join('&'); } function generatePath(basicPath, paramsScheme) { let result = basicPath; if( !paramsScheme ) return result; let replaces = generateJOIObject(paramsScheme); for(let key in replaces) result = result.replace(`{${key}}`, replaces[ key ]); return result; } function genAuthHeaders() { let result = {}; let respToken = rsync('GET', API_URL + `/auth?login=${AUTH_USER.login}&password=${AUTH_USER.pass}`); let respTokenBody = JSON.parse(respToken.getBody('utf8')); result[ 'token' ] = { Authorization: 'Bearer ' + respTokenBody.data[ 0 ].token }; return result; } function generateRequest(route, authKeys) { if( !route.options.validate ) { return false; } let options = { method: route.method, url: API_URL + generatePath(route.path, route.options.validate.params) + '?' + generateQuiryParams( generateJOIObject(route.options.validate.query || {}) ), headers: authKeys[ route.options.auth ] ? authKeys[ route.options.auth ] : {}, body: generateJOIObject(route.options.validate.payload || {}), json: true, timeout: 15000 } return options; } let authKeys = genAuthHeaders(); let testSec = [ 'POST', 'PUT', 'GET', 'DELETE' ]; let routeList = []; for(let route of filepaths.getSync(__dirname + '/../src/routes/')) routeList.push(require(route)); describe('Autogenerate Hapi Routes TEST', async () => { for(let metod of testSec) for(let testRoute of routeList) { if( testRoute.method != metod ) { continue; } it(`TESTING: ${testRoute.method} ${testRoute.path}`, async function () { let options = generateRequest(testRoute, authKeys); if( !options ) return false; let statusCode = 0; try { let result = await rp( options ); statusCode = 200; } catch(err) { statusCode = err.statusCode; } if( !allowedStatusCodes[ statusCode ] ) { console.log('*** TEST STACK FOR:', `${testRoute.method} ${testRoute.path}`); console.log('options:', options); console.log('StatusCode:', statusCode); } return assert.ok(allowedStatusCodes[ statusCode ]); }); } }); 

निर्भरता के बारे में मत भूलना:

 npm i request-promise mocha sync-request 

और package.json के बारे में

 ... "scripts": { "test": "mocha", "dbinit": "node ./scripts/dbInit.js" }, ... 

हम जाँच करते हैं:

 npm test 

और अगर ताला किसी प्रकार की डेटा योजना है, या उत्तर योजना से मेल नहीं खाता है:

और यह मत भूलो कि जितनी जल्दी या बाद में परीक्षण डेटाबेस में डेटा के प्रति संवेदनशील हो जाएंगे। परीक्षण चलाने से पहले, आपको डेटाबेस को कम से कम पोंछना होगा।

संपूर्ण स्रोत