Hapi.js Ontwikkelomgeving Inrichten met ServBay

Hapi.js is een krachtig en flexibel Node.js-framework voor het bouwen van applicaties en API’s. ServBay biedt Node.js-ontwikkelaars een handige lokale ontwikkelomgeving, met geïntegreerde Node.js-runtime, diverse databases en eenvoudig te configureren webserverfunctionaliteit. In dit artikel leer je hoe je een Hapi.js-project aanmaakt en runt binnen ServBay, de Website-functionaliteit configureert voor toegang, en hoe je verbinding maakt met ingebouwde databases van ServBay.

Wat is Hapi.js?

Hapi.js is een krachtig en flexibel Node.js-framework ontwikkeld door Walmart Labs voor het bouwen van applicaties en diensten. Het staat bekend om zijn sterke plug-insysteem, configuratiegedreven aanpak en ingebouwde beveiligingsvoorzieningen, zodat ontwikkelaars efficiënter hoogwaardige, onderhoudbare webapplicaties en API’s kunnen bouwen.

Belangrijkste Kenmerken en Voordelen van Hapi.js

• Plug-insysteem: Hapi.js beschikt over een krachtig en gebruiksvriendelijk plug-insysteem, waarmee je het framework eenvoudig kunt uitbreiden of applicatielogica in herbruikbare modules kunt organiseren.
• Configuratie eerst: Hapi.js hecht veel waarde aan een configuratiegedreven ontwikkelmethode, waarbij je gedrag zoals routing, validatie en caching via uitgebreide configuratie-opties bepaalt.
• Invoer-validatie: Dankzij de ingebouwde Joi-bibliotheek biedt Hapi.js declaratieve datavalidatie voor optimale dataveiligheid en integriteit.
• Rijke ecosysteem: Er is een actieve community en een breed scala aan officiële én third-party plug-ins voor algemene functies als authenticatie, autorisatie, caching en logging.
• Beveiliging: Het framework komt standaard met meerdere beveiligingsfeatures, zoals inputvalidatie en CORS-controle, voor bescherming tegen veelvoorkomende webdreigingen.
• Loggen & debuggen: Gedetailleerde logs van het request-leven en diverse debugtools zijn standaard aanwezig.

Met Hapi.js kun je als ontwikkelaar focussen op jouw eigen businesslogica, terwijl het framework de complexiteit van HTTP-afhandeling, routing, validatie en security overneemt.

Hapi.js-project opzetten met ServBay

In deze sectie leer je hoe je met de Node.js-omgeving van ServBay een basis Hapi.js-app opzet en draait, en via de Website-functie (reverse proxy) beschikbaar maakt.

Vereisten

Voordat je begint, zorg dat je:

1. ServBay succesvol op macOS hebt geïnstalleerd.
2. Node.js hebt ingeschakeld als Pakket in ServBay. Je vindt en activeert Node.js in het tabblad "Pakketten" van het ServBay-configuratiescherm.
3. De basis van werken in de terminal en het gebruik van Node.js’ npm package manager beheerst.

Hapi.js-project aanmaken

1. Initialiseer de projectmap

   Open de terminal en ga naar de aanbevolen web root directory van ServBay /Applications/ServBay/www. Maak hier een nieuwe projectfolder aan (bijvoorbeeld servbay-hapi-app) en ga naar die directory:

   cd /Applications/ServBay/www
   mkdir servbay-hapi-app
   cd servbay-hapi-app

2. Initialiseer het Node.js-project

   Start een nieuw Node.js-project in je directory met npm:

   npm init -y

   Hiermee wordt een package.json aangemaakt in de hoofdmap van je project.

3. Installeer Hapi.js-afhankelijkheden

   Installeer Hapi.js met npm:

   npm install @hapi/hapi

   Hiermee wordt @hapi/hapi toegevoegd aan je projectafhankelijkheden.

4. Maak het hoofd-bestand van de app

   Maak in de projectroot een bestand server.js en voeg de volgende code toe om een eenvoudige Hapi.js-server op te zetten:

   'use strict'; // Strikte modus aanzetten
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Luister standaard op poort 3000, of gespecificeerd via de PORT-omgevingvariabele
       host: 'localhost' // Luisteren op het lokale loopback-adres
     });
   
     // Definieer een eenvoudige rootroute
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Start de server
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Afhandeling van ongecaptured Promise Rejection fouten
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Proces beëindigen
   });
   
   // Roep de init-functie aan om de app te starten
   init();

   Deze code creëert een Hapi-server die luistert op de opgegeven poort van localhost (standaard 3000) en voorziet in een simpele GET-handler voor het rootpad /.

