Estrategías de autenticación - Asegurando el API REST

No funciona así de “simple” con el @hapi/basic, ya que no valida bien, puedes poner cualquier cosa y valida, porque se equivocó en usar la función de validar de users, que no era validate sino validateUser. Así lo hice:

No es necesario require el basic.

Registrar basic
await server.register(require('@hapi/basic'))

Usamos la estrategia:

server.auth.strategy('simple', 'basic', { validate }) server.auth.default('simple')

Llamamos arriba los modelos de users.
const users = require('../models/index').users

y finalmente la función validate.

`async function validate (req, username, password, h) {
let user

  try {
    user = await users.validateUser({
      email: username,
      password: password
    })
  } catch (error) {
    server.log('error', error)
  }

  return {
    credentials: user || {},
    isValid: (user !== false)
  }
}`

al final en el modelo users se implementó el método validateUser y no validate así que aunque ingresará datos erróneos ingresaría sin problema.

exactamente como dijo @nikosantis

el módulo de autenticación hapi-auth-basic está deprecado se debe usar @hapi/basic y se implementa de la siguiente forma:

await server.register(require('@hapi/basic'));
server.auth.strategy('simple', 'basic', { validate: validateAuth });

la función validateAuth queda igual que en la clase

Alguien sabe como evitar que también pida login para las demás páginas?
Por lo que tengo entendido sólo debería pedir login cuando accedemos a las rutas de la api no de home, register, login, etc

await server.register(require('@hapi/basic'));
    server.auth.strategy('simple', 'basic', { validate }) 
    server.auth.default('simple')

    async function validate (req, username, password, h) {
        let user
        try {
            user = await users.validateUser({
              email: username,
              password: password
            })
          } catch (error) {
            server.log('error', error)
          }
          return {
            credentials: user || {},
            isValid: (user !== false)
          }
    }

'use strict'

const Boom = require('boom')
const authBasic = require('hapi-auth-basic')
const Joi = require('joi')
const questions = require('../models/index').questions
const users = require('../models/index').users


module.exports = {
    name: 'api-rest',
    version: '1.0.0',
    async register (server, options) {
        const prefix = options.prefix || 'api'

        await server.register(authBasic)
        server.auth.strategy('simple', 'basic', { validate: validateAuth})

        server.route({
            method: 'GET',
            path: `/${prefix}/question/{key}`,
            options: {
                auth: 'simple',
                validate: {
                    params: {
                        key: Joi.string().required()
                    },
                    failAction: failValidation
                }
            },
            handler: async (req, h) => {
                let result
                try {
                    result = await questions.getOne(req.params.key)
                    if (!result) {
                        return Boom.notFound(`No se pudo encontrar la pregunta ${req.params.key}`)
                    }
                } catch (error) {
                    return Boom.badImplementation(`Hubo error buscando ${req.params.key} - ${error}`)   
                }
                return result
            }
        })

        server.route({
            method: 'GET',
            path: `/${prefix}/questions/{amount}`,
            options: {
                auth: 'simple',
                validate: {
                    params: {
                        amount: Joi.number().integer().min(1).max(20).required()
                    },
                    failAction: failValidation
                }
            },
            handler: async (req, h) => {
                let result
                try {
                    result = await questions.getLast(req.params.amount)
                    if (!result) {
                        return Boom.notFound(`No se pudo requperar las preguntas`)
                    }
                } catch (error) {
                    return Boom.badImplementation(`Hubo error buscando las preguntas - ${error}`)   
                }
                return result
            }
        })

        function failValidation (req, h, err) {
            return Boom.badRequest('Por favor use los paramtros correctos')
        }

        async function validateAuth(req, username, password, h) {
            let user
            try {
                user = await users.validate({ email: username, password: password })
            } catch (error) {
                server.log('error', error)
            }
            return {
                credentials: user || {},
                isValid: (user != false)
            }
        }
    }
}

Hapi Auth Basic esta deprecado como dice en su documentación.

Pueden usar el equivalente ‘@hapi/basic’ pero en version 5, ya que la version 6 que es la mas nueva, te pide Hapi v18.4, pero no me quiere instalar esa versión, es como si no existira.