How to use boom - 10 common examples

request.method !== 'HEAD') {

        return callback(Boom.unauthorized('Invalid method', 'Hawk'));
    }

    // No other authentication

    if (request.authorization) {
        return callback(Boom.badRequest('Multiple authentications'));
    }

    // Parse bewit

    var bewitString = Hoek.base64urlDecode(resource[3]);
    if (bewitString instanceof Error) {
        return callback(Boom.badRequest('Invalid bewit encoding'));
    }

    // Bewit format: id\exp\mac\ext ('\' is used because it is a reserved header attribute character)

    var bewitParts = bewitString.split('\\');
    if (bewitParts.length !== 4) {
        return callback(Boom.badRequest('Invalid bewit structure'));
    }

    var bewit = {
        id: bewitParts[0],
        exp: parseInt(bewitParts[1], 10),
        mac: bewitParts[2],
        ext: bewitParts[3] || ''
    };

function mapHandler (req, res) {
  // parse and validate bbox parameter from query
  // See services/BoundingBox.js.
  var paramString = req.query.bbox || '';
  var bbox = new BoundingBox.fromCoordinates(paramString.split(','));
  if (bbox.error) {
    return res(Boom.badRequest(bbox.error));
  }

  queryBbox(knex, bbox)
  .then(function(result) {
    var xmlDoc = XML.write({
      bbox: bbox,
      nodes: result.nodes,
      ways: result.ways,
      relations: result.relations
    });
    var response = res(xmlDoc.toString());
    response.type('text/xml');
  })
  .catch(function (err) {
    return res(Boom.wrap(err));
  });

where: {
        email: { _eq: $email }
      }
    ) {
      id
    }
  }
  `;

  try {
    var hasura_data = await graphql_client.request(query, {
      email,
    });
  } catch (e) {
    console.log(e);
    return next(Boom.badImplementation('Unable to check for duplicates'));
  }

  if (hasura_data.users.length !== 0) {
    return next(Boom.unauthorized('The email is already in use'));
  }

  // generate password_hash
  try {
    var password_hash = await bcrypt.hash(password, 10);
  } catch(e) {
    return next(Boom.badImplementation('Unable to generate password hash'));
  }

  // insert user
  var query = `
  mutation insert_user($user: users_insert_input!) {

update: function(request, reply) {
            // console.log(config.update.access)
            if(request.auth.isAuthenticated && request.auth.credentials.access !== 'admin' && request.auth.credentials.access !== config.update.access) {
                var error = Boom.unauthorized('You do not have update access');

                return reply(error);
            }
            else {
                // Resource ID from URL
                var resourceId = request.params.id;
                var validSchema = config.update.payload;

                if(request.method === 'get') {
                    var payload = request.query;
                } else {
                    var payload = request.payload;
                }

                Joi.validate(payload, validSchema, config.validationOpts, function (err, value) {
                    if(err !== null) {

}
  }
  `;

  let hasura_data;
  try {
    hasura_data = await graphql_client.request(query, {
      refresh_token
    });
  } catch (e) {
    console.error(e);
    return next(Boom.unauthorized("Invalid refresh token request"));
  }

  if (hasura_data[`${schema_name}refresh_tokens`].length === 0) {
    return next(Boom.unauthorized("invalid refresh token"));
  }

  const user = hasura_data[`${schema_name}refresh_tokens`][0].user;
  const user_id = user.id

  // delete current refresh token and generate a new, and insert the
  // new refresh_token in the database
  // two mutations as transaction
  query = `
  mutation (
    $old_refresh_token: uuid!,
    $new_refresh_token_data: refresh_tokens_insert_input!
    $user_id: Int!
  ) {
    delete_${schema_name}refresh_tokens (
      where: {

}
    let workspaceRepo: Repository;
    if (await this.workspaceExists(repositoryUri, revision)) {
      workspaceRepo = await this.updateWorkspace(repositoryUri, revision, targetCommit);
    } else {
      workspaceRepo = await this.cloneWorkspace(bareRepo, repositoryUri, revision);
    }

    const workspaceHeadCommit = await workspaceRepo.getHeadCommit();
    if (workspaceHeadCommit.sha() !== targetCommit.sha()) {
      const commit = await workspaceRepo.getCommit(targetCommit.sha());
      this.log.info(`checkout ${workspaceRepo.workdir()} to commit ${targetCommit.sha()}`);
      // @ts-ignore
      const result = await Reset.reset(workspaceRepo, commit, Reset.TYPE.HARD, {});
      if (result !== undefined && result !== GitError.CODE.OK) {
        throw Boom.internal(`checkout workspace to commit ${targetCommit.sha()} failed.`);
      }
    }
    this.setWorkspaceRevision(workspaceRepo, workspaceHeadCommit);
    return { workspaceRepo, workspaceRevision: workspaceHeadCommit.sha().substring(0, 7) };
  }

server.ext('onPreResponse', (request, reply) => {
    // Only interested in errors
    if (!(request.response instanceof Error)) return reply.continue();

    const error = Boom.wrap(request.response);
    const accept = request.headers.accept || '';

    if (error.output.statusCode >= 500) {
      console.error(error.stack);
    }

    if (accept.indexOf('text/html') === 0) {
      // Respond with an error template
      if (error.output.statusCode === 401) {
        return reply.redirect('/login');
      }

      if (error.output.statusCode === 404) {
        var data = {};
        data.footer = require('../../fixtures/footer');
        data.museums = require('../../fixtures/museums');

.catch((err) => {
      // eslint-disable-next-line no-console
      console.error(err);
      reply(
        Boom.badGateway('Internal error', err)
      );
    });
}

p.catch((e) => {
              console.error(e.stack);  // eslint-disable-line no-console
              console.error(e.toString()); // eslint-disable-line no-console
              reply(Boom.badGateway('server error'));
            });
          }

polka.use(function securityhook(req, res, next) {
	req.authed = false
	
	let doc = {
		ip: security.ip(req.headers),
		uuid: req.cookies['x-uuid'],
		finger: req.cookies['x-finger'],
		useragent: req.headers['user-agent'],
		bits: req.cookies['x-bits'],
		token: req.cookies['x-token'],
	} as Security.Doc
	
	// console.log(`doc ->`, doc)

	let failed = security.isDoc(doc)
	if (failed) return next(boom.preconditionFailed(failed, { hook: 'security' }));
	req.doc = doc

	if (!req.doc.token) return next();
	security.reqDoc(req).then(next).catch(next)

})