Ontwikkelmodus starten & ServBay Website configureren

Tijdens de ontwikkeling kun je de Node.js-app direct uitvoeren en met de reverse proxy van ServBay aan een eigen domein koppelen. Je hebt dan HTTPS met een door ServBay uitgegeven certificaat.

1. Start de Hapi.js development server

   Zorg dat je je in de map servbay-hapi-app bevindt en gebruik de node-opdracht om server.js te draaien. Kies bijvoorbeeld poort 8585 om goed samen te werken met ServBay’s proxy:

   PORT=8585 node server.js

   Je ziet dan output als Server running on http://localhost:8585. Laat deze terminal open; de server draait nu actief.

2. Website instellen in ServBay (reverse proxy)

   Open de ServBay-app. Ga naar "Websites", klik linksonder op "+" om een nieuwe site toe te voegen.

   • Naam (Name): ServBay Hapi Dev (of een andere, alleen voor eigen herkenning in ServBay)
   • Domein (Domain): servbay-hapi-dev.servbay.demo (het is aanbevolen een .servbay.demo-domein te gebruiken voor lokaal gebruik en automatisch SSL-certificaat)
   • Type Website (Type): Kies Reverse Proxy
   • Proxy naar (Proxy to):
     • Protocol: http
     • IP Adres: 127.0.0.1 (Node.js-server draait lokaal)
     • Poort (Port): 8585 (de gekozen poort voor node server.js)

   Klik op "Toevoegen" om de site aan te maken. ServBay configureert automatisch de webserver (zoals Caddy of Nginx) zodat verzoeken aan https://servbay-hapi-dev.servbay.demo naar http://127.0.0.1:8585 worden doorgestuurd. Ook wordt automatisch een SSL-certificaat aangemaakt en vertrouwd via ServBay User CA, zodat je lokaal veilig via HTTPS kunt testen.

   Voor meer uitleg: zie de ServBay documentatie over website-configuratie.

3. De Hapi.js-app benaderen via browser

   Open je browser en ga naar het domein https://servbay-hapi-dev.servbay.demo. Je ziet nu de pagina met "Hello from Hapi.js powered by ServBay!".

   Alle wijzigingen die je in server.js aanbrengt (eventueel met hot reload via bijvoorbeeld nodemon) worden direct doorgemapt via ServBay’s reverse proxy.

Productieomgeving opzetten (voorbeeld)

Voor productie kun je een robuuste process manager (zoals PM2) en afwijkende configuratie gebruiken. Een basisvoorbeeld:

1. Draai de Hapi.js productieserver

   Stel een andere poort in (bijv. 8586) en een productieomgevingconfiguratie voor je app:

   PORT=8586 NODE_ENV=production node server.js

   (Let op: In een productiesetting wordt meestal PM2 of een soortgelijke tool gebruikt voor procesbeheer. ServBay ondersteunt integratie met PM2.)

2. Productiewebsite instellen in ServBay (reverse proxy)

   Voeg in het tabblad "Websites" van de ServBay-app nog een site toe via "+":

   • Naam: ServBay Hapi Prod
   • Domein: servbay-hapi-prod.servbay.demo
   • Type: Reverse Proxy
   • Proxy naar:
     • Protocol: http
     • IP-adres: 127.0.0.1
     • Poort: 8586

   Klik op "Toevoegen".

3. De productieversie van Hapi.js testen

   Surf naar https://servbay-hapi-prod.servbay.demo. Je ziet dezelfde output als in de ontwikkelmodus (tenzij je op basis van NODE_ENV andere logica hebt), maar dan gesimuleerd voor productie.

Via de Website-functie van ServBay beheer je eenvoudig meerdere lokale ontwikkel- of gesimuleerde productieomgevingsdomeinen en koppel je ze aan aparte Node.js-instanties op verschillende poorten.

Verbinding maken met databases in ServBay

ServBay biedt standaard diverse database-opties, waaronder MySQL, MariaDB, PostgreSQL, MongoDB en Redis. Hier volgt hoe je deze databases vanuit Hapi.js koppelt.

Belangrijk: Schakel eerst de gewenste databasepakketten in het tabblad "Pakketten" van de ServBay-app in en zorg dat de betreffende databaseservice draait. Je vindt de status in het ServBay-configuratiescherm.

Standaardgebruikers en -wachtwoorden van ServBay databases:

• MySQL/MariaDB: Gebruikersnaam root, wachtwoord password
• PostgreSQL: Gebruikersnaam user, wachtwoord password
• MongoDB: Geen authenticatie vereist (standaard)
• Redis: Geen authenticatie vereist (standaard)

Opmerking: Wijzig om veiligheidsredenen altijd de standaard wachtwoorden van databases in ServBay, zeker buiten een lokale omgeving. Je kunt via ServBay eenvoudig het root-wachtwoord van MySQL, MariaDB en PostgreSQL wijzigen. Zie documentatie database-wachtwoord resetten.

Zie hieronder voorbeeldcode voor het verbinden van de diverse databases. Installeer eerst het benodigde npm client library.

1. MySQL verbinden

   Installeer MySQL-klant:

   npm install mysql2 # of mysql

   Voorbeeldcode voor verbinden (met mysql2):

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // Standaard gebruikersnaam ServBay
     password: 'password', // Standaard wachtwoord ServBay
     database: 'servbay_hapi_app' // Vervang dit door je eigen databasenaam
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Sluit de verbinding indien nodig
   // connection.end();

2. MariaDB verbinden

   Installeer MariaDB-klant:

   npm install mariadb

   Voorbeeld verbindingscode:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // Standaard gebruikersnaam ServBay
     password: 'password', // Standaard wachtwoord ServBay
     database: 'servbay_hapi_app', // Vervang dit door je eigen databasenaam
     connectionLimit: 5 // Grootte van de connection pool
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) voer query’s uit
       conn.release(); // Geef connectie terug aan pool
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. PostgreSQL verbinden

   Installeer PostgreSQL-client:

   npm install pg

   Voorbeeld verbindingscode:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // Standaard gebruikersnaam ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // Vervang dit door je eigen databasenaam
     password: 'password', // Standaard wachtwoord ServBay
     port: 5432, // Standaardpoort PostgreSQL
   });
   
   pool.connect((err, client, done) => {
     if (err) {
       console.error('Error connecting to PostgreSQL: ', err);
       return;
     }
     console.log('Connected to PostgreSQL');
     client.query('SELECT NOW()', (err, res) => {
       done(); // Vrijgeven clientverbinding
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // De pool sluit automatisch bij het afsluiten van de app
   // pool.end();

4. MongoDB verbinden

   Installeer MongoDB-client:

   npm install mongoose # of mongodb

   Voorbeeldcode verbinden via mongoose:

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // Standaard installatie van MongoDB in ServBay vereist geen authenticatie. Indien wel, vul dan authSource, user, pass aan.
     // authSource: 'admin',
     // user: 'your_username',
     // pass: 'your_password',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // Mongoose blijft verbonden gedurende de levensduur van de app
   // Verbinding sluiten: mongoose.connection.close();

5. Redis verbinden

   Installeer Redis-client:

   npm install redis

   Voorbeeldcode verbinden:

   const redis = require('redis');
   // Gebruik standaard connector: host: 'localhost', port: 6379
   const client = redis.createClient();
   
   client.on('error', function (err) {
     console.error('Redis Error: ' + err);
   });
   
   client.on('connect', function () {
     console.log('Redis client connected');
   });
   
   // Maak verbinding met de Redis-server
   client.connect(); // Nodig bij redis v4+
   
   // Voorbeeld: key-value zetten en lezen
   // async function exampleRedisUsage() {
   //   await client.set('mykey', 'myvalue');
   //   const value = await client.get('mykey');
   //   console.log('Value from Redis:', value);
   //   await client.del('mykey');
   // }
   // exampleRedisUsage();
   
   // Sluit verbinding bij app-exit
   // client.quit();

Integreer deze connectievoorbeelden in je Hapi.js-app om eenvoudig alle databaseservices van ServBay lokaal te gebruiken.

Samenvatting

Met ServBay kun je op macOS razendsnel een Hapi.js-ontwikkelomgeving opzetten. ServBay biedt een alles-in-één oplossing: eenvoudig te installeren en te beheren Node.js-runtime, diverse standaard databasetypes, en via de Website-functie (reverse proxy & automatische SSL) een zeer eenvoudige lokale toegang. Door de stappen uit dit artikel te volgen, start je razendsnel met je Hapi.js-project en maak je optimaal gebruik van de krachtige mogelijkheden van ServBay ter versnelling van je ontwikkelproces.