Ejemplo API REST en express.js y mongodb

const express = require('express');
const app = express();

app.get('/', function (req, res) {
  res.send('Hello World!');
});

app.listen(3000, function () {
  console.log('Example app listening on port 3000!');
});

PersonModel.findOne({first\_name:"Pedro"})
.then ( data=>{
  console.log(data.first\_name + " " + data.last\_name);
})
.catch ( err=>{
  console.log(err.message);
})

{
  "name": "dps-url-shortener",
  "version": "1.0.0",
  "description": "simple url shortener based on express.js REST API.",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.16.4",
    "dotenv": "^8.0.0",
    "mongodb": "^3.2.4",
    "mongoose": "^5.5.8",
    "cors": "^2.8.5",
    "body-parser": "^1.19.0",
    "shortid": "^2.2.14"
  },
  "engines": {
    "node": "8.x"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/davidpoza/dps-url-shortener.git"
  },
  "author": "David Poza Suárez",
  "license": "ISC",
  "bugs": {
    "url": "https://github.com/davidpoza/dps-url-shortener/issues"
  },
  "homepage": "https://github.com/davidpoza/dps-url-shortener#readme"
}

require('dotenv').config(); //Por si usas Windows. Realiza la lectura y parseo de las variables del fichero .env, disponibles a través de process.env.VAR.
const path = require('path'); //Para componer las rutas abstrayendonos del sistema operativo
const express = require('express'); //framework para manejar las peticiones y respuestas http, parámetros etc.
const mongo = require('mongodb'), //el driver para poder conectar a mongodb
const mongoose = require('mongoose'); //el cliente para poder realizar consultas.
const Schema = mongoose.Schema; //la clase que permite definir "esquemas" de documento
const bodyParser = require('body-parser'); //middleware para poder codificar datos enviados por POST en formato urlencoded, y para poder enviar el payload como json
const cors = require('cors'); //middleware para configurar el CORS (compartición de recursos de origen cruzado) para permitir acceso al API desde dominios externos.
const shortid = require('shortid'); //librería para generar ids únicos de corta longitud a partir de un conjunto de caracteres dado.
const utils = require('./utils'); //modulo nuestro para separar el código de algunas funciones

mongoose.connect(process.env.MONGO\_URI, { useNewUrlParser: true })
.catch((err)=>{console.log(err); process.exit(1)});

let UrlSchema = new Schema({
  \_id: {type:String, required:true},
  originalUrl: {type:String, required:true},
});

let UrlModel = mongoose.model('Url', UrlSchema, 'urls'); //el nombre del modelo es "Url" y el de su colección "urls"

app.use(cors());
app.use(bodyParser.urlencoded({extended:false}));
app.use(bodyParser.json());
app.use('/public', express.static(process.cwd() + '/public'));

/*
endpoint de página index
*/
app.get('/', function(req, res){
  res.sendFile(process.cwd() + '/views/index.html'); //devolvemos un html estático
});

/*
endpoint de redirección
Redirige a la url original
*/
app.get("/api/shorturl/:id", (req,res)=>{
  UrlModel.findById(req.params.id)
  .then((data)=>{
    res.redirect(data.originalUrl);
  })
});

/*
endpoint de acortado de url.
1. Comprueba si la url está correctamente formada y el dominio resuelve correctamente.
2. Comprueba si ya existe un shortcut para esa url en la base de datos, si es así devuelve ese su id.
   Si no existe nada, se crea con un id alteatorio usando la librería shortid.
3. Si algo falla devuelve un json con el error "Invalid URL".
*/
app.post("/api/shorturl/new", (req,res)=>{
  utils.urlValid(req.body.url) //gracias a bodyParser podemos recoger los parametros via POST en req.body
  .then((data)=>{
    return UrlModel.findOne({originalUrl: data})
  })
  .then((data)=>{
    if(!data){ //no existe la url en la db
      let document = new UrlModel({
        _id: shortid.generate(),
        originalUrl: req.body.url,
      });
      return document.save();
    }
    else //ya existe, se devuelve el resultado del find
      return data;
  })
  .then((data)=>{
    res.json({
      original_url: data.originalUrl,
      short_url: data._id
    })
  })
  .catch((err)=>{
    console.log(err);
    res.json({error: "invalid URL"})
  })
});

<!DOCTYPE html>
<html>
   <head>
      <title>URL Shortener</title>
      <link rel="shortcut icon" href="https://cdn.hyperdev.com/us-east-1%3A52a203ff-088b-420f-81be-45bf559d01b1%2Ffavicon.ico" type="image/x-icon"/>
      <link href="https://fonts.googleapis.com/css?family=Roboto" rel="stylesheet" type="text/css">
      <link href="/public/style.css" rel="stylesheet" type="text/css">
      <script type="text/javascript">

        function onSubmit(url){
          fetch(window.location + "api/shorturl/new", {
            method: "POST",
            headers: {
              "Accept": "application/json",
              "Content-Type": "application/json"
            },
            body: JSON.stringify({
              url: url,
            })
          })
          .then(
            (response)=>response.json()
          )
          .then((data)=>{
            if(data.error){
              document.getElementById("result").innerHTML = data.error;
            }
            else{
              document.getElementById("result").innerHTML =
              \`
              The shorten url is:
              <a href='${window.location}api/shorturl/${data.short\_url}'>
                ${window.location}api/shorturl/${data.short\_url}
              </a>
              \`
            }

          })
        }

      </script>
   </head>

   <body>
      <div class="container">
        <h2>API Project: URL Shortener Microservice</h2>
        <div>
          This example works with an express.js API and mongoDB database.
        </div>
        <h3>Short URL Creation </h3>
        <p>
          This page makes a POST request to: <code>/api/shorturl/new</code> with a key with name "url".
        </p>
        <label for="url\_input">URL to be shortened: </label>
        <input id="url\_input" type="text" name="url" value="https://google.es">
        <button onclick="onSubmit(document.getElementById('url\_input').value)">Shorten url</button>

        <div id="result">

        </div>
      </div>
   </body>
</html>

const dns = require('dns'); //forma parte del core de nodejs por lo que no hace falta añadir nada en el packages.json

const utils = {
  /\*
  Valida que la url sea del tipo: http/https://subdominio.dominio.com/ruta/subruta?param=1&param=2.
  Y además trata de resolver el dominio para ver si existe
  \*/
  urlValid: (url)=>{
    let p = new Promise((resolve,reject)=>{
      let regex = /https?:\\/\\/(\[a-zA-Z0-9-.\]\*\[a-z\]{2,6})\[a-zA-Z0-9\_\\-.\\/?=&%+\]\*/;
      if(regex.test(url)){
        let url\_no\_protocol = url.match(regex)\[1\];
        dns.lookup(url\_no\_protocol, (err, address) => {
          if(err!=null){
            reject(err);
          }
          else
            resolve(url);
        });
      }
    });
    return p;
  }
};

module.exports = utils;

let app = express();
let port = process.env.PORT || 3000;
app.listen(port, function () {
  console.log('Node.js listening ...');
